add fast insert-into-sorted-list utils.

.github/workflows/test.yml

@@ -1,8 +1,7 @@
 name: test every commit
 on:
-  push:
+  - push
-    branches:
+  - pull_request
-      - master
 
 jobs:
   test:

fakejson.test.js

@@ -0,0 +1,35 @@
+/* eslint-env jest */
+
+const {fj} = require('./lib/nostr.cjs')
+
+test('match id', () => {
+  expect(
+    fj.matchEventId(
+      `["EVENT","nostril-query",{"tags":[],"content":"so did we cut all corners and p2p stuff in order to make a decentralized social network that was fast and worked, but in the end what we got was a lot of very slow clients that can't handle the traffic of one jack dorsey tweet?","sig":"ca62629d189edebb8f0811cfa0ac53015013df5f305dcba3f411ba15cfc4074d8c2d517ee7d9e81c9eb72a7328bfbe31c9122156397565ac55e740404e2b1fe7","id":"fef2a50f7d9d3d5a5f38ee761bc087ec16198d3f0140df6d1e8193abf7c2b146","kind":1,"pubkey":"3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d","created_at":1671150419}]`,
+      'fef2a50f7d9d3d5a5f38ee761bc087ec16198d3f0140df6d1e8193abf7c2b146'
+    )
+  ).toBeTruthy()
+
+  expect(
+    fj.matchEventId(
+      `["EVENT","nostril-query",{"content":"a bunch of mfs interacted with my post using what I assume were \"likes\": https://nostr.build/i/964.png","created_at":1672506879,"id":"f40bdd0905137ad60482537e260890ab50b0863bf16e67cf9383f203bd26c96f","kind":1,"pubkey":"3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d","sig":"8b825d2d4096f0643b18ca39da59ec07a682cd8a3e717f119c845037573d98099f5bea94ec7ddedd5600c8020144a255ed52882a911f7f7ada6d6abb3c0a1eb4","tags":[]}]`,
+      'fef2a50f7d9d3d5a5f38ee761bc087ec16198d3f0140df6d1e8193abf7c2b146'
+    )
+  ).toBeFalsy()
+})
+
+test('match kind', () => {
+  expect(
+    fj.matchEventKind(
+      `["EVENT","nostril-query",{"tags":[],"content":"so did we cut all corners and p2p stuff in order to make a decentralized social network that was fast and worked, but in the end what we got was a lot of very slow clients that can't handle the traffic of one jack dorsey tweet?","sig":"ca62629d189edebb8f0811cfa0ac53015013df5f305dcba3f411ba15cfc4074d8c2d517ee7d9e81c9eb72a7328bfbe31c9122156397565ac55e740404e2b1fe7","id":"fef2a50f7d9d3d5a5f38ee761bc087ec16198d3f0140df6d1e8193abf7c2b146","kind":1,"pubkey":"3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d","created_at":1671150419}]`,
+      1
+    )
+  ).toBeTruthy()
+
+  expect(
+    fj.matchEventKind(
+      `["EVENT","nostril-query",{"content":"{\"name\":\"fiatjaf\",\"about\":\"buy my merch at fiatjaf store\",\"picture\":\"https://fiatjaf.com/static/favicon.jpg\",\"nip05\":\"_@fiatjaf.com\"}","created_at":1671217411,"id":"b52f93f6dfecf9d81f59062827cd941412a0e8398dda60baf960b17499b88900","kind":12720,"pubkey":"3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d","sig":"fc1ea5d45fa5ed0526faed06e8fc7a558e60d1b213e9714f440828584ee999b93407092f9b04deea7e504fa034fc0428f31f7f0f95417b3280ebe6004b80b470","tags":[]}]`,
+      12720
+    )
+  ).toBeTruthy()
+})

fakejson.ts

@@ -0,0 +1,26 @@
+export function getHex64(json: string, field: string): string {
+  let len = field.length + 3
+  let idx = json.indexOf(`"${field}":`) + len
+  let s = json.slice(idx).indexOf(`"`) + idx + 1
+  return json.slice(s, s + 64)
+}
+
+export function getInt(json: string, field: string): number {
+  let len = field.length
+  let idx = json.indexOf(`"${field}":`) + len + 3
+  let sliced = json.slice(idx)
+  let end = Math.min(sliced.indexOf(','), sliced.indexOf('}'))
+  return parseInt(sliced.slice(0, end), 10)
+}
+
+export function matchEventId(json: string, id: string): boolean {
+  return id === getHex64(json, 'id')
+}
+
+export function matchEventPubkey(json: string, pubkey: string): boolean {
+  return pubkey === getHex64(json, 'pubkey')
+}
+
+export function matchEventKind(json: string, kind: number): boolean {
+  return kind === getInt(json, 'kind')
+}

index.ts

@@ -9,6 +9,9 @@ export * as nip06 from './nip06'
 export * as nip19 from './nip19'
 export * as nip26 from './nip26'
 
+export * as fj from './fakejson'
+export * as utils from './utils'
+
 // monkey patch secp256k1
 import * as secp256k1 from '@noble/secp256k1'
 import {hmac} from '@noble/hashes/hmac'

package.json

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

relay.ts

@@ -2,6 +2,7 @@
 
 import {Event, verifySignature, validateEvent} from './event'
 import {Filter, matchFilters} from './filter'
+import {getHex64} from './fakejson'
 
 type RelayEvent = 'connect' | 'disconnect' | 'error' | 'notice'
 
@@ -31,10 +32,16 @@ type SubscriptionOptions = {
   id?: string
 }
 
-export function relayInit(url: string): Relay {
+export function relayInit(
+  url: string,
+  alreadyHaveEvent: (id: string) => boolean = () => false
+): Relay {
   var ws: WebSocket
   var resolveClose: () => void
-  var untilOpen: Promise<void>
+  var setOpen: (value: PromiseLike<void> | void) => void
+  var untilOpen = new Promise<void>(resolve => {
+    setOpen = resolve
+  })
   var openSubs: {[id: string]: {filters: Filter[]} & SubscriptionOptions} = {}
   var listeners: {
     connect: Array<() => void>
@@ -67,6 +74,7 @@ export function relayInit(url: string): Relay {
 
       ws.onopen = () => {
         listeners.connect.forEach(cb => cb())
+        setOpen()
         resolve()
       }
       ws.onerror = () => {
@@ -78,19 +86,36 @@ export function relayInit(url: string): Relay {
         resolveClose && resolveClose()
       }
 
-      ws.onmessage = async e => {
+      let incomingMessageQueue: string[] = []
-        var data
+      let handleNextInterval: any
-        try {
+
-          data = JSON.parse(e.data)
+      ws.onmessage = e => {
-        } catch (err) {
+        incomingMessageQueue.push(e.data)
-          data = e.data
+        if (!handleNextInterval) {
+          handleNextInterval = setInterval(handleNext, 0)
+        }
+      }
+
+      function handleNext() {
+        if (incomingMessageQueue.length === 0) {
+          clearInterval(handleNextInterval)
+          handleNextInterval = null
+          return
         }
 
-        if (data.length >= 1) {
+        var json = incomingMessageQueue.shift()
+        if (!json || alreadyHaveEvent(getHex64(json, 'id'))) {
+          return
+        }
+
+        try {
+          let data = JSON.parse(json)
+
+          // we won't do any checks against the data since all failures (i.e. invalid messages from relays)
+          // will naturally be caught by the encompassing try..catch block
+
           switch (data[0]) {
             case 'EVENT':
-              if (data.length !== 3) return // ignore empty or malformed EVENT
-
               let id = data[1]
               let event = data[2]
               if (
@@ -104,13 +129,11 @@ export function relayInit(url: string): Relay {
               }
               return
             case 'EOSE': {
-              if (data.length !== 2) return // ignore empty or malformed EOSE
               let id = data[1]
               ;(subListeners[id]?.eose || []).forEach(cb => cb())
               return
             }
             case 'OK': {
-              if (data.length < 3) return // ignore empty or malformed OK
               let id: string = data[1]
               let ok: boolean = data[2]
               let reason: string = data[3] || ''
@@ -119,11 +142,12 @@ export function relayInit(url: string): Relay {
               return
             }
             case 'NOTICE':
-              if (data.length !== 2) return // ignore empty or malformed NOTICE
               let notice = data[1]
               listeners.notice.forEach(cb => cb(notice))
               return
           }
+        } catch (err) {
+          return
         }
       }
     })
@@ -138,7 +162,11 @@ export function relayInit(url: string): Relay {
     let msg = JSON.stringify(params)
 
     await untilOpen
-    ws.send(msg)
+    try {
+      ws.send(msg)
+    } catch (err) {
+      console.log(err)
+    }
   }
 
   const sub = (
@@ -186,19 +214,13 @@ export function relayInit(url: string): Relay {
   return {
     url,
     sub,
-    on: (
+    on: (type: RelayEvent, cb: any): void => {
-      type: RelayEvent,
-      cb: any
-    ): void => {
       listeners[type].push(cb)
       if (type === 'connect' && ws?.readyState === 1) {
         cb()
       }
     },
-    off: (
+    off: (type: RelayEvent, cb: any): void => {
-      type: RelayEvent,
-      cb: any
-    ): void => {
       let index = listeners[type].indexOf(cb)
       if (index !== -1) listeners[type].splice(index, 1)
     },

utils.test.js

@@ -0,0 +1,183 @@
+/* eslint-env jest */
+
+const {utils} = require('./lib/nostr.cjs')
+
+const {insertEventIntoAscendingList, insertEventIntoDescendingList} = utils
+
+describe('inserting into a desc sorted list of events', () => {
+  test('insert into an empty list', async () => {
+    const list0 = []
+    expect(
+      insertEventIntoDescendingList(list0, {id: 'abc', created_at: 10})
+    ).toHaveLength(1)
+  })
+
+  test('insert in the beginning of a list', async () => {
+    const list0 = [{created_at: 20}, {created_at: 10}]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 30
+    })
+    expect(list1).toHaveLength(3)
+    expect(list1[0].id).toBe('abc')
+  })
+
+  test('insert in the beginning of a list with same created_at', async () => {
+    const list0 = [{created_at: 30}, {created_at: 20}, {created_at: 10}]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 30
+    })
+    expect(list1).toHaveLength(4)
+    expect(list1[0].id).toBe('abc')
+  })
+
+  test('insert in the middle of a list', async () => {
+    const list0 = [
+      {created_at: 30},
+      {created_at: 20},
+      {created_at: 10},
+      {created_at: 1}
+    ]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 15
+    })
+    expect(list1).toHaveLength(5)
+    expect(list1[2].id).toBe('abc')
+  })
+
+  test('insert in the end of a list', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 10}
+    ]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 5
+    })
+    expect(list1).toHaveLength(6)
+    expect(list1.slice(-1)[0].id).toBe('abc')
+  })
+
+  test('insert in the last-to-end of a list with same created_at', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 10}
+    ]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 10
+    })
+    expect(list1).toHaveLength(6)
+    expect(list1.slice(-2)[0].id).toBe('abc')
+  })
+
+  test('do not insert duplicates', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 10, id: 'abc'}
+    ]
+    const list1 = insertEventIntoDescendingList(list0, {
+      id: 'abc',
+      created_at: 10
+    })
+    expect(list1).toHaveLength(3)
+  })
+})
+
+describe('inserting into a asc sorted list of events', () => {
+  test('insert into an empty list', async () => {
+    const list0 = []
+    expect(
+      insertEventIntoAscendingList(list0, {id: 'abc', created_at: 10})
+    ).toHaveLength(1)
+  })
+
+  test('insert in the beginning of a list', async () => {
+    const list0 = [{created_at: 10}, {created_at: 20}]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 1
+    })
+    expect(list1).toHaveLength(3)
+    expect(list1[0].id).toBe('abc')
+  })
+
+  test('insert in the beginning of a list with same created_at', async () => {
+    const list0 = [{created_at: 10}, {created_at: 20}, {created_at: 30}]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 10
+    })
+    expect(list1).toHaveLength(4)
+    expect(list1[0].id).toBe('abc')
+  })
+
+  test('insert in the middle of a list', async () => {
+    const list0 = [
+      {created_at: 10},
+      {created_at: 20},
+      {created_at: 30},
+      {created_at: 40}
+    ]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 25
+    })
+    expect(list1).toHaveLength(5)
+    expect(list1[2].id).toBe('abc')
+  })
+
+  test('insert in the end of a list', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 40}
+    ]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 50
+    })
+    expect(list1).toHaveLength(6)
+    expect(list1.slice(-1)[0].id).toBe('abc')
+  })
+
+  test('insert in the last-to-end of a list with same created_at', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 30}
+    ]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 30
+    })
+    expect(list1).toHaveLength(6)
+    expect(list1.slice(-2)[0].id).toBe('abc')
+  })
+
+  test('do not insert duplicates', async () => {
+    const list0 = [
+      {created_at: 20},
+      {created_at: 20},
+      {created_at: 30, id: 'abc'}
+    ]
+    const list1 = insertEventIntoAscendingList(list0, {
+      id: 'abc',
+      created_at: 30
+    })
+    expect(list1).toHaveLength(3)
+  })
+})

utils.ts

@@ -1,2 +1,97 @@
+import {Event} from './event'
+
 export const utf8Decoder = new TextDecoder('utf-8')
 export const utf8Encoder = new TextEncoder()
+
+//
+// fast insert-into-sorted-array functions adapted from https://github.com/terrymorse58/fast-sorted-array
+//
+export function insertEventIntoDescendingList(
+  sortedArray: Event[],
+  event: Event
+) {
+  let start = 0
+  let end = sortedArray.length - 1
+  let midPoint
+  let position = start
+
+  if (end < 0) {
+    position = 0
+  } else if (event.created_at < sortedArray[end].created_at) {
+    position = end + 1
+  } else if (event.created_at >= sortedArray[start].created_at) {
+    position = start
+  } else
+    while (true) {
+      if (end <= start + 1) {
+        position = end
+        break
+      }
+      midPoint = Math.floor(start + (end - start) / 2)
+      if (sortedArray[midPoint].created_at > event.created_at) {
+        start = midPoint
+      } else if (sortedArray[midPoint].created_at < event.created_at) {
+        end = midPoint
+      } else {
+        // aMidPoint === num
+        position = midPoint
+        break
+      }
+    }
+
+  // insert when num is NOT already in (no duplicates)
+  if (sortedArray[position]?.id !== event.id) {
+    return [
+      ...sortedArray.slice(0, position),
+      event,
+      ...sortedArray.slice(position)
+    ]
+  }
+
+  return sortedArray
+}
+
+export function insertEventIntoAscendingList(
+  sortedArray: Event[],
+  event: Event
+) {
+  let start = 0
+  let end = sortedArray.length - 1
+  let midPoint
+  let position = start
+
+  if (end < 0) {
+    position = 0
+  } else if (event.created_at > sortedArray[end].created_at) {
+    position = end + 1
+  } else if (event.created_at <= sortedArray[start].created_at) {
+    position = start
+  } else
+    while (true) {
+      if (end <= start + 1) {
+        position = end
+        break
+      }
+      midPoint = Math.floor(start + (end - start) / 2)
+      if (sortedArray[midPoint].created_at < event.created_at) {
+        start = midPoint
+      } else if (sortedArray[midPoint].created_at > event.created_at) {
+        end = midPoint
+      } else {
+        // aMidPoint === num
+        position = midPoint
+        break
+      }
+    }
+
+  // insert when num is NOT already in (no duplicates)
+  if (sortedArray[position]?.id !== event.id) {
+    return [
+      ...sortedArray.slice(0, position),
+      event,
+      ...sortedArray.slice(position)
+    ]
+  }
+
+  return sortedArray
+}