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

@@ -120,6 +120,41 @@ To use this on Node.js you first must install `websocket-polyfill` and import it
 import 'websocket-polyfill'
 ```
 
+### Interacting with multiple relays
+
+```js
+import {pool} from 'nostr-tools'
+
+const pool = new SimplePool()
+
+let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
+
+relays.forEach(async url => {
+  let relay = pool.ensureRelay(url)
+  await relay.connect()
+})
+
+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
 
 ```js
@@ -195,7 +230,7 @@ let event = {
 sendEvent(event)
 
 // on the receiver side
-sub.on('event', (event) => {
+sub.on('event', event => {
   let sender = event.tags.find(([k, v]) => k === 'p' && v && v !== '')[1]
   pk1 === sender
   let plaintext = await nip04.decrypt(sk2, pk1, event.content)

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

index.ts

@@ -2,6 +2,7 @@ export * from './keys'
 export * from './relay'
 export * from './event'
 export * from './filter'
+export * from './pool'
 
 export * as nip04 from './nip04'
 export * as nip05 from './nip05'

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.1",
+  "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

@@ -0,0 +1,68 @@
+import {Relay, relayInit} from './relay'
+import {normalizeURL} from './utils'
+import {Filter} from './filter'
+import {Event} from './event'
+import {SubscriptionOptions, Sub, Pub} from './relay'
+
+export class SimplePool {
+  private _conn: {[url: string]: Relay}
+
+  constructor(defaultRelays: string[] = []) {
+    this._conn = {}
+    defaultRelays.forEach(this.ensureRelay)
+  }
+
+  ensureRelay(url: string): Relay {
+    const nm = normalizeURL(url)
+    const existing = this._conn[nm]
+    if (existing) return existing
+
+    const relay = relayInit(nm)
+    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: () => {

utils.ts

@@ -3,6 +3,20 @@ import {Event} from './event'
 export const utf8Decoder = new TextDecoder('utf-8')
 export const utf8Encoder = new TextEncoder()
 
+export function normalizeURL(url: string): string {
+  let p = new URL(url)
+  p.pathname = p.pathname.replace(/\/+/g, '/')
+  if (p.pathname.endsWith('/')) p.pathname = p.pathname.slice(0, -1)
+  if (
+    (p.port === '80' && p.protocol === 'ws:') ||
+    (p.port === '443' && p.protocol === 'wss:')
+  )
+    p.port = ''
+  p.searchParams.sort()
+  p.hash = ''
+  return p.toString()
+}
+
 //
 // fast insert-into-sorted-array functions adapted from https://github.com/terrymorse58/fast-sorted-array
 //