fix just.

now pools are much smarter.

.github/workflows/npm-publish.yml

@@ -12,9 +12,10 @@ jobs:
       - uses: actions/setup-node@v3
         with:
           node-version: 18
-      - run: yarn --ignore-engines
+      - uses: extractions/setup-just@v1
-      - run: node build.js
+      - run: just install-dependencies
-      - run: yarn test
+      - run: just build
+      - run: just test
       - uses: JS-DevTools/npm-publish@v1
         with:
           token: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -11,6 +11,7 @@ jobs:
       - uses: actions/setup-node@v3
         with:
           node-version: 18
-      - run: yarn --ignore-engines
+      - uses: extractions/setup-just@v1
-      - run: node build.js
+      - run: just install-dependencies
-      - run: yarn test
+      - run: just build
+      - run: just test

README.md

@@ -125,15 +125,34 @@ import 'websocket-polyfill'
 ```js
 import {pool} from 'nostr-tools'
 
-const p = pool()
+const pool = new SimplePool()
 
-["wss://relay.example.com", "wss://relay.example2.com"].forEach(async url => {
+let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
+
+relays.forEach(async url => {
   let relay = pool.ensureRelay(url)
   await relay.connect()
-
-  relay.sub(...) // same as above
-  relay.publish(...) // etc
 })
+
+let relay = pool.ensureRelay('wss://relay.example3.com')
+
+let subs = pool.sub([...relays, relay], {
+  authors: ['32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
+})
+
+subs.forEach(sub =>
+  sub.on('event', event => {
+    // this will only be called once the first time the event is received
+    // ...
+  })
+)
+
+let pubs = pool.publish(newEvent)
+pubs.forEach(pub =>
+  pub.on('ok', () => {
+    // ...
+  })
+)
 ```
 
 ### Querying profile data from a NIP-05 address

fakejson.test.js

@@ -33,3 +33,17 @@ test('match kind', () => {
     )
   ).toBeTruthy()
 })
+
+test('match subscription id', () => {
+  expect(fj.getSubscriptionId('["EVENT","",{}]')).toEqual('')
+  expect(fj.getSubscriptionId('["EVENT","_",{}]')).toEqual('_')
+  expect(fj.getSubscriptionId('["EVENT","subname",{}]')).toEqual('subname')
+  expect(fj.getSubscriptionId('["EVENT", "kasjbdjkav", {}]')).toEqual(
+    'kasjbdjkav'
+  )
+  expect(
+    fj.getSubscriptionId(
+      '  [ \n\n "EVENT"  , \n\n "y4d5ow45gfwoiudfÇA VSADLKAN KLDASB[12312535]SFMZSNJKLH" , {}]'
+    )
+  ).toEqual('y4d5ow45gfwoiudfÇA VSADLKAN KLDASB[12312535]SFMZSNJKLH')
+})

fakejson.ts

@@ -13,6 +13,21 @@ export function getInt(json: string, field: string): number {
   return parseInt(sliced.slice(0, end), 10)
 }
 
+export function getSubscriptionId(json: string): string | null {
+  let idx = json.slice(0, 22).indexOf(`"EVENT"`)
+  if (idx === -1) return null
+
+  let pstart = json.slice(idx + 7 + 1).indexOf(`"`)
+  if (pstart === -1) return null
+  let start = idx + 7 + 1 + pstart
+
+  let pend = json.slice(start + 1, 80).indexOf(`"`)
+  if (pend === -1) return null
+  let end = start + 1 + pend
+
+  return json.slice(start + 1, end)
+}
+
 export function matchEventId(json: string, id: string): boolean {
   return id === getHex64(json, 'id')
 }

justfile

@@ -0,0 +1,13 @@
+export PATH := "./node_modules/.bin:" + env_var('PATH')
+
+install-dependencies:
+    yarn --ignore-engines
+
+build:
+    node build.js
+
+test: build
+    jest
+
+testOnly file: build
+    jest {{file}}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -38,10 +38,5 @@
     "tsd": "^0.22.0",
     "typescript": "^4.9.4",
     "websocket-polyfill": "^0.0.3"
-  },
-  "scripts": {
-    "build": "node build.js",
-    "pretest": "node build.js",
-    "test": "jest"
   }
 }

pool.test.js

@@ -0,0 +1,119 @@
+/* eslint-env jest */
+
+require('websocket-polyfill')
+const {
+  SimplePool,
+  generatePrivateKey,
+  getPublicKey,
+  getEventHash,
+  signEvent
+} = require('./lib/nostr.cjs')
+
+let pool = new SimplePool()
+
+let relays = [
+  'wss://nostr-dev.wellorder.net/',
+  'wss://relay.nostr.bg/',
+  'wss://nostr.fmt.wiz.biz/',
+  'wss://relay.nostr.band/',
+  'wss://nostr.zebedee.cloud/'
+]
+
+beforeAll(async () => {
+  Promise.all(
+    relays.map(relay => {
+      try {
+        let r = pool.ensureRelay(relay)
+        return r.connect()
+      } catch (err) {
+        /***/
+      }
+    })
+  )
+})
+
+afterAll(async () => {
+  relays.forEach(relay => {
+    try {
+      let r = pool.ensureRelay(relay)
+      r.close()
+    } catch (err) {
+      /***/
+    }
+  })
+})
+
+test('removing duplicates when querying', async () => {
+  let priv = generatePrivateKey()
+  let pub = getPublicKey(priv)
+
+  let subs = pool.sub(relays, [
+    {
+      authors: [pub]
+    }
+  ])
+
+  let received = []
+
+  subs.forEach(sub =>
+    sub.on('event', event => {
+      // this should be called only once even though we're listening
+      // to multiple relays because the events will be catched and
+      // deduplicated efficiently (without even being parsed)
+      received.push(event)
+    })
+  )
+
+  let event = {
+    pubkey: pub,
+    created_at: Math.round(Date.now() / 1000),
+    content: 'test',
+    kind: 22345,
+    tags: []
+  }
+  event.id = getEventHash(event)
+  event.sig = signEvent(event, priv)
+
+  pool.publish(relays, event)
+
+  await new Promise(resolve => setTimeout(resolve, 1500))
+
+  expect(received).toHaveLength(1)
+})
+
+test('removing duplicates correctly when double querying', async () => {
+  let priv = generatePrivateKey()
+  let pub = getPublicKey(priv)
+
+  let subs1 = pool.sub(relays, [{authors: [pub]}])
+  let subs2 = pool.sub(relays, [{authors: [pub]}])
+
+  let received = []
+
+  subs1.forEach(sub =>
+    sub.on('event', event => {
+      received.push(event)
+    })
+  )
+  subs2.forEach(sub =>
+    sub.on('event', event => {
+      received.push(event)
+    })
+  )
+
+  let event = {
+    pubkey: pub,
+    created_at: Math.round(Date.now() / 1000),
+    content: 'test2',
+    kind: 22346,
+    tags: []
+  }
+  event.id = getEventHash(event)
+  event.sig = signEvent(event, priv)
+
+  pool.publish(relays, event)
+
+  await new Promise(resolve => setTimeout(resolve, 1500))
+
+  expect(received).toHaveLength(2)
+})

pool.ts

@@ -1,15 +1,13 @@
 import {Relay, relayInit} from './relay'
 import {normalizeURL} from './utils'
+import {Filter} from './filter'
+import {Event} from './event'
+import {SubscriptionOptions, Sub, Pub} from './relay'
 
-export function pool(defaultRelays: string[] = []) {
+export class SimplePool {
-  return new SimplePool(defaultRelays)
-}
-
-class SimplePool {
   private _conn: {[url: string]: Relay}
-  private _knownIds: Set<string> = new Set()
 
-  constructor(defaultRelays: string[]) {
+  constructor(defaultRelays: string[] = []) {
     this._conn = {}
     defaultRelays.forEach(this.ensureRelay)
   }
@@ -19,9 +17,52 @@ class SimplePool {
     const existing = this._conn[nm]
     if (existing) return existing
 
-    const hasEventId = (id: string): boolean => this._knownIds.has(id)
+    const relay = relayInit(nm)
-    const relay = relayInit(nm, hasEventId)
     this._conn[nm] = relay
+
     return relay
   }
+
+  sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub[] {
+    let _knownIds: Set<string> = new Set()
+    let modifiedOpts = opts || {}
+    modifiedOpts.alreadyHaveEvent = id => _knownIds.has(id)
+
+    return relays.map(relay => {
+      let r = this._conn[relay]
+      if (!r) return badSub()
+      let s = r.sub(filters, modifiedOpts)
+      s.on('event', (event: Event) => _knownIds.add(event.id as string))
+      return s
+    })
+  }
+
+  publish(relays: string[], event: Event): Pub[] {
+    return relays.map(relay => {
+      let r = this._conn[relay]
+      if (!r) return badPub(relay)
+      let s = r.publish(event)
+      return s
+    })
+  }
+}
+
+function badSub(): Sub {
+  return {
+    on() {},
+    off() {},
+    sub(): Sub {
+      return badSub()
+    },
+    unsub() {}
+  }
+}
+
+function badPub(relay: string): Pub {
+  return {
+    on(typ, cb) {
+      if (typ === 'failed') cb(`relay ${relay} not connected`)
+    },
+    off() {}
+  }
 }

relay.ts

@@ -2,7 +2,7 @@
 
 import {Event, verifySignature, validateEvent} from './event'
 import {Filter, matchFilters} from './filter'
-import {getHex64} from './fakejson'
+import {getHex64, getSubscriptionId} from './fakejson'
 
 type RelayEvent = 'connect' | 'disconnect' | 'error' | 'notice'
 
@@ -27,15 +27,13 @@ export type Sub = {
   off: (type: 'event' | 'eose', cb: any) => void
 }
 
-type SubscriptionOptions = {
+export type SubscriptionOptions = {
   skipVerification?: boolean
+  alreadyHaveEvent?: null | ((id: string) => boolean)
   id?: string
 }
 
-export function relayInit(
+export function relayInit(url: string): Relay {
-  url: string,
-  alreadyHaveEvent: (id: string) => boolean = () => false
-): Relay {
   var ws: WebSocket
   var resolveClose: () => void
   var setOpen: (value: PromiseLike<void> | void) => void
@@ -46,7 +44,7 @@ export function relayInit(
   var listeners: {
     connect: Array<() => void>
     disconnect: Array<() => void>
-    error: Array<(e: globalThis.Event) => void>
+    error: Array<() => void>
     notice: Array<(msg: string) => void>
   } = {
     connect: [],
@@ -77,9 +75,9 @@ export function relayInit(
         setOpen()
         resolve()
       }
-      ws.onerror = (e: globalThis.Event) => {
+      ws.onerror = () => {
-        listeners.error.forEach(cb => cb(e))
+        listeners.error.forEach(cb => cb())
-        reject(e)
+        reject()
       }
       ws.onclose = async () => {
         listeners.disconnect.forEach(cb => cb())
@@ -104,8 +102,14 @@ export function relayInit(
         }
 
         var json = incomingMessageQueue.shift()
-        if (!json || alreadyHaveEvent(getHex64(json, 'id'))) {
+        if (!json) return
-          return
+
+        let subid = getSubscriptionId(json)
+        if (subid) {
+          let {alreadyHaveEvent} = openSubs[subid]
+          if (alreadyHaveEvent && alreadyHaveEvent(getHex64(json, 'id'))) {
+            return
+          }
         }
 
         try {
@@ -173,6 +177,7 @@ export function relayInit(
     filters: Filter[],
     {
       skipVerification = false,
+      alreadyHaveEvent = null,
       id = Math.random().toString().slice(2)
     }: SubscriptionOptions = {}
   ): Sub => {
@@ -181,7 +186,8 @@ export function relayInit(
     openSubs[subid] = {
       id: subid,
       filters,
-      skipVerification
+      skipVerification,
+      alreadyHaveEvent
     }
     trySend(['REQ', subid, ...filters])
 
@@ -189,6 +195,7 @@ export function relayInit(
       sub: (newFilters, newOpts = {}) =>
         sub(newFilters || filters, {
           skipVerification: newOpts.skipVerification || skipVerification,
+          alreadyHaveEvent: newOpts.alreadyHaveEvent || alreadyHaveEvent,
           id: subid
         }),
       unsub: () => {