bump noble-hashes.

Small fix of import SimplePool in new multiple relay docs.

.github/workflows/test.yml

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

README.md

@@ -128,18 +128,13 @@ import 'websocket-polyfill'
 ### Interacting with multiple relays
 
 ```js
-import {pool} from 'nostr-tools'
+import {SimplePool} 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 relay = await pool.ensureRelay('wss://relay.example3.com')
 
 let subs = pool.sub([...relays, relay], {
   authors: ['32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
@@ -163,6 +158,11 @@ let events = await pool.list(relays, [{kinds: [0, 1]}])
 let event = await pool.get(relays, {
   ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
 })
+
+let relaysForEvent = pool.seenOn(
+  '44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'
+)
+// relaysForEvent will be an array of URLs from relays a given event was seen on
 ```
 
 ### Querying profile data from a NIP-05 address
@@ -293,6 +293,11 @@ Please consult the tests or [the source code](https://github.com/fiatjaf/nostr-t
 </script>
 ```
 
+## Plumbing
+
+1. Install [`just`](https://just.systems/)
+2. `just -l`
+
 ## License
 
 Public domain.

justfile

@@ -11,3 +11,6 @@ test: build
 
 testOnly file: build
     jest {{file}}
+
+publish: build
+    npm publish

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -9,11 +9,12 @@
   "main": "lib/nostr.cjs.js",
   "module": "lib/nostr.esm.js",
   "dependencies": {
-    "@noble/hashes": "^0.5.7",
-    "@noble/secp256k1": "^1.7.0",
+    "@noble/hashes": "1.0.0",
+    "@noble/secp256k1": "^1.7.1",
     "@scure/base": "^1.1.1",
-    "@scure/bip32": "^1.1.1",
-    "@scure/bip39": "^1.1.0"
+    "@scure/bip32": "^1.1.5",
+    "@scure/bip39": "^1.1.1",
+    "prettier": "^2.8.4"
   },
   "keywords": [
     "decentralization",
@@ -23,20 +24,20 @@
     "nostr"
   ],
   "devDependencies": {
-    "@types/node": "^18.0.3",
-    "@typescript-eslint/eslint-plugin": "^5.46.1",
-    "@typescript-eslint/parser": "^5.46.1",
+    "@types/node": "^18.13.0",
+    "@typescript-eslint/eslint-plugin": "^5.51.0",
+    "@typescript-eslint/parser": "^5.51.0",
     "esbuild": "0.16.9",
     "esbuild-plugin-alias": "^0.2.1",
-    "eslint": "^8.30.0",
+    "eslint": "^8.33.0",
     "eslint-plugin-babel": "^5.3.1",
-    "esm-loader-typescript": "^1.0.1",
+    "esm-loader-typescript": "^1.0.3",
     "events": "^3.3.0",
-    "jest": "^29.3.1",
-    "node-fetch": "2",
-    "ts-jest": "^29.0.3",
+    "jest": "^29.4.2",
+    "node-fetch": "^2.6.9",
+    "ts-jest": "^29.0.5",
     "tsd": "^0.22.0",
-    "typescript": "^4.9.4",
+    "typescript": "^4.9.5",
     "websocket-polyfill": "^0.0.3"
   }
 }

pool.test.js

@@ -19,50 +19,28 @@ let relays = [
   '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) {
-      /***/
-    }
-  })
+  await pool.close([
+    ...relays,
+    'wss://nostr-relay.untethr.me',
+    'wss://offchain.pub',
+    'wss://eden.nostr.land'
+  ])
 })
 
 test('removing duplicates when querying', async () => {
   let priv = generatePrivateKey()
   let pub = getPublicKey(priv)
 
-  let subs = pool.sub(relays, [
-    {
-      authors: [pub]
-    }
-  ])
-
+  let sub = 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)
-    })
-  )
+  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,
@@ -81,25 +59,22 @@ test('removing duplicates when querying', async () => {
   expect(received).toHaveLength(1)
 })
 
-test('removing duplicates correctly when double querying', async () => {
+test('same with 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 sub1 = pool.sub(relays, [{authors: [pub]}])
+  let sub2 = 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)
-    })
-  )
+  sub1.on('event', event => {
+    received.push(event)
+  })
+
+  sub2.on('event', event => {
+    received.push(event)
+  })
 
   let event = {
     pubkey: pub,
@@ -117,3 +92,42 @@ test('removing duplicates correctly when double querying', async () => {
 
   expect(received).toHaveLength(2)
 })
+
+test('get()', async () => {
+  let event = await pool.get(relays, {
+    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027']
+  })
+
+  expect(event).toHaveProperty(
+    'id',
+    'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'
+  )
+})
+
+test('list()', async () => {
+  let events = await pool.list(
+    [...relays, 'wss://offchain.pub', 'wss://eden.nostr.land'],
+    [
+      {
+        authors: [
+          '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'
+        ],
+        kinds: [1],
+        limit: 2
+      }
+    ]
+  )
+
+  // the actual received number will be greater than 2, but there will be no duplicates
+  expect(events.length).toEqual(
+    events
+      .map(evt => evt.id)
+      .reduce((acc, n) => (acc.indexOf(n) !== -1 ? acc : [...acc, n]), [])
+      .length
+  )
+
+  let relaysForAllEvents = events
+    .map(event => pool.seenOn(event.id))
+    .reduce((acc, n) => acc.concat(n), [])
+  expect(relaysForAllEvents.length).toBeGreaterThanOrEqual(events.length)
+})

pool.ts

@@ -6,13 +6,22 @@ import {SubscriptionOptions, Sub, Pub} from './relay'
 
 export class SimplePool {
   private _conn: {[url: string]: Relay}
+  private _seenOn: {[id: string]: Set<string>} = {} // a map of all events we've seen in each relay
 
-  constructor(defaultRelays: string[] = []) {
+  constructor() {
     this._conn = {}
-    defaultRelays.forEach(this.ensureRelay)
   }
 
-  ensureRelay(url: string): Relay {
+  async close(relays: string[]): Promise<void> {
+    await Promise.all(
+      relays.map(async url => {
+        let relay = this._conn[normalizeURL(url)]
+        if (relay) await relay.close()
+      })
+    )
+  }
+
+  async ensureRelay(url: string): Promise<Relay> {
     const nm = normalizeURL(url)
     const existing = this._conn[nm]
     if (existing) return existing
@@ -20,21 +29,78 @@ export class SimplePool {
     const relay = relayInit(nm)
     this._conn[nm] = relay
 
+    await relay.connect()
+
     return relay
   }
 
-  sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub[] {
+  sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub {
     let _knownIds: Set<string> = new Set()
     let modifiedOpts = opts || {}
-    modifiedOpts.alreadyHaveEvent = id => _knownIds.has(id)
+    modifiedOpts.alreadyHaveEvent = (id, url) => {
+      let set = this._seenOn[id] || new Set()
+      set.add(url)
+      this._seenOn[id] = set
+      return _knownIds.has(id)
+    }
 
-    return relays.map(relay => {
-      let r = this._conn[relay]
-      if (!r) return badSub()
+    let subs: Sub[] = []
+    let eventListeners: Set<(event: Event) => void> = new Set()
+    let eoseListeners: Set<() => void> = new Set()
+    let eosesMissing = relays.length
+
+    let eoseSent = false
+    let eoseTimeout = setTimeout(() => {
+      eoseSent = true
+      for (let cb of eoseListeners.values()) cb()
+    }, 2400)
+
+    relays.forEach(async relay => {
+      let r = await this.ensureRelay(relay)
+      if (!r) return
       let s = r.sub(filters, modifiedOpts)
-      s.on('event', (event: Event) => _knownIds.add(event.id as string))
-      return s
+      s.on('event', (event: Event) => {
+        _knownIds.add(event.id as string)
+        for (let cb of eventListeners.values()) cb(event)
+      })
+      s.on('eose', () => {
+        if (eoseSent) return
+
+        eosesMissing--
+        if (eosesMissing === 0) {
+          clearTimeout(eoseTimeout)
+          for (let cb of eoseListeners.values()) cb()
+        }
+      })
+      subs.push(s)
     })
+
+    let greaterSub: Sub = {
+      sub(filters, opts) {
+        subs.forEach(sub => sub.sub(filters, opts))
+        return greaterSub
+      },
+      unsub() {
+        subs.forEach(sub => sub.unsub())
+      },
+      on(type, cb) {
+        switch (type) {
+          case 'event':
+            eventListeners.add(cb)
+            break
+          case 'eose':
+            eoseListeners.add(cb)
+            break
+        }
+      },
+      off(type, cb) {
+        if (type === 'event') {
+          eventListeners.delete(cb)
+        } else if (type === 'eose') eoseListeners.delete(cb)
+      }
+    }
+
+    return greaterSub
   }
 
   get(
@@ -43,19 +109,15 @@ export class SimplePool {
     opts?: SubscriptionOptions
   ): Promise<Event | null> {
     return new Promise(resolve => {
-      let subs = this.sub(relays, [filter], opts)
+      let sub = this.sub(relays, [filter], opts)
       let timeout = setTimeout(() => {
-        subs.forEach(sub => sub.unsub(), 1500)
+        sub.unsub()
         resolve(null)
-      })
-      subs.forEach(sub => {
-        sub.on('event', (event: Event) => {
-          resolve(event)
-          clearTimeout(timeout)
-          subs.forEach(sub => {
-            sub.unsub()
-          })
-        })
+      }, 1500)
+      sub.on('event', (event: Event) => {
+        resolve(event)
+        clearTimeout(timeout)
+        sub.unsub()
       })
     })
   }
@@ -66,57 +128,32 @@ export class SimplePool {
     opts?: SubscriptionOptions
   ): Promise<Event[]> {
     return new Promise(resolve => {
-      let _knownIds: Set<string> = new Set()
-      let modifiedOpts = opts || {}
-      modifiedOpts.alreadyHaveEvent = id => _knownIds.has(id)
-
       let events: Event[] = []
+      let sub = this.sub(relays, filters, opts)
 
-      let subs = this.sub(relays, filters, modifiedOpts)
-      let timeout = setTimeout(() => {
-        subs.forEach(sub => sub.unsub(), 1500)
-        resolve(events)
+      sub.on('event', (event: Event) => {
+        events.push(event)
       })
 
-      let pendingEoses = relays.length
-
-      subs.forEach(sub => {
-        sub.on('event', (event: Event) => {
-          events.push(event)
-        })
-
-        sub.on('eose', () => {
-          pendingEoses--
-          if (pendingEoses === 0) {
-            resolve(events)
-            clearTimeout(timeout)
-            subs.forEach(sub => {
-              sub.unsub()
-            })
-          }
-        })
+      // we can rely on an eose being emitted here because pool.sub() will fake one
+      sub.on('eose', () => {
+        sub.unsub()
+        resolve(events)
       })
     })
   }
 
   publish(relays: string[], event: Event): Pub[] {
     return relays.map(relay => {
-      let r = this._conn[relay]
+      let r = this._conn[normalizeURL(relay)]
       if (!r) return badPub(relay)
       let s = r.publish(event)
       return s
     })
   }
-}
 
-function badSub(): Sub {
-  return {
-    on() {},
-    off() {},
-    sub(): Sub {
-      return badSub()
-    },
-    unsub() {}
+  seenOn(id: string): string[] {
+    return Array.from(this._seenOn[id]?.values?.() || [])
   }
 }
 

relay.test.js

@@ -32,7 +32,7 @@ test('connectivity', () => {
   ).resolves.toBe(true)
 })
 
-test('querying', () => {
+test('querying', async () => {
   var resolve1
   var resolve2
 
@@ -52,16 +52,42 @@ test('querying', () => {
     resolve2(true)
   })
 
-  return expect(
-    Promise.all([
-      new Promise(resolve => {
-        resolve1 = resolve
-      }),
-      new Promise(resolve => {
-        resolve2 = resolve
-      })
-    ])
-  ).resolves.toEqual([true, true])
+  let [t1, t2] = await Promise.all([
+    new Promise(resolve => {
+      resolve1 = resolve
+    }),
+    new Promise(resolve => {
+      resolve2 = resolve
+    })
+  ])
+
+  expect(t1).toEqual(true)
+  expect(t2).toEqual(true)
+})
+
+test('get()', async () => {
+  let event = await relay.get({
+    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027']
+  })
+
+  expect(event).toHaveProperty(
+    'id',
+    'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'
+  )
+})
+
+test('list()', async () => {
+  let events = await relay.list([
+    {
+      authors: [
+        '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'
+      ],
+      kinds: [1],
+      limit: 2
+    }
+  ])
+
+  expect(events.length).toEqual(2)
 })
 
 test('listening (twice) and publishing', async () => {

relay.ts

@@ -30,9 +30,9 @@ export type Sub = {
 }
 
 export type SubscriptionOptions = {
-  skipVerification?: boolean
-  alreadyHaveEvent?: null | ((id: string) => boolean)
   id?: string
+  skipVerification?: boolean
+  alreadyHaveEvent?: null | ((id: string, relay: string) => boolean)
 }
 
 export function relayInit(url: string): Relay {
@@ -108,8 +108,12 @@ export function relayInit(url: string): Relay {
 
         let subid = getSubscriptionId(json)
         if (subid) {
-          let {alreadyHaveEvent} = openSubs[subid]
-          if (alreadyHaveEvent && alreadyHaveEvent(getHex64(json, 'id'))) {
+          let so = openSubs[subid]
+          if (
+            so &&
+            so.alreadyHaveEvent &&
+            so.alreadyHaveEvent(getHex64(json, 'id'), url)
+          ) {
             return
           }
         }
@@ -320,6 +324,7 @@ export function relayInit(url: string): Relay {
     },
     connect,
     close(): Promise<void> {
+      if (ws.readyState > 1) return Promise.resolve()
       ws.close()
       return new Promise<void>(resolve => {
         resolveClose = resolve