fix tests, .seenOn() method for pools.

.github/workflows/npm-publish.yml

@@ -16,7 +16,6 @@ jobs:
       - run: just install-dependencies
       - run: just build
       - run: just test
-      - run: just emit-types
       - uses: JS-DevTools/npm-publish@v1
         with:
           token: ${{ secrets.NPM_TOKEN }}

.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - uses: actions/setup-node@v3
         with:
           node-version: 18

README.md

@@ -4,12 +4,6 @@ Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 Only depends on _@scure_ and _@noble_ packages.
 
-## Installation
-
-```bash
- npm install nostr-tools # or yarn add nostr-tools
-```
-
 ## Usage
 
 ### Generating a private key and a public key
@@ -59,6 +53,8 @@ import {
 } from 'nostr-tools'
 
 const relay = relayInit('wss://relay.example.com')
+await relay.connect()
+
 relay.on('connect', () => {
   console.log(`connected to ${relay.url}`)
 })
@@ -66,8 +62,6 @@ relay.on('error', () => {
   console.log(`failed to connect to ${relay.url}`)
 })
 
-await relay.connect()
-
 // let's query for an event that exists
 let sub = relay.sub([
   {
@@ -110,6 +104,9 @@ let pub = relay.publish(event)
 pub.on('ok', () => {
   console.log(`${relay.url} has accepted our event`)
 })
+pub.on('seen', () => {
+  console.log(`we saw the event on ${relay.url}`)
+})
 pub.on('failed', reason => {
   console.log(`failed to publish to ${relay.url}: ${reason}`)
 })
@@ -119,7 +116,7 @@ let event = await relay.get({
   ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
 })
 
-relay.close()
+await relay.close()
 ```
 
 To use this on Node.js you first must install `websocket-polyfill` and import it:
@@ -131,33 +128,31 @@ import 'websocket-polyfill'
 ### Interacting with multiple relays
 
 ```js
-import {SimplePool} from 'nostr-tools'
+import {pool} from 'nostr-tools'
 
 const pool = new SimplePool()
 
 let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
 
-let sub = pool.sub(
-  [...relays, 'wss://relay.example3.com'],
-  [
-    {
-      authors: [
-        '32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'
-      ]
-    }
-  ]
+let relay = await 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
+    // ...
+  })
 )
 
-sub.on('event', event => {
-  // this will only be called once the first time the event is received
-  // ...
-})
-
 let pubs = pool.publish(relays, newEvent)
-pubs.on('ok', () => {
-  // this may be called multiple times, once for every relay that accepts the event
-  // ...
-})
+pubs.forEach(pub =>
+  pub.on('ok', () => {
+    // ...
+  })
+)
 
 let events = await pool.list(relays, [{kinds: [0, 1]}])
 let event = await pool.get(relays, {
@@ -298,11 +293,6 @@ 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.

build.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-const fs = require('fs')
 const esbuild = require('esbuild')
 
 let common = {
@@ -12,16 +11,11 @@ let common = {
 esbuild
   .build({
     ...common,
-    outfile: 'lib/esm/nostr.mjs',
+    outfile: 'lib/nostr.esm.js',
     format: 'esm',
     packages: 'external'
   })
-  .then(() => {
-    const packageJson = JSON.stringify({type: 'module'})
-    fs.writeFileSync(`${__dirname}/lib/esm/package.json`, packageJson, 'utf8')
-
-    console.log('esm build success.')
-  })
+  .then(() => console.log('esm build success.'))
 
 esbuild
   .build({

event.ts

@@ -2,7 +2,6 @@ import * as secp256k1 from '@noble/secp256k1'
 import {sha256} from '@noble/hashes/sha256'
 
 import {utf8Encoder} from './utils'
-import {getPublicKey} from './keys'
 
 /* eslint-disable no-unused-vars */
 export enum Kind {
@@ -17,49 +16,30 @@ export enum Kind {
   ChannelMetadata = 41,
   ChannelMessage = 42,
   ChannelHideMessage = 43,
-  ChannelMuteUser = 44,
-  Report = 1984,
-  ZapRequest = 9734,
-  Zap = 9735,
-  RelayList = 10002,
-  ClientAuth = 22242,
-  Article = 30023
+  ChannelMuteUser = 44
 }
 
-export type EventTemplate = {
+export type Event = {
+  id?: string
+  sig?: string
   kind: Kind
   tags: string[][]
+  pubkey: string
   content: string
   created_at: number
 }
 
-export type UnsignedEvent = EventTemplate & {
-  pubkey: string
-}
-
-export type Event = UnsignedEvent & {
-  id: string
-  sig: string
-}
-
-export function getBlankEvent(): EventTemplate {
+export function getBlankEvent(): Event {
   return {
     kind: 255,
+    pubkey: '',
     content: '',
     tags: [],
     created_at: 0
   }
 }
 
-export function finishEvent(t: EventTemplate, privateKey: string): Event {
-  let event = t as Event
-  event.pubkey = getPublicKey(privateKey)
-  event.id = getEventHash(event)
-  event.sig = signEvent(event, privateKey)
-  return event
-}
-
-export function serializeEvent(evt: UnsignedEvent): string {
+export function serializeEvent(evt: Event): string {
   if (!validateEvent(evt))
     throw new Error("can't serialize event with wrong or missing properties")
 
@@ -73,14 +53,12 @@ export function serializeEvent(evt: UnsignedEvent): string {
   ])
 }
 
-export function getEventHash(event: UnsignedEvent): string {
+export function getEventHash(event: Event): string {
   let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
   return secp256k1.utils.bytesToHex(eventHash)
 }
 
-export function validateEvent(event: UnsignedEvent): boolean {
-  if (typeof event !== 'object') return false
-  if (typeof event.kind !== 'number') return false
+export function validateEvent(event: Event): boolean {
   if (typeof event.content !== 'string') return false
   if (typeof event.created_at !== 'number') return false
   if (typeof event.pubkey !== 'string') return false
@@ -106,7 +84,7 @@ export function verifySignature(event: Event & {sig: string}): boolean {
   )
 }
 
-export function signEvent(event: UnsignedEvent, key: string): string {
+export function signEvent(event: Event, key: string): string {
   return secp256k1.utils.bytesToHex(
     secp256k1.schnorr.signSync(getEventHash(event), key)
   )

filter.ts

@@ -7,7 +7,6 @@ export type Filter = {
   since?: number
   until?: number
   limit?: number
-  search?: string
   [key: `#${string}`]: string[]
 }
 

index.ts

@@ -9,8 +9,6 @@ export * as nip05 from './nip05'
 export * as nip06 from './nip06'
 export * as nip19 from './nip19'
 export * as nip26 from './nip26'
-export * as nip39 from './nip39'
-export * as nip57 from './nip57'
 
 export * as fj from './fakejson'
 export * as utils from './utils'

justfile

@@ -4,20 +4,13 @@ install-dependencies:
     yarn --ignore-engines
 
 build:
-    rm -rf lib
     node build.js
 
 test: build
     jest
 
-test-only file: build
+testOnly file: build
     jest {{file}}
 
-emit-types:
-    tsc # see tsconfig.json
-
-publish: build emit-types
+publish: build
     npm publish
-
-format:
-    prettier --plugin-search-dir . --write .

magic.ts

@@ -0,0 +1,140 @@
+import {Relay, relayInit} from './relay'
+import {Event} from './event'
+import {normalizeURL} from './utils'
+
+export default function (
+  writeableRelays: string[],
+  fallbackRelays: string[],
+  safeRelays: string[]
+) {
+  return new MagicPool(fallbackRelays, writeableRelays, safeRelays)
+}
+
+class MagicPool {
+  private _conn: {[url: string]: Relay}
+  private _fallback: {[url: string]: Relay}
+  private _write: {[url: string]: Relay}
+  private _safe: {[url: string]: Relay}
+
+  private _profileRelays: {[pubkey: string]: RelayTableScore}
+  private _tempCache: {[id: string]: Event}
+
+  constructor(
+    fallbackRelays: string[],
+    writeableRelays: string[],
+    safeRelays: string[] = [
+      'wss://eden.nostr.land',
+      'wss://nostr.milou.lol',
+      'wss://relay.minds.com/nostr/v1/ws'
+    ]
+  ) {
+    this._conn = {}
+    this._write = {}
+    this._fallback = {}
+    this._profileRelays = {}
+    this._tempCache = {}
+
+    const hasEventId = (id: string): boolean => id in this._tempCache
+    const init = (url: string) => {
+      this._conn[normalizeURL(url)] = relayInit(normalizeURL(url), hasEventId)
+    }
+
+    fallbackRelays.forEach(init)
+    writeableRelays.forEach(init)
+    safeRelays.forEach(init)
+
+    this._write = Object.fromEntries(
+      writeableRelays.map(url => [
+        normalizeURL(url),
+        this._conn[normalizeURL(url)]
+      ])
+    )
+    this._fallback = Object.fromEntries(
+      fallbackRelays.map(url => [
+        normalizeURL(url),
+        this._conn[normalizeURL(url)]
+      ])
+    )
+    this._safe = Object.fromEntries(
+      safeRelays.map(url => [normalizeURL(url), this._conn[normalizeURL(url)]])
+    )
+  }
+
+  publish(event: Event) {
+    return Promise.all(
+      Object.entries(this._write).map(
+        ([url, relay]) =>
+          new Promise(async resolve => {
+            await relay.connect()
+            let pub = relay.publish(event)
+            let to = setTimeout(() => {
+              let end = setTimeout(() => {
+                resolve({url, success: false, reason: 'timeout'})
+              }, 2500)
+              pub.on('seen', () => {
+                clearTimeout(end)
+                resolve({url, success: true, reason: 'seen'})
+              })
+            }, 2500)
+            pub.on('ok', () => {
+              clearTimeout(to)
+              resolve({url, success: true, reason: 'ok'})
+            })
+            pub.on('failed', (reason: string) => {
+              clearTimeout(to)
+              resolve({url, success: false, reason})
+            })
+          })
+      )
+    )
+  }
+
+  profile(
+    pubkey: string,
+    onUpdate: (events: Event[]) => void
+  ): {
+    page(n: number): void
+  } {
+    var relays = new Set()
+    let rts = this._profileRelays[pubkey]
+    if (rts) {
+      relays = rts.get(3)
+    }
+
+    let fallback = Object.values(this._fallback)
+    for (let i = 0; i < fallback.length; i++) {
+      if (relays.size < 3) {
+        relays.add(fallback[Math.floor(Math.random() * fallback.length)])
+      } else break
+    }
+
+    // start subscription
+    for (let r in relays) {
+        r.
+    }
+
+    return {
+      page(n: number) {}
+    }
+  }
+}
+
+class RelayTableScore {
+  seen: string[] = []
+  hinted: string[] = []
+  explicit: string[] = []
+
+  get(n: number): Set<string> {
+    let relays = new Set<string>()
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < 3; j++) {
+        let v = [this.seen, this.explicit, this.hinted][j][i]
+        if (v) {
+          relays.add(v)
+          if (relays.size >= n) return relays
+        }
+      }
+    }
+    return relays
+  }
+}

nip05.ts

@@ -37,16 +37,10 @@ export async function queryProfile(
   }
 
   if (!name.match(/^[A-Za-z0-9-_]+$/)) return null
-  if (!domain.includes('.')) return null
 
-  let res
-  try {
-    res = await (
-      await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
-    ).json()
-  } catch (err) {
-    return null
-  }
+  let res = await (
+    await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
+  ).json()
 
   if (!res?.names?.[name]) return null
 

nip06.test.js

@@ -4,16 +4,12 @@ const {nip06} = require('./lib/nostr.cjs')
 test('generate private key from a mnemonic', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const privateKey = nip06.privateKeyFromSeedWords(mnemonic)
-  expect(privateKey).toEqual(
-    'c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2'
-  )
+  expect(privateKey).toEqual('c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2')
 })
 
 test('generate private key from a mnemonic and passphrase', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const passphrase = '123'
   const privateKey = nip06.privateKeyFromSeedWords(mnemonic, passphrase)
-  expect(privateKey).toEqual(
-    '55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4'
-  )
+  expect(privateKey).toEqual('55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4')
 })

nip06.ts

@@ -7,10 +7,7 @@ import {
 } from '@scure/bip39'
 import {HDKey} from '@scure/bip32'
 
-export function privateKeyFromSeedWords(
-  mnemonic: string,
-  passphrase?: string
-): string {
+export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string): string {
   let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
   let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey
   if (!privateKey) throw new Error('could not derive private key')

nip19.test.js

@@ -34,69 +34,3 @@ test('encode and decode nprofile', () => {
   expect(data.relays).toContain(relays[0])
   expect(data.relays).toContain(relays[1])
 })
-
-test('decode nprofile without relays', () => {
-  expect(
-    nip19.decode(
-      nip19.nprofileEncode({
-        pubkey:
-          '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322',
-        relays: []
-      })
-    ).data
-  ).toHaveProperty(
-    'pubkey',
-    '97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322'
-  )
-})
-
-test('encode and decode naddr', () => {
-  let pk = getPublicKey(generatePrivateKey())
-  let relays = [
-    'wss://relay.nostr.example.mydomain.example.com',
-    'wss://nostr.banana.com'
-  ]
-  let naddr = nip19.naddrEncode({
-    pubkey: pk,
-    relays,
-    kind: 30023,
-    identifier: 'banana'
-  })
-  expect(naddr).toMatch(/naddr1\w+/)
-  let {type, data} = nip19.decode(naddr)
-  expect(type).toEqual('naddr')
-  expect(data.pubkey).toEqual(pk)
-  expect(data.relays).toContain(relays[0])
-  expect(data.relays).toContain(relays[1])
-  expect(data.kind).toEqual(30023)
-  expect(data.identifier).toEqual('banana')
-})
-
-test('decode naddr from habla.news', () => {
-  let {type, data} = nip19.decode(
-    'naddr1qq98yetxv4ex2mnrv4esygrl54h466tz4v0re4pyuavvxqptsejl0vxcmnhfl60z3rth2xkpjspsgqqqw4rsf34vl5'
-  )
-  expect(type).toEqual('naddr')
-  expect(data.pubkey).toEqual(
-    '7fa56f5d6962ab1e3cd424e758c3002b8665f7b0d8dcee9fe9e288d7751ac194'
-  )
-  expect(data.kind).toEqual(30023)
-  expect(data.identifier).toEqual('references')
-})
-
-test('decode naddr from go-nostr with different TLV ordering', () => {
-  let {type, data} = nip19.decode(
-    'naddr1qqrxyctwv9hxzq3q80cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsxpqqqp65wqfwwaehxw309aex2mrp0yhxummnw3ezuetcv9khqmr99ekhjer0d4skjm3wv4uxzmtsd3jjucm0d5q3vamnwvaz7tmwdaehgu3wvfskuctwvyhxxmmd0zfmwx'
-  )
-
-  expect(type).toEqual('naddr')
-  expect(data.pubkey).toEqual(
-    '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'
-  )
-  expect(data.relays).toContain(
-    'wss://relay.nostr.example.mydomain.example.com'
-  )
-  expect(data.relays).toContain('wss://nostr.banana.com')
-  expect(data.kind).toEqual(30023)
-  expect(data.identifier).toEqual('banana')
-})

nip19.ts

@@ -15,75 +15,46 @@ export type EventPointer = {
   relays?: string[]
 }
 
-export type AddressPointer = {
-  identifier: string
-  pubkey: string
-  kind: number
-  relays?: string[]
-}
-
 export function decode(nip19: string): {
   type: string
-  data: ProfilePointer | EventPointer | AddressPointer | string
+  data: ProfilePointer | EventPointer | string
 } {
   let {prefix, words} = bech32.decode(nip19, Bech32MaxSize)
   let data = new Uint8Array(bech32.fromWords(words))
 
-  switch (prefix) {
-    case 'nprofile': {
-      let tlv = parseTLV(data)
-      if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nprofile')
-      if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
+  if (prefix === 'nprofile') {
+    let tlv = parseTLV(data)
+    if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nprofile')
+    if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
 
-      return {
-        type: 'nprofile',
-        data: {
-          pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : []
-        }
+    return {
+      type: 'nprofile',
+      data: {
+        pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
+        relays: tlv[1].map(d => utf8Decoder.decode(d))
       }
     }
-    case 'nevent': {
-      let tlv = parseTLV(data)
-      if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nevent')
-      if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
-
-      return {
-        type: 'nevent',
-        data: {
-          id: secp256k1.utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : []
-        }
-      }
-    }
-
-    case 'naddr': {
-      let tlv = parseTLV(data)
-      if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for naddr')
-      if (!tlv[2]?.[0]) throw new Error('missing TLV 2 for naddr')
-      if (tlv[2][0].length !== 32) throw new Error('TLV 2 should be 32 bytes')
-      if (!tlv[3]?.[0]) throw new Error('missing TLV 3 for naddr')
-      if (tlv[3][0].length !== 4) throw new Error('TLV 3 should be 4 bytes')
-
-      return {
-        type: 'naddr',
-        data: {
-          identifier: utf8Decoder.decode(tlv[0][0]),
-          pubkey: secp256k1.utils.bytesToHex(tlv[2][0]),
-          kind: parseInt(secp256k1.utils.bytesToHex(tlv[3][0]), 16),
-          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : []
-        }
-      }
-    }
-
-    case 'nsec':
-    case 'npub':
-    case 'note':
-      return {type: prefix, data: secp256k1.utils.bytesToHex(data)}
-
-    default:
-      throw new Error(`unknown prefix ${prefix}`)
   }
+
+  if (prefix === 'nevent') {
+    let tlv = parseTLV(data)
+    if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nevent')
+    if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
+
+    return {
+      type: 'nevent',
+      data: {
+        id: secp256k1.utils.bytesToHex(tlv[0][0]),
+        relays: tlv[1].map(d => utf8Decoder.decode(d))
+      }
+    }
+  }
+
+  if (prefix === 'nsec' || prefix === 'npub' || prefix === 'note') {
+    return {type: prefix, data: secp256k1.utils.bytesToHex(data)}
+  }
+
+  throw new Error(`unknown prefix ${prefix}`)
 }
 
 type TLV = {[t: number]: Uint8Array[]}
@@ -139,20 +110,6 @@ export function neventEncode(event: EventPointer): string {
   return bech32.encode('nevent', words, Bech32MaxSize)
 }
 
-export function naddrEncode(addr: AddressPointer): string {
-  let kind = new ArrayBuffer(4)
-  new DataView(kind).setUint32(0, addr.kind, false)
-
-  let data = encodeTLV({
-    0: [utf8Encoder.encode(addr.identifier)],
-    1: (addr.relays || []).map(url => utf8Encoder.encode(url)),
-    2: [secp256k1.utils.hexToBytes(addr.pubkey)],
-    3: [new Uint8Array(kind)]
-  })
-  let words = bech32.toWords(data)
-  return bech32.encode('naddr', words, Bech32MaxSize)
-}
-
 function encodeTLV(tlv: TLV): Uint8Array {
   let entries: Uint8Array[] = []
 

nip39.test.js

@@ -1,15 +0,0 @@
-/* eslint-env jest */
-
-const fetch = require('node-fetch')
-const {nip39} = require('./lib/nostr.cjs.js')
-
-test('validate github claim', async () => {
-  nip39.useFetchImplementation(fetch)
-
-  let result = await nip39.validateGithub(
-    'npub1gcxzte5zlkncx26j68ez60fzkvtkm9e0vrwdcvsjakxf9mu9qewqlfnj5z',
-    'vitorpamplona',
-    'cf19e2d1d7f8dac6348ad37b35ec8421'
-  )
-  expect(result).toBe(true)
-})

nip39.ts

@@ -1,27 +0,0 @@
-var _fetch: any
-
-try {
-  _fetch = fetch
-} catch {}
-
-export function useFetchImplementation(fetchImplementation: any) {
-  _fetch = fetchImplementation
-}
-
-export async function validateGithub(
-  pubkey: string,
-  username: string,
-  proof: string
-): Promise<boolean> {
-  try {
-    let res = await (
-      await _fetch(`https://gist.github.com/${username}/${proof}/raw`)
-    ).text()
-    return (
-      res ===
-      `Verifying that I control the following Nostr public key: ${pubkey}`
-    )
-  } catch (_) {
-    return false
-  }
-}

nip57.ts

@@ -1,138 +0,0 @@
-import {bech32} from '@scure/base'
-
-import {Event, EventTemplate, validateEvent, verifySignature} from './event'
-import {utf8Decoder} from './utils'
-
-var _fetch: any
-
-try {
-  _fetch = fetch
-} catch {}
-
-export function useFetchImplementation(fetchImplementation: any) {
-  _fetch = fetchImplementation
-}
-
-export async function getZapEndpoint(metadata: Event): Promise<null | string> {
-  try {
-    let lnurl: string = ''
-    let {lud06, lud16} = JSON.parse(metadata.content)
-    if (lud06) {
-      let {words} = bech32.decode(lud06, 1000)
-      let data = bech32.fromWords(words)
-      lnurl = utf8Decoder.decode(data)
-    } else if (lud16) {
-      let [name, domain] = lud16.split('@')
-      lnurl = `https://${domain}/.well-known/lnurlp/${name}`
-    } else {
-      return null
-    }
-
-    let res = await _fetch(lnurl)
-    let body = await res.json()
-
-    if (body.allowsNostr && body.nostrPubkey) {
-      return body.callback
-    }
-  } catch (err) {
-    /*-*/
-  }
-
-  return null
-}
-
-export function makeZapRequest({
-  profile,
-  event,
-  amount,
-  relays,
-  comment = ''
-}: {
-  profile: string
-  event: string | null
-  amount: number
-  comment: string
-  relays: string[]
-}): EventTemplate {
-  if (!amount) throw new Error('amount not given')
-  if (!profile) throw new Error('profile not given')
-
-  let zr = {
-    kind: 9734,
-    created_at: Math.round(Date.now() / 1000),
-    content: comment,
-    tags: [
-      ['p', profile],
-      ['amount', amount.toString()],
-      ['relays', ...relays]
-    ]
-  }
-
-  if (event) {
-    zr.tags.push(['e', event])
-  }
-
-  return zr
-}
-
-export function validateZapRequest(zapRequestString: string): string | null {
-  let zapRequest: Event
-
-  try {
-    zapRequest = JSON.parse(zapRequestString)
-  } catch (err) {
-    return 'Invalid zap request JSON.'
-  }
-
-  if (!validateEvent(zapRequest))
-    return 'Zap request is not a valid Nostr event.'
-  if (!verifySignature(zapRequest)) return 'Invalid signature on zap request.'
-
-  let p = zapRequest.tags.find(([t, v]) => t === 'p' && v)
-  if (!p) return "Zap request doesn't have a 'p' tag."
-  if (!p[1].match(/^[a-f0-9]{64}$/))
-    return "Zap request 'p' tag is not valid hex."
-
-  let e = zapRequest.tags.find(([t, v]) => t === 'e' && v)
-  if (e && !e[1].match(/^[a-f0-9]{64}$/))
-    return "Zap request 'e' tag is not valid hex."
-
-  let relays = zapRequest.tags.find(([t, v]) => t === 'relays' && v)
-  if (!relays) return "Zap request doesn't have a 'relays' tag."
-
-  return null
-}
-
-export function makeZapReceipt({
-  zapRequest,
-  preimage,
-  bolt11,
-  paidAt
-}: {
-  zapRequest: string
-  preimage: string | null
-  bolt11: string
-  paidAt: Date
-}): EventTemplate {
-  let zr: Event = JSON.parse(zapRequest)
-  let tagsFromZapRequest = zr.tags.filter(
-    ([t]) => t === 'e' || t === 'p' || t === 'a'
-  )
-
-  let zap = {
-    kind: 9735,
-    created_at: Math.round(paidAt.getTime() / 1000),
-    content: '',
-    tags: [
-      ...tagsFromZapRequest,
-      ['bolt11', bolt11],
-      ['description', zapRequest]
-    ]
-  }
-
-  if (preimage) {
-    zap.tags.push(['preimage', preimage])
-  }
-
-  return zap
-}

package.json

@@ -1,29 +1,19 @@
 {
   "name": "nostr-tools",
-  "version": "1.7.5",
+  "version": "1.3.2",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nbd-wtf/nostr-tools.git"
+    "url": "https://github.com/fiatjaf/nostr-tools.git"
   },
-  "files": [
-    "./lib/**/*"
-  ],
-  "types": "./lib/index.d.ts",
   "main": "lib/nostr.cjs.js",
-  "module": "lib/esm/nostr.mjs",
-  "exports": {
-    "import": "./lib/esm/nostr.mjs",
-    "require": "./lib/nostr.cjs.js"
-  },
-  "license": "Public domain",
+  "module": "lib/nostr.esm.js",
   "dependencies": {
-    "@noble/hashes": "1.0.0",
-    "@noble/secp256k1": "^1.7.1",
+    "@noble/hashes": "^0.5.7",
+    "@noble/secp256k1": "^1.7.0",
     "@scure/base": "^1.1.1",
-    "@scure/bip32": "^1.1.5",
-    "@scure/bip39": "^1.1.1",
-    "prettier": "^2.8.4"
+    "@scure/bip32": "^1.1.1",
+    "@scure/bip39": "^1.1.0"
   },
   "keywords": [
     "decentralization",
@@ -33,20 +23,20 @@
     "nostr"
   ],
   "devDependencies": {
-    "@types/node": "^18.13.0",
-    "@typescript-eslint/eslint-plugin": "^5.51.0",
-    "@typescript-eslint/parser": "^5.51.0",
+    "@types/node": "^18.0.3",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
     "esbuild": "0.16.9",
     "esbuild-plugin-alias": "^0.2.1",
-    "eslint": "^8.33.0",
+    "eslint": "^8.30.0",
     "eslint-plugin-babel": "^5.3.1",
-    "esm-loader-typescript": "^1.0.3",
+    "esm-loader-typescript": "^1.0.1",
     "events": "^3.3.0",
-    "jest": "^29.4.2",
-    "node-fetch": "^2.6.9",
-    "ts-jest": "^29.0.5",
+    "jest": "^29.3.1",
+    "node-fetch": "2",
+    "ts-jest": "^29.0.3",
     "tsd": "^0.22.0",
-    "typescript": "^4.9.5",
+    "typescript": "^4.9.4",
     "websocket-polyfill": "^0.0.3"
   }
 }

pool.test.js

@@ -12,17 +12,17 @@ const {
 let pool = new SimplePool()
 
 let relays = [
-  'wss://relay.damus.io/',
+  'wss://nostr-dev.wellorder.net/',
   'wss://relay.nostr.bg/',
   'wss://nostr.fmt.wiz.biz/',
   'wss://relay.nostr.band/',
-  'wss://nos.lol/'
+  'wss://nostr.zebedee.cloud/'
 ]
 
-afterAll(() => {
-  pool.close([
+afterAll(async () => {
+  await pool.close([
     ...relays,
-    'wss://nostr.wine',
+    'wss://nostr-relay.untethr.me',
     'wss://offchain.pub',
     'wss://eden.nostr.land'
   ])

pool.ts

@@ -8,36 +8,25 @@ 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
 
-  private eoseSubTimeout: number
-  private getTimeout: number
-
-  constructor(options: {eoseSubTimeout?: number; getTimeout?: number} = {}) {
+  constructor() {
     this._conn = {}
-    this.eoseSubTimeout = options.eoseSubTimeout || 3400
-    this.getTimeout = options.getTimeout || 3400
   }
 
-  close(relays: string[]): void {
-    relays.forEach(url => {
-      let relay = this._conn[normalizeURL(url)]
-      if (relay) relay.close()
-    })
+  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 && existing.status === 1) return existing
+    if (existing) return existing
 
-    if (existing) {
-      await existing.connect()
-      return existing
-    }
-
-    const relay = relayInit(nm, {
-      getTimeout: this.getTimeout * 0.9,
-      listTimeout: this.getTimeout * 0.9
-    })
+    const relay = relayInit(nm)
     this._conn[nm] = relay
 
     await relay.connect()
@@ -47,11 +36,8 @@ export class SimplePool {
 
   sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub {
     let _knownIds: Set<string> = new Set()
-    let modifiedOpts = {...(opts || {})}
+    let modifiedOpts = opts || {}
     modifiedOpts.alreadyHaveEvent = (id, url) => {
-      if (opts?.alreadyHaveEvent?.(id, url)) {
-        return true
-      }
       let set = this._seenOn[id] || new Set()
       set.add(url)
       this._seenOn[id] = set
@@ -67,16 +53,10 @@ export class SimplePool {
     let eoseTimeout = setTimeout(() => {
       eoseSent = true
       for (let cb of eoseListeners.values()) cb()
-    }, this.eoseSubTimeout)
+    }, 2400)
 
     relays.forEach(async relay => {
-      let r
-      try {
-        r = await this.ensureRelay(relay)
-      } catch (err) {
-        handleEose()
-        return
-      }
+      let r = await this.ensureRelay(relay)
       if (!r) return
       let s = r.sub(filters, modifiedOpts)
       s.on('event', (event: Event) => {
@@ -85,17 +65,14 @@ export class SimplePool {
       })
       s.on('eose', () => {
         if (eoseSent) return
-        handleEose()
-      })
-      subs.push(s)
 
-      function handleEose() {
         eosesMissing--
         if (eosesMissing === 0) {
           clearTimeout(eoseTimeout)
           for (let cb of eoseListeners.values()) cb()
         }
-      }
+      })
+      subs.push(s)
     })
 
     let greaterSub: Sub = {
@@ -107,17 +84,19 @@ export class SimplePool {
         subs.forEach(sub => sub.unsub())
       },
       on(type, cb) {
-        if (type === 'event') {
-          eventListeners.add(cb)
-        } else if (type === 'eose') {
-          eoseListeners.add(cb as () => void | Promise<void>)
+        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 as () => void | Promise<void>)
+        } else if (type === 'eose') eoseListeners.delete(cb)
       }
     }
 
@@ -134,7 +113,7 @@ export class SimplePool {
       let timeout = setTimeout(() => {
         sub.unsub()
         resolve(null)
-      }, this.getTimeout)
+      }, 1500)
       sub.on('event', (event: Event) => {
         resolve(event)
         clearTimeout(timeout)
@@ -164,28 +143,25 @@ export class SimplePool {
     })
   }
 
-  publish(relays: string[], event: Event): Pub {
-    const pubs: Pub[] = []
-    relays.forEach(async relay => {
-      let r
-      try {
-        r = await this.ensureRelay(relay)
-        pubs.push(r.publish(event))
-      } catch (_) {}
+  publish(relays: string[], event: Event): Pub[] {
+    return relays.map(relay => {
+      let r = this._conn[normalizeURL(relay)]
+      if (!r) return badPub(relay)
+      let s = r.publish(event)
+      return s
     })
-    return {
-      on(type, cb) {
-        pubs.forEach((pub, i) => {
-          pub.on(type, () => cb(relays[i]))
-        })
-      },
-      off() {
-        // do nothing here, FIXME
-      }
-    }
   }
 
   seenOn(id: string): string[] {
     return Array.from(this._seenOn[id]?.values?.() || [])
   }
 }
+
+function badPub(relay: string): Pub {
+  return {
+    on(typ, cb) {
+      if (typ === 'failed') cb(`relay ${relay} not connected`)
+    },
+    off() {}
+  }
+}

relay.test.js

@@ -9,14 +9,14 @@ const {
   signEvent
 } = require('./lib/nostr.cjs')
 
-let relay = relayInit('wss://relay.damus.io/')
+let relay = relayInit('wss://nostr-dev.wellorder.net/')
 
 beforeAll(() => {
   relay.connect()
 })
 
-afterAll(() => {
-  relay.close()
+afterAll(async () => {
+  await relay.close()
 })
 
 test('connectivity', () => {

relay.ts

@@ -4,49 +4,29 @@ import {Event, verifySignature, validateEvent} from './event'
 import {Filter, matchFilters} from './filter'
 import {getHex64, getSubscriptionId} from './fakejson'
 
-type RelayEvent = {
-  connect: () => void | Promise<void>
-  disconnect: () => void | Promise<void>
-  error: () => void | Promise<void>
-  notice: (msg: string) => void | Promise<void>
-}
-type SubEvent = {
-  event: (event: Event) => void | Promise<void>
-  eose: () => void | Promise<void>
-}
+type RelayEvent = 'connect' | 'disconnect' | 'error' | 'notice'
+
 export type Relay = {
   url: string
   status: number
   connect: () => Promise<void>
-  close: () => void
+  close: () => Promise<void>
   sub: (filters: Filter[], opts?: SubscriptionOptions) => Sub
   list: (filters: Filter[], opts?: SubscriptionOptions) => Promise<Event[]>
   get: (filter: Filter, opts?: SubscriptionOptions) => Promise<Event | null>
   publish: (event: Event) => Pub
-  off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
-    event: T,
-    listener: U
-  ) => void
-  on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
-    event: T,
-    listener: U
-  ) => void
+  on: (type: RelayEvent, cb: any) => void
+  off: (type: RelayEvent, cb: any) => void
 }
 export type Pub = {
-  on: (type: 'ok' | 'failed', cb: any) => void
-  off: (type: 'ok' | 'failed', cb: any) => void
+  on: (type: 'ok' | 'seen' | 'failed', cb: any) => void
+  off: (type: 'ok' | 'seen' | 'failed', cb: any) => void
 }
 export type Sub = {
   sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
   unsub: () => void
-  on: <T extends keyof SubEvent, U extends SubEvent[T]>(
-    event: T,
-    listener: U
-  ) => void
-  off: <T extends keyof SubEvent, U extends SubEvent[T]>(
-    event: T,
-    listener: U
-  ) => void
+  on: (type: 'event' | 'eose', cb: any) => void
+  off: (type: 'event' | 'eose', cb: any) => void
 }
 
 export type SubscriptionOptions = {
@@ -55,25 +35,30 @@ export type SubscriptionOptions = {
   alreadyHaveEvent?: null | ((id: string, relay: string) => boolean)
 }
 
-export function relayInit(
-  url: string,
-  options: {
-    getTimeout?: number
-    listTimeout?: number
-  } = {}
-): Relay {
-  let {listTimeout = 3000, getTimeout = 3000} = options
-
+export function relayInit(url: string): Relay {
   var ws: WebSocket
+  var resolveClose: () => 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: {[TK in keyof RelayEvent]: RelayEvent[TK][]} = {
+  var listeners: {
+    connect: Array<() => void>
+    disconnect: Array<() => void>
+    error: Array<() => void>
+    notice: Array<(msg: string) => void>
+  } = {
     connect: [],
     disconnect: [],
     error: [],
     notice: []
   }
   var subListeners: {
-    [subid: string]: {[TK in keyof SubEvent]: SubEvent[TK][]}
+    [subid: string]: {
+      event: Array<(event: Event) => void>
+      eose: Array<() => void>
+    }
   } = {}
   var pubListeners: {
     [eventid: string]: {
@@ -85,14 +70,11 @@ export function relayInit(
 
   async function connectRelay(): Promise<void> {
     return new Promise((resolve, reject) => {
-      try {
-        ws = new WebSocket(url)
-      } catch (err) {
-        reject(err)
-      }
+      ws = new WebSocket(url)
 
       ws.onopen = () => {
         listeners.connect.forEach(cb => cb())
+        setOpen()
         resolve()
       }
       ws.onerror = () => {
@@ -101,6 +83,7 @@ export function relayInit(
       }
       ws.onclose = async () => {
         listeners.disconnect.forEach(cb => cb())
+        resolveClose && resolveClose()
       }
 
       let incomingMessageQueue: string[] = []
@@ -157,22 +140,15 @@ export function relayInit(
               return
             case 'EOSE': {
               let id = data[1]
-              if (id in subListeners) {
-                subListeners[id].eose.forEach(cb => cb())
-                subListeners[id].eose = [] // 'eose' only happens once per sub, so stop listeners here
-              }
+              ;(subListeners[id]?.eose || []).forEach(cb => cb())
               return
             }
             case 'OK': {
               let id: string = data[1]
               let ok: boolean = data[2]
               let reason: string = data[3] || ''
-              if (id in pubListeners) {
-                if (ok) pubListeners[id].ok.forEach(cb => cb())
-                else pubListeners[id].failed.forEach(cb => cb(reason))
-                pubListeners[id].ok = [] // 'ok' only happens once per pub, so stop listeners here
-                pubListeners[id].failed = []
-              }
+              if (ok) pubListeners[id]?.ok.forEach(cb => cb())
+              else pubListeners[id]?.failed.forEach(cb => cb(reason))
               return
             }
             case 'NOTICE':
@@ -187,23 +163,15 @@ export function relayInit(
     })
   }
 
-  function connected() {
-    return ws?.readyState === 1
-  }
-
   async function connect(): Promise<void> {
-    if (connected()) return // ws already open
+    if (ws?.readyState && ws.readyState === 1) return // ws already open
     await connectRelay()
   }
 
   async function trySend(params: [string, ...any]) {
     let msg = JSON.stringify(params)
-    if (!connected()) {
-      await new Promise(resolve => setTimeout(resolve, 1000))
-      if (!connected()) {
-        return
-      }
-    }
+
+    await untilOpen
     try {
       ws.send(msg)
     } catch (err) {
@@ -241,20 +209,14 @@ export function relayInit(
         delete subListeners[subid]
         trySend(['CLOSE', subid])
       },
-      on: <T extends keyof SubEvent, U extends SubEvent[T]>(
-        type: T,
-        cb: U
-      ): void => {
+      on: (type: 'event' | 'eose', cb: any): void => {
         subListeners[subid] = subListeners[subid] || {
           event: [],
           eose: []
         }
         subListeners[subid][type].push(cb)
       },
-      off: <T extends keyof SubEvent, U extends SubEvent[T]>(
-        type: T,
-        cb: U
-      ): void => {
+      off: (type: 'event' | 'eose', cb: any): void => {
         let listeners = subListeners[subid]
         let idx = listeners[type].indexOf(cb)
         if (idx >= 0) listeners[type].splice(idx, 1)
@@ -265,20 +227,13 @@ export function relayInit(
   return {
     url,
     sub,
-    on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
-      type: T,
-      cb: U
-    ): void => {
+    on: (type: RelayEvent, cb: any): void => {
       listeners[type].push(cb)
       if (type === 'connect' && ws?.readyState === 1) {
-        // i would love to know why we need this
-        ;(cb as () => void)()
+        cb()
       }
     },
-    off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
-      type: T,
-      cb: U
-    ): void => {
+    off: (type: RelayEvent, cb: any): void => {
       let index = listeners[type].indexOf(cb)
       if (index !== -1) listeners[type].splice(index, 1)
     },
@@ -289,7 +244,7 @@ export function relayInit(
         let timeout = setTimeout(() => {
           s.unsub()
           resolve(events)
-        }, listTimeout)
+        }, 1500)
         s.on('eose', () => {
           s.unsub()
           clearTimeout(timeout)
@@ -305,7 +260,7 @@ export function relayInit(
         let timeout = setTimeout(() => {
           s.unsub()
           resolve(null)
-        }, getTimeout)
+        }, 1500)
         s.on('event', (event: Event) => {
           s.unsub()
           clearTimeout(timeout)
@@ -316,17 +271,50 @@ export function relayInit(
       if (!event.id) throw new Error(`event ${event} has no id`)
       let id = event.id
 
+      var sent = false
+      var mustMonitor = false
+
       trySend(['EVENT', event])
+        .then(() => {
+          sent = true
+          if (mustMonitor) {
+            startMonitoring()
+            mustMonitor = false
+          }
+        })
+        .catch(() => {})
+
+      const startMonitoring = () => {
+        let monitor = sub([{ids: [id]}], {
+          id: `monitor-${id.slice(0, 5)}`
+        })
+        let willUnsub = setTimeout(() => {
+          ;(pubListeners[id]?.failed || []).forEach(cb =>
+            cb('event not seen after 5 seconds')
+          )
+          monitor.unsub()
+        }, 5000)
+        monitor.on('event', () => {
+          clearTimeout(willUnsub)
+          ;(pubListeners[id]?.seen || []).forEach(cb => cb())
+        })
+      }
 
       return {
-        on: (type: 'ok' | 'failed', cb: any) => {
+        on: (type: 'ok' | 'seen' | 'failed', cb: any) => {
           pubListeners[id] = pubListeners[id] || {
             ok: [],
+            seen: [],
             failed: []
           }
           pubListeners[id][type].push(cb)
+
+          if (type === 'seen') {
+            if (sent) startMonitoring()
+            else mustMonitor = true
+          }
         },
-        off: (type: 'ok' | 'failed', cb: any) => {
+        off: (type: 'ok' | 'seen' | 'failed', cb: any) => {
           let listeners = pubListeners[id]
           if (!listeners) return
           let idx = listeners[type].indexOf(cb)
@@ -335,13 +323,12 @@ export function relayInit(
       }
     },
     connect,
-    close(): void {
-      listeners = {connect: [], disconnect: [], error: [], notice: []}
-      subListeners = {}
-      pubListeners = {}
-      if (ws.readyState === WebSocket.OPEN) {
-        ws?.close()
-      }
+    close(): Promise<void> {
+      if (ws.readyState > 1) return Promise.resolve()
+      ws.close()
+      return new Promise<void>(resolve => {
+        resolveClose = resolve
+      })
     },
     get status() {
       return ws?.readyState ?? 3

tsconfig.json

@@ -9,7 +9,7 @@
     "skipLibCheck": true,
     "esModuleInterop": true,
     "emitDeclarationOnly": true,
-    "outDir": "lib",
+    "outDir": "dist",
     "rootDir": "."
   }
 }