bump to v1.7.5

* RelayEvent allow Promises

* type Sub EventHandler

* Update relay.ts

.eslintrc.json

@@ -24,6 +24,7 @@
     "document": false,
     "navigator": false,
     "window": false,
+    "crypto": false,
     "location": false,
     "URL": false,
     "URLSearchParams": false,

.github/workflows/npm-publish.yml

@@ -12,9 +12,11 @@ jobs:
       - uses: actions/setup-node@v3
         with:
           node-version: 18
-      - run: yarn --ignore-engines
-      - run: node build.js
-      - run: yarn test
+      - uses: extractions/setup-just@v1
+      - 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

@@ -3,15 +3,17 @@ on:
   push:
     branches:
       - master
+  pull_request:
 
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
           node-version: 18
-      - run: yarn --ignore-engines
-      - run: node build.js
-      - run: yarn test
+      - uses: extractions/setup-just@v1
+      - run: just install-dependencies
+      - run: just build
+      - run: just test

README.md

@@ -2,15 +2,23 @@
 
 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
 
 ```js
-import { generatePrivateKey, getPublicKey } from 'nostr-tools'
+import {generatePrivateKey, getPublicKey} from 'nostr-tools'
 
-let sk = generatePrivateKey() # `sk` is a hex string
-let pk = getPublicKey(sk) # `pk` is a hex string
+let sk = generatePrivateKey() // `sk` is a hex string
+let pk = getPublicKey(sk) // `pk` is a hex string
 ```
 
 ### Creating, signing and verifying events
@@ -28,15 +36,15 @@ let event = {
   kind: 1,
   created_at: Math.floor(Date.now() / 1000),
   tags: [],
-  content: 'hello'
+  content: 'hello',
+  pubkey: getPublicKey(privateKey)
 }
 
-event.id = getEventHash(event.id)
-event.pubkey = getPublicKey(privateKey)
-event.sig = await signEvent(event, privateKey)
+event.id = getEventHash(event)
+event.sig = signEvent(event, privateKey)
 
 let ok = validateEvent(event)
-let veryOk = await verifySignature(event)
+let veryOk = verifySignature(event)
 ```
 
 ### Interacting with a relay
@@ -51,8 +59,6 @@ import {
 } from 'nostr-tools'
 
 const relay = relayInit('wss://relay.example.com')
-relay.connect()
-
 relay.on('connect', () => {
   console.log(`connected to ${relay.url}`)
 })
@@ -60,6 +66,8 @@ 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([
   {
@@ -96,20 +104,70 @@ let event = {
   content: 'hello world'
 }
 event.id = getEventHash(event)
-event.sig = await signEvent(event, sk)
+event.sig = signEvent(event, sk)
 
 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}`)
+  console.log(`${relay.url} has accepted our event`)
 })
 pub.on('failed', reason => {
-  console.log(`failed to publish to {relay.url}: ${reason}`)
+  console.log(`failed to publish to ${relay.url}: ${reason}`)
 })
 
-await relay.close()
+let events = await relay.list([{kinds: [0, 1]}])
+let event = await relay.get({
+  ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245']
+})
+
+relay.close()
+```
+
+To use this on Node.js you first must install `websocket-polyfill` and import it:
+
+```js
+import 'websocket-polyfill'
+```
+
+### Interacting with multiple relays
+
+```js
+import {SimplePool} 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'
+      ]
+    }
+  ]
+)
+
+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
+  // ...
+})
+
+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
@@ -122,8 +180,11 @@ console.log(profile.pubkey)
 // prints: 32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245
 console.log(profile.relays)
 // prints: [wss://relay.damus.io]
+```
 
-// on nodejs, install node-fetch@2 and call this first:
+To use this on Node.js you first must install `node-fetch@2` and call something like this:
+
+```js
 nip05.useFetchImplementation(require('node-fetch'))
 ```
 
@@ -171,7 +232,7 @@ let pk2 = getPublicKey(sk2)
 
 // on the sender side
 let message = 'hello'
-let ciphertext = nip04.encrypt(sk1, pk2, 'hello')
+let ciphertext = await nip04.encrypt(sk1, pk2, message)
 
 let event = {
   kind: 4,
@@ -184,14 +245,48 @@ let event = {
 sendEvent(event)
 
 // on the receiver side
-
-sub.on('event', (event) => {
-  let sender = event.tags.find(([k, v]) => k === 'p' && && v && v !== '')[1]
+sub.on('event', event => {
+  let sender = event.tags.find(([k, v]) => k === 'p' && v && v !== '')[1]
   pk1 === sender
-  let plaintext = nip04.decrypt(sk2, pk1, event.content)
+  let plaintext = await nip04.decrypt(sk2, pk1, event.content)
 })
 ```
 
+### Performing and checking for delegation
+
+```js
+import {nip26, getPublicKey, generatePrivateKey} from 'nostr-tools'
+
+// delegator
+let sk1 = generatePrivateKey()
+let pk1 = getPublicKey(sk1)
+
+// delegatee
+let sk2 = generatePrivateKey()
+let pk2 = getPublicKey(sk2)
+
+// generate delegation
+let delegation = nip26.createDelegation(sk1, {
+  pubkey: pk2,
+  kind: 1,
+  since: Math.round(Date.now() / 1000),
+  until: Math.round(Date.now() / 1000) + 60 * 60 * 24 * 30 /* 30 days */
+})
+
+// the delegatee uses the delegation when building an event
+let event = {
+  pubkey: pk2,
+  kind: 1,
+  created_at: Math.round(Date.now() / 1000),
+  content: 'hello from a delegated key',
+  tags: [['delegation', delegation.from, delegation.cond, delegation.sig]]
+}
+
+// finally any receiver of this event can check for the presence of a valid delegation tag
+let delegator = nip26.getDelegator(event)
+assert(delegator === pk1) // will be null if there is no delegation tag or if it is invalid
+```
+
 Please consult the tests or [the source code](https://github.com/fiatjaf/nostr-tools) for more information that isn't available here.
 
 ### Using from the browser (if you don't want to use a bundler)
@@ -203,6 +298,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.

build.js

@@ -1,27 +1,27 @@
 #!/usr/bin/env node
 
+const fs = require('fs')
 const esbuild = require('esbuild')
-const alias = require('esbuild-plugin-alias')
 
 let common = {
   entryPoints: ['index.ts'],
   bundle: true,
-  plugins: [
-    alias({
-      stream: require.resolve('readable-stream')
-    })
-  ],
   sourcemap: 'external'
 }
 
 esbuild
   .build({
     ...common,
-    outfile: 'lib/nostr.esm.js',
+    outfile: 'lib/esm/nostr.mjs',
     format: 'esm',
     packages: 'external'
   })
-  .then(() => console.log('esm build success.'))
+  .then(() => {
+    const packageJson = JSON.stringify({type: 'module'})
+    fs.writeFileSync(`${__dirname}/lib/esm/package.json`, packageJson, 'utf8')
+
+    console.log('esm build success.')
+  })
 
 esbuild
   .build({

event.test.js

@@ -4,7 +4,6 @@ const {
   validateEvent,
   verifySignature,
   signEvent,
-  getEventHash,
   getPublicKey
 } = require('./lib/nostr.cjs')
 
@@ -35,15 +34,15 @@ test('validate event', () => {
 })
 
 test('check signature', async () => {
-  expect(await verifySignature(event)).toBeTruthy()
+  expect(verifySignature(event)).toBeTruthy()
 })
 
 test('sign event', async () => {
-  let sig = await signEvent(unsigned, privateKey)
-  let hash = getEventHash(unsigned)
   let pubkey = getPublicKey(privateKey)
+  let authored = {...unsigned, pubkey}
 
-  let signed = {...unsigned, id: hash, sig, pubkey}
+  let sig = signEvent(authored, privateKey)
+  let signed = {...authored, sig}
 
-  expect(await verifySignature(signed)).toBeTruthy()
+  expect(verifySignature(signed)).toBeTruthy()
 })

event.ts

@@ -1,29 +1,68 @@
-import {Buffer} from 'buffer'
-// @ts-ignore
 import * as secp256k1 from '@noble/secp256k1'
 import {sha256} from '@noble/hashes/sha256'
 
-export type Event = {
-  id?: string
-  sig?: string
-  kind: number
+import {utf8Encoder} from './utils'
+import {getPublicKey} from './keys'
+
+/* eslint-disable no-unused-vars */
+export enum Kind {
+  Metadata = 0,
+  Text = 1,
+  RecommendRelay = 2,
+  Contacts = 3,
+  EncryptedDirectMessage = 4,
+  EventDeletion = 5,
+  Reaction = 7,
+  ChannelCreation = 40,
+  ChannelMetadata = 41,
+  ChannelMessage = 42,
+  ChannelHideMessage = 43,
+  ChannelMuteUser = 44,
+  Report = 1984,
+  ZapRequest = 9734,
+  Zap = 9735,
+  RelayList = 10002,
+  ClientAuth = 22242,
+  Article = 30023
+}
+
+export type EventTemplate = {
+  kind: Kind
   tags: string[][]
-  pubkey: string
   content: string
   created_at: number
 }
 
-export function getBlankEvent(): Event {
+export type UnsignedEvent = EventTemplate & {
+  pubkey: string
+}
+
+export type Event = UnsignedEvent & {
+  id: string
+  sig: string
+}
+
+export function getBlankEvent(): EventTemplate {
   return {
     kind: 255,
-    pubkey: '',
     content: '',
     tags: [],
     created_at: 0
   }
 }
 
-export function serializeEvent(evt: Event): string {
+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 {
+  if (!validateEvent(evt))
+    throw new Error("can't serialize event with wrong or missing properties")
+
   return JSON.stringify([
     0,
     evt.pubkey,
@@ -34,15 +73,18 @@ export function serializeEvent(evt: Event): string {
   ])
 }
 
-export function getEventHash(event: Event): string {
-  let eventHash = sha256(Buffer.from(serializeEvent(event)))
-  return Buffer.from(eventHash).toString('hex')
+export function getEventHash(event: UnsignedEvent): string {
+  let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
+  return secp256k1.utils.bytesToHex(eventHash)
 }
 
-export function validateEvent(event: Event): boolean {
-  if (event.id !== getEventHash(event)) return false
+export function validateEvent(event: UnsignedEvent): boolean {
+  if (typeof event !== 'object') return false
+  if (typeof event.kind !== 'number') return false
   if (typeof event.content !== 'string') return false
   if (typeof event.created_at !== 'number') return false
+  if (typeof event.pubkey !== 'string') return false
+  if (!event.pubkey.match(/^[a-f0-9]{64}$/)) return false
 
   if (!Array.isArray(event.tags)) return false
   for (let i = 0; i < event.tags.length; i++) {
@@ -56,14 +98,16 @@ export function validateEvent(event: Event): boolean {
   return true
 }
 
-export function verifySignature(
-  event: Event & {id: string; sig: string}
-): Promise<boolean> {
-  return secp256k1.schnorr.verify(event.sig, event.id, event.pubkey)
+export function verifySignature(event: Event & {sig: string}): boolean {
+  return secp256k1.schnorr.verifySync(
+    event.sig,
+    getEventHash(event),
+    event.pubkey
+  )
 }
 
-export async function signEvent(event: Event, key: string): Promise<string> {
-  return Buffer.from(
-    await secp256k1.schnorr.sign(event.id || getEventHash(event), key)
-  ).toString('hex')
+export function signEvent(event: UnsignedEvent, key: string): string {
+  return secp256k1.utils.bytesToHex(
+    secp256k1.schnorr.signSync(getEventHash(event), key)
+  )
 }

fakejson.test.js

@@ -0,0 +1,49 @@
+/* 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()
+})
+
+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

@@ -0,0 +1,41 @@
+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 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')
+}
+
+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')
+}

filter.ts

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

index.ts

@@ -2,8 +2,24 @@ 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'
 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'
+
+// monkey patch secp256k1
+import * as secp256k1 from '@noble/secp256k1'
+import {hmac} from '@noble/hashes/hmac'
+import {sha256} from '@noble/hashes/sha256'
+secp256k1.utils.hmacSha256Sync = (key, ...msgs) =>
+  hmac(sha256, key, secp256k1.utils.concatBytes(...msgs))
+secp256k1.utils.sha256Sync = (...msgs) =>
+  sha256(secp256k1.utils.concatBytes(...msgs))

justfile

@@ -0,0 +1,23 @@
+export PATH := "./node_modules/.bin:" + env_var('PATH')
+
+install-dependencies:
+    yarn --ignore-engines
+
+build:
+    rm -rf lib
+    node build.js
+
+test: build
+    jest
+
+test-only file: build
+    jest {{file}}
+
+emit-types:
+    tsc # see tsconfig.json
+
+publish: build emit-types
+    npm publish
+
+format:
+    prettier --plugin-search-dir . --write .

keys.ts

@@ -1,10 +1,9 @@
 import * as secp256k1 from '@noble/secp256k1'
-import {Buffer} from 'buffer'
 
 export function generatePrivateKey(): string {
-  return Buffer.from(secp256k1.utils.randomPrivateKey()).toString('hex')
+  return secp256k1.utils.bytesToHex(secp256k1.utils.randomPrivateKey())
 }
 
 export function getPublicKey(privateKey: string): string {
-  return Buffer.from(secp256k1.schnorr.getPublicKey(privateKey)).toString('hex')
+  return secp256k1.utils.bytesToHex(secp256k1.schnorr.getPublicKey(privateKey))
 }

nip04.test.js

@@ -1,14 +1,15 @@
 /* eslint-env jest */
 
+globalThis.crypto = require('crypto')
 const {nip04, getPublicKey, generatePrivateKey} = require('./lib/nostr.cjs')
 
-test('encrypt and decrypt message', () => {
+test('encrypt and decrypt message', async () => {
   let sk1 = generatePrivateKey()
   let sk2 = generatePrivateKey()
   let pk1 = getPublicKey(sk1)
   let pk2 = getPublicKey(sk2)
 
-  expect(nip04.decrypt(sk2, pk1, nip04.encrypt(sk1, pk2, 'hello'))).toEqual(
-    'hello'
-  )
+  expect(
+    await nip04.decrypt(sk2, pk1, await nip04.encrypt(sk1, pk2, 'hello'))
+  ).toEqual('hello')
 })

nip04.ts

@@ -1,45 +1,66 @@
-import {Buffer} from 'buffer'
 import {randomBytes} from '@noble/hashes/utils'
 import * as secp256k1 from '@noble/secp256k1'
-// @ts-ignore
-import aes from 'browserify-cipher'
+import {base64} from '@scure/base'
 
-export function encrypt(privkey: string, pubkey: string, text: string): string {
+import {utf8Decoder, utf8Encoder} from './utils'
+
+export async function encrypt(
+  privkey: string,
+  pubkey: string,
+  text: string
+): Promise<string> {
   const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
   const normalizedKey = getNormalizedX(key)
 
   let iv = Uint8Array.from(randomBytes(16))
-  var cipher = aes.createCipheriv(
-    'aes-256-cbc',
-    Buffer.from(normalizedKey, 'hex'),
-    iv
+  let plaintext = utf8Encoder.encode(text)
+  let cryptoKey = await crypto.subtle.importKey(
+    'raw',
+    normalizedKey,
+    {name: 'AES-CBC'},
+    false,
+    ['encrypt']
   )
-  let encryptedMessage = cipher.update(text, 'utf8', 'base64')
-  encryptedMessage += cipher.final('base64')
+  let ciphertext = await crypto.subtle.encrypt(
+    {name: 'AES-CBC', iv},
+    cryptoKey,
+    plaintext
+  )
+  let ctb64 = base64.encode(new Uint8Array(ciphertext))
+  let ivb64 = base64.encode(new Uint8Array(iv.buffer))
 
-  return `${encryptedMessage}?iv=${Buffer.from(iv.buffer).toString('base64')}`
+  return `${ctb64}?iv=${ivb64}`
 }
 
-export function decrypt(
+export async function decrypt(
   privkey: string,
   pubkey: string,
-  ciphertext: string
-): string {
-  let [cip, iv] = ciphertext.split('?iv=')
+  data: string
+): Promise<string> {
+  let [ctb64, ivb64] = data.split('?iv=')
   let key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
   let normalizedKey = getNormalizedX(key)
 
-  var decipher = aes.createDecipheriv(
-    'aes-256-cbc',
-    Buffer.from(normalizedKey, 'hex'),
-    Buffer.from(iv, 'base64')
+  let cryptoKey = await crypto.subtle.importKey(
+    'raw',
+    normalizedKey,
+    {name: 'AES-CBC'},
+    false,
+    ['decrypt']
   )
-  let decryptedMessage = decipher.update(cip, 'base64', 'utf8')
-  decryptedMessage += decipher.final('utf8')
+  let ciphertext = base64.decode(ctb64)
+  let iv = base64.decode(ivb64)
 
-  return decryptedMessage
+  let plaintext = await crypto.subtle.decrypt(
+    {name: 'AES-CBC', iv},
+    cryptoKey,
+    ciphertext
+  )
+
+  let text = utf8Decoder.decode(plaintext)
+  return text
 }
 
-function getNormalizedX(key: Uint8Array): string {
-  return Buffer.from(key.slice(1, 33)).toString('hex')
+function getNormalizedX(key: Uint8Array): Uint8Array {
+  return key.slice(1, 33)
 }

nip05.ts

@@ -1,6 +1,10 @@
 import {ProfilePointer} from './nip19'
 
-var _fetch = fetch
+var _fetch: any
+
+try {
+  _fetch = fetch
+} catch {}
 
 export function useFetchImplementation(fetchImplementation: any) {
   _fetch = fetchImplementation
@@ -32,9 +36,17 @@ export async function queryProfile(
     name = '_'
   }
 
-  let res = await (
-    await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
-  ).json()
+  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
+  }
 
   if (!res?.names?.[name]) return null
 

nip06.test.js

@@ -0,0 +1,19 @@
+/* eslint-env jest */
+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'
+  )
+})
+
+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'
+  )
+})

nip06.ts

@@ -1,3 +1,4 @@
+import * as secp256k1 from '@noble/secp256k1'
 import {wordlist} from '@scure/bip39/wordlists/english.js'
 import {
   generateMnemonic,
@@ -6,15 +7,14 @@ import {
 } from '@scure/bip39'
 import {HDKey} from '@scure/bip32'
 
-export function privateKeyFromSeed(seed: string): string {
-  let root = HDKey.fromMasterSeed(Buffer.from(seed, 'hex'))
+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')
-  return Buffer.from(privateKey).toString('hex')
-}
-
-export function seedFromWords(mnemonic: string): string {
-  return Buffer.from(mnemonicToSeedSync(mnemonic)).toString('hex')
+  return secp256k1.utils.bytesToHex(privateKey)
 }
 
 export function generateSeedWords(): string {

nip19.test.js

@@ -34,3 +34,69 @@ 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

@@ -1,5 +1,9 @@
 import * as secp256k1 from '@noble/secp256k1'
-import {bech32} from 'bech32'
+import {bech32} from '@scure/base'
+
+import {utf8Decoder, utf8Encoder} from './utils'
+
+const Bech32MaxSize = 5000
 
 export type ProfilePointer = {
   pubkey: string // hex
@@ -11,49 +15,75 @@ export type EventPointer = {
   relays?: string[]
 }
 
-let utf8Decoder = new TextDecoder('utf-8')
-let utf8Encoder = new TextEncoder()
+export type AddressPointer = {
+  identifier: string
+  pubkey: string
+  kind: number
+  relays?: string[]
+}
 
 export function decode(nip19: string): {
   type: string
-  data: ProfilePointer | EventPointer | string
+  data: ProfilePointer | EventPointer | AddressPointer | string
 } {
-  let {prefix, words} = bech32.decode(nip19, 1000)
+  let {prefix, words} = bech32.decode(nip19, Bech32MaxSize)
   let data = new Uint8Array(bech32.fromWords(words))
 
-  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')
+  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')
 
-    return {
-      type: 'nprofile',
-      data: {
-        pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
-        relays: tlv[1].map(d => utf8Decoder.decode(d))
+      return {
+        type: 'nprofile',
+        data: {
+          pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
+          relays: tlv[1] ? 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')
 
-  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))
+      return {
+        type: 'nevent',
+        data: {
+          id: secp256k1.utils.bytesToHex(tlv[0][0]),
+          relays: tlv[1] ? tlv[1].map(d => utf8Decoder.decode(d)) : []
+        }
       }
     }
-  }
 
-  if (prefix === 'nsec' || prefix === 'npub' || prefix === 'note') {
-    return {type: prefix, data: secp256k1.utils.bytesToHex(data)}
-  }
+    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')
 
-  throw new Error(`unknown prefix ${prefix}`)
+      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}`)
+  }
 }
 
 type TLV = {[t: number]: Uint8Array[]}
@@ -88,7 +118,7 @@ export function noteEncode(hex: string): string {
 function encodeBytes(prefix: string, hex: string): string {
   let data = secp256k1.utils.hexToBytes(hex)
   let words = bech32.toWords(data)
-  return bech32.encode(prefix, words, 1000)
+  return bech32.encode(prefix, words, Bech32MaxSize)
 }
 
 export function nprofileEncode(profile: ProfilePointer): string {
@@ -97,7 +127,7 @@ export function nprofileEncode(profile: ProfilePointer): string {
     1: (profile.relays || []).map(url => utf8Encoder.encode(url))
   })
   let words = bech32.toWords(data)
-  return bech32.encode('nprofile', words, 1000)
+  return bech32.encode('nprofile', words, Bech32MaxSize)
 }
 
 export function neventEncode(event: EventPointer): string {
@@ -106,7 +136,21 @@ export function neventEncode(event: EventPointer): string {
     1: (event.relays || []).map(url => utf8Encoder.encode(url))
   })
   let words = bech32.toWords(data)
-  return bech32.encode('nevent', words, 1000)
+  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 {

nip26.test.js

@@ -0,0 +1,105 @@
+/* eslint-env jest */
+
+const {nip26, getPublicKey, generatePrivateKey} = require('./lib/nostr.cjs')
+
+test('parse good delegation from NIP', async () => {
+  expect(
+    nip26.getDelegator({
+      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
+      pubkey:
+        '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
+      created_at: 1660896109,
+      kind: 1,
+      tags: [
+        [
+          'delegation',
+          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
+          'kind=1&created_at>1640995200',
+          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1'
+        ]
+      ],
+      content: 'Hello world',
+      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6'
+    })
+  ).toEqual('86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e')
+})
+
+test('parse bad delegations', async () => {
+  expect(
+    nip26.getDelegator({
+      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
+      pubkey:
+        '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
+      created_at: 1660896109,
+      kind: 1,
+      tags: [
+        [
+          'delegation',
+          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42f',
+          'kind=1&created_at>1640995200',
+          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1'
+        ]
+      ],
+      content: 'Hello world',
+      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6'
+    })
+  ).toEqual(null)
+
+  expect(
+    nip26.getDelegator({
+      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
+      pubkey:
+        '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
+      created_at: 1660896109,
+      kind: 1,
+      tags: [
+        [
+          'delegation',
+          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
+          'kind=1&created_at>1740995200',
+          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1'
+        ]
+      ],
+      content: 'Hello world',
+      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6'
+    })
+  ).toEqual(null)
+
+  expect(
+    nip26.getDelegator({
+      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
+      pubkey:
+        '62903b1ff41559daf9ee98ef1ae67c152f301bb5ce26d14baba3052f649c3f49',
+      created_at: 1660896109,
+      kind: 1,
+      tags: [
+        [
+          'delegation',
+          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
+          'kind=1&created_at>1640995200',
+          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1'
+        ]
+      ],
+      content: 'Hello world',
+      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6'
+    })
+  ).toEqual(null)
+})
+
+test('create and verify delegation', async () => {
+  let sk1 = generatePrivateKey()
+  let pk1 = getPublicKey(sk1)
+  let sk2 = generatePrivateKey()
+  let pk2 = getPublicKey(sk2)
+  let delegation = nip26.createDelegation(sk1, {pubkey: pk2, kind: 1})
+  expect(delegation).toHaveProperty('from', pk1)
+  expect(delegation).toHaveProperty('to', pk2)
+  expect(delegation).toHaveProperty('cond', 'kind=1')
+
+  let event = {
+    kind: 1,
+    tags: [['delegation', delegation.from, delegation.cond, delegation.sig]],
+    pubkey: pk2
+  }
+  expect(nip26.getDelegator(event)).toEqual(pk1)
+})

nip26.ts

@@ -0,0 +1,90 @@
+import * as secp256k1 from '@noble/secp256k1'
+import {sha256} from '@noble/hashes/sha256'
+
+import {Event} from './event'
+import {utf8Encoder} from './utils'
+import {getPublicKey} from './keys'
+
+export type Parameters = {
+  pubkey: string // the key to whom the delegation will be given
+  kind: number | undefined
+  until: number | undefined // delegation will only be valid until this date
+  since: number | undefined // delegation will be valid from this date on
+}
+
+export type Delegation = {
+  from: string // the pubkey who signed the delegation
+  to: string // the pubkey that is allowed to use the delegation
+  cond: string // the string of conditions as they should be included in the event tag
+  sig: string
+}
+
+export function createDelegation(
+  privateKey: string,
+  parameters: Parameters
+): Delegation {
+  let conditions = []
+  if ((parameters.kind || -1) >= 0) conditions.push(`kind=${parameters.kind}`)
+  if (parameters.until) conditions.push(`created_at<${parameters.until}`)
+  if (parameters.since) conditions.push(`created_at>${parameters.since}`)
+  let cond = conditions.join('&')
+
+  if (cond === '')
+    throw new Error('refusing to create a delegation without any conditions')
+
+  let sighash = sha256(
+    utf8Encoder.encode(`nostr:delegation:${parameters.pubkey}:${cond}`)
+  )
+
+  let sig = secp256k1.utils.bytesToHex(
+    secp256k1.schnorr.signSync(sighash, privateKey)
+  )
+
+  return {
+    from: getPublicKey(privateKey),
+    to: parameters.pubkey,
+    cond,
+    sig
+  }
+}
+
+export function getDelegator(event: Event): string | null {
+  // find delegation tag
+  let tag = event.tags.find(tag => tag[0] === 'delegation' && tag.length >= 4)
+  if (!tag) return null
+
+  let pubkey = tag[1]
+  let cond = tag[2]
+  let sig = tag[3]
+
+  // check conditions
+  let conditions = cond.split('&')
+  for (let i = 0; i < conditions.length; i++) {
+    let [key, operator, value] = conditions[i].split(/\b/)
+
+    // the supported conditions are just 'kind' and 'created_at' for now
+    if (key === 'kind' && operator === '=' && event.kind === parseInt(value))
+      continue
+    else if (
+      key === 'created_at' &&
+      operator === '<' &&
+      event.created_at < parseInt(value)
+    )
+      continue
+    else if (
+      key === 'created_at' &&
+      operator === '>' &&
+      event.created_at > parseInt(value)
+    )
+      continue
+    else return null // invalid condition
+  }
+
+  // check signature
+  let sighash = sha256(
+    utf8Encoder.encode(`nostr:delegation:${event.pubkey}:${cond}`)
+  )
+  if (!secp256k1.schnorr.verifySync(sig, sighash, pubkey)) return null
+
+  return pubkey
+}

nip39.test.js

@@ -0,0 +1,15 @@
+/* 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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,138 @@
+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,22 +1,29 @@
 {
   "name": "nostr-tools",
-  "version": "1.0.0-beta",
+  "version": "1.7.5",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/fiatjaf/nostr-tools.git"
+    "url": "https://github.com/nbd-wtf/nostr-tools.git"
   },
+  "files": [
+    "./lib/**/*"
+  ],
+  "types": "./lib/index.d.ts",
   "main": "lib/nostr.cjs.js",
-  "module": "lib/nostr.esm.js",
+  "module": "lib/esm/nostr.mjs",
+  "exports": {
+    "import": "./lib/esm/nostr.mjs",
+    "require": "./lib/nostr.cjs.js"
+  },
+  "license": "Public domain",
   "dependencies": {
-    "@noble/hashes": "^0.5.7",
-    "@noble/secp256k1": "^1.7.0",
-    "@scure/bip32": "^1.1.1",
-    "@scure/bip39": "^1.1.0",
-    "bech32": "^2.0.0",
-    "browserify-cipher": ">=1",
-    "buffer": "^6.0.3",
-    "websocket-polyfill": "^0.0.3"
+    "@noble/hashes": "1.0.0",
+    "@noble/secp256k1": "^1.7.1",
+    "@scure/base": "^1.1.1",
+    "@scure/bip32": "^1.1.5",
+    "@scure/bip39": "^1.1.1",
+    "prettier": "^2.8.4"
   },
   "keywords": [
     "decentralization",
@@ -26,24 +33,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"
-  },
-  "scripts": {
-    "build": "node build.js",
-    "pretest": "node build.js",
-    "test": "jest"
+    "typescript": "^4.9.5",
+    "websocket-polyfill": "^0.0.3"
   }
 }

pool.test.js

@@ -0,0 +1,133 @@
+/* eslint-env jest */
+
+require('websocket-polyfill')
+const {
+  SimplePool,
+  generatePrivateKey,
+  getPublicKey,
+  getEventHash,
+  signEvent
+} = require('./lib/nostr.cjs')
+
+let pool = new SimplePool()
+
+let relays = [
+  'wss://relay.damus.io/',
+  'wss://relay.nostr.bg/',
+  'wss://nostr.fmt.wiz.biz/',
+  'wss://relay.nostr.band/',
+  'wss://nos.lol/'
+]
+
+afterAll(() => {
+  pool.close([
+    ...relays,
+    'wss://nostr.wine',
+    'wss://offchain.pub',
+    'wss://eden.nostr.land'
+  ])
+})
+
+test('removing duplicates when querying', async () => {
+  let priv = generatePrivateKey()
+  let pub = getPublicKey(priv)
+
+  let sub = pool.sub(relays, [{authors: [pub]}])
+  let received = []
+
+  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('same with double querying', async () => {
+  let priv = generatePrivateKey()
+  let pub = getPublicKey(priv)
+
+  let sub1 = pool.sub(relays, [{authors: [pub]}])
+  let sub2 = pool.sub(relays, [{authors: [pub]}])
+
+  let received = []
+
+  sub1.on('event', event => {
+    received.push(event)
+  })
+
+  sub2.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)
+})
+
+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

@@ -0,0 +1,191 @@
+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}
+  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} = {}) {
+    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 ensureRelay(url: string): Promise<Relay> {
+    const nm = normalizeURL(url)
+    const existing = this._conn[nm]
+    if (existing && existing.status === 1) return existing
+
+    if (existing) {
+      await existing.connect()
+      return existing
+    }
+
+    const relay = relayInit(nm, {
+      getTimeout: this.getTimeout * 0.9,
+      listTimeout: this.getTimeout * 0.9
+    })
+    this._conn[nm] = relay
+
+    await relay.connect()
+
+    return relay
+  }
+
+  sub(relays: string[], filters: Filter[], opts?: SubscriptionOptions): Sub {
+    let _knownIds: Set<string> = new Set()
+    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
+      return _knownIds.has(id)
+    }
+
+    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()
+    }, this.eoseSubTimeout)
+
+    relays.forEach(async relay => {
+      let r
+      try {
+        r = await this.ensureRelay(relay)
+      } catch (err) {
+        handleEose()
+        return
+      }
+      if (!r) return
+      let s = r.sub(filters, modifiedOpts)
+      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
+        handleEose()
+      })
+      subs.push(s)
+
+      function handleEose() {
+        eosesMissing--
+        if (eosesMissing === 0) {
+          clearTimeout(eoseTimeout)
+          for (let cb of eoseListeners.values()) cb()
+        }
+      }
+    })
+
+    let greaterSub: Sub = {
+      sub(filters, opts) {
+        subs.forEach(sub => sub.sub(filters, opts))
+        return greaterSub
+      },
+      unsub() {
+        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>)
+        }
+      },
+      off(type, cb) {
+        if (type === 'event') {
+          eventListeners.delete(cb)
+        } else if (type === 'eose')
+          eoseListeners.delete(cb as () => void | Promise<void>)
+      }
+    }
+
+    return greaterSub
+  }
+
+  get(
+    relays: string[],
+    filter: Filter,
+    opts?: SubscriptionOptions
+  ): Promise<Event | null> {
+    return new Promise(resolve => {
+      let sub = this.sub(relays, [filter], opts)
+      let timeout = setTimeout(() => {
+        sub.unsub()
+        resolve(null)
+      }, this.getTimeout)
+      sub.on('event', (event: Event) => {
+        resolve(event)
+        clearTimeout(timeout)
+        sub.unsub()
+      })
+    })
+  }
+
+  list(
+    relays: string[],
+    filters: Filter[],
+    opts?: SubscriptionOptions
+  ): Promise<Event[]> {
+    return new Promise(resolve => {
+      let events: Event[] = []
+      let sub = this.sub(relays, filters, opts)
+
+      sub.on('event', (event: Event) => {
+        events.push(event)
+      })
+
+      // 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 {
+    const pubs: Pub[] = []
+    relays.forEach(async relay => {
+      let r
+      try {
+        r = await this.ensureRelay(relay)
+        pubs.push(r.publish(event))
+      } catch (_) {}
+    })
+    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?.() || [])
+  }
+}

relay.test.js

@@ -1,5 +1,6 @@
 /* eslint-env jest */
 
+require('websocket-polyfill')
 const {
   relayInit,
   generatePrivateKey,
@@ -8,110 +9,132 @@ const {
   signEvent
 } = require('./lib/nostr.cjs')
 
-describe('relay interaction', () => {
-  let relay = relayInit('wss://nostr-pub.semisol.dev/')
+let relay = relayInit('wss://relay.damus.io/')
 
-  beforeAll(() => {
-    relay.connect()
-  })
-
-  afterAll(async () => {
-    await relay.close()
-  })
-
-  test('connectivity', () => {
-    return expect(
-      new Promise(resolve => {
-        relay.on('connect', () => {
-          resolve(true)
-        })
-        relay.on('error', () => {
-          resolve(false)
-        })
-      })
-    ).resolves.toBe(true)
-  })
-
-  test('querying', () => {
-    var resolve1
-    var resolve2
-
-    let sub = relay.sub([
-      {
-        ids: [
-          'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'
-        ]
-      }
-    ])
-    sub.on('event', event => {
-      expect(event).toHaveProperty(
-        'id',
-        'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'
-      )
-      resolve1(true)
-    })
-    sub.on('eose', () => {
-      resolve2(true)
-    })
-
-    return expect(
-      Promise.all([
-        new Promise(resolve => {
-          resolve1 = resolve
-        }),
-        new Promise(resolve => {
-          resolve2 = resolve
-        })
-      ])
-    ).resolves.toEqual([true, true])
-  })
-
-  test('listening (twice) and publishing', async () => {
-    let sk = generatePrivateKey()
-    let pk = getPublicKey(sk)
-    var resolve1
-    var resolve2
-
-    let sub = relay.sub([
-      {
-        kinds: [27572],
-        authors: [pk]
-      }
-    ])
-
-    sub.on('event', event => {
-      expect(event).toHaveProperty('pubkey', pk)
-      expect(event).toHaveProperty('kind', 27572)
-      expect(event).toHaveProperty('content', 'nostr-tools test suite')
-      resolve1(true)
-    })
-    sub.on('event', event => {
-      expect(event).toHaveProperty('pubkey', pk)
-      expect(event).toHaveProperty('kind', 27572)
-      expect(event).toHaveProperty('content', 'nostr-tools test suite')
-      resolve2(true)
-    })
-
-    let event = {
-      kind: 27572,
-      pubkey: pk,
-      created_at: Math.floor(Date.now() / 1000),
-      tags: [],
-      content: 'nostr-tools test suite'
-    }
-    event.id = getEventHash(event)
-    event.sig = await signEvent(event, sk)
-
-    relay.publish(event)
-    return expect(
-      Promise.all([
-        new Promise(resolve => {
-          resolve1 = resolve
-        }),
-        new Promise(resolve => {
-          resolve2 = resolve
-        })
-      ])
-    ).resolves.toEqual([true, true])
-  })
+beforeAll(() => {
+  relay.connect()
+})
+
+afterAll(() => {
+  relay.close()
+})
+
+test('connectivity', () => {
+  return expect(
+    new Promise(resolve => {
+      relay.on('connect', () => {
+        resolve(true)
+      })
+      relay.on('error', () => {
+        resolve(false)
+      })
+    })
+  ).resolves.toBe(true)
+})
+
+test('querying', async () => {
+  var resolve1
+  var resolve2
+
+  let sub = relay.sub([
+    {
+      ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027']
+    }
+  ])
+  sub.on('event', event => {
+    expect(event).toHaveProperty(
+      'id',
+      'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'
+    )
+    resolve1(true)
+  })
+  sub.on('eose', () => {
+    resolve2(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 () => {
+  let sk = generatePrivateKey()
+  let pk = getPublicKey(sk)
+  var resolve1
+  var resolve2
+
+  let sub = relay.sub([
+    {
+      kinds: [27572],
+      authors: [pk]
+    }
+  ])
+
+  sub.on('event', event => {
+    expect(event).toHaveProperty('pubkey', pk)
+    expect(event).toHaveProperty('kind', 27572)
+    expect(event).toHaveProperty('content', 'nostr-tools test suite')
+    resolve1(true)
+  })
+  sub.on('event', event => {
+    expect(event).toHaveProperty('pubkey', pk)
+    expect(event).toHaveProperty('kind', 27572)
+    expect(event).toHaveProperty('content', 'nostr-tools test suite')
+    resolve2(true)
+  })
+
+  let event = {
+    kind: 27572,
+    pubkey: pk,
+    created_at: Math.floor(Date.now() / 1000),
+    tags: [],
+    content: 'nostr-tools test suite'
+  }
+  event.id = getEventHash(event)
+  event.sig = signEvent(event, sk)
+
+  relay.publish(event)
+  return expect(
+    Promise.all([
+      new Promise(resolve => {
+        resolve1 = resolve
+      }),
+      new Promise(resolve => {
+        resolve2 = resolve
+      })
+    ])
+  ).resolves.toEqual([true, true])
 })

relay.ts

@@ -1,60 +1,79 @@
 /* global WebSocket */
 
-import 'websocket-polyfill'
-
 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>
+}
 export type Relay = {
   url: string
   status: number
-  connect: () => void
+  connect: () => Promise<void>
   close: () => void
-  sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
+  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
-  on: (type: 'connect' | 'disconnect' | 'notice', cb: any) => void
-  off: (type: 'connect' | 'disconnect' | 'notice', cb: any) => void
+  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
 }
 export type Pub = {
-  on: (type: 'ok' | 'seen' | 'failed', cb: any) => void
-  off: (type: 'ok' | 'seen' | 'failed', cb: any) => void
+  on: (type: 'ok' | 'failed', cb: any) => void
+  off: (type: 'ok' | 'failed', cb: any) => void
 }
 export type Sub = {
   sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
   unsub: () => void
-  on: (type: 'event' | 'eose', cb: any) => void
-  off: (type: 'event' | 'eose', cb: any) => 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
 }
 
-type SubscriptionOptions = {
-  skipVerification?: boolean
+export type SubscriptionOptions = {
   id?: string
+  skipVerification?: boolean
+  alreadyHaveEvent?: null | ((id: string, relay: string) => boolean)
 }
 
-export function relayInit(url: string): Relay {
+export function relayInit(
+  url: string,
+  options: {
+    getTimeout?: number
+    listTimeout?: number
+  } = {}
+): Relay {
+  let {listTimeout = 3000, getTimeout = 3000} = options
+
   var ws: WebSocket
-  var resolveOpen: () => void
-  var resolveClose: () => void
-  var untilOpen: Promise<void>
-  var wasClosed: boolean
-  var closed: boolean
   var openSubs: {[id: string]: {filters: Filter[]} & SubscriptionOptions} = {}
-  var listeners: {
-    connect: Array<() => void>
-    disconnect: Array<() => void>
-    error: Array<() => void>
-    notice: Array<(msg: string) => void>
-  } = {
+  var listeners: {[TK in keyof RelayEvent]: RelayEvent[TK][]} = {
     connect: [],
     disconnect: [],
     error: [],
     notice: []
   }
   var subListeners: {
-    [subid: string]: {
-      event: Array<(event: Event) => void>
-      eose: Array<() => void>
-    }
+    [subid: string]: {[TK in keyof SubEvent]: SubEvent[TK][]}
   } = {}
   var pubListeners: {
     [eventid: string]: {
@@ -63,136 +82,140 @@ export function relayInit(url: string): Relay {
       failed: Array<(reason: string) => void>
     }
   } = {}
-  let attemptNumber = 1
-  let nextAttemptSeconds = 1
-  let isConnected = false
 
-  function resetOpenState() {
-    untilOpen = new Promise(resolve => {
-      resolveOpen = resolve
+  async function connectRelay(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        ws = new WebSocket(url)
+      } catch (err) {
+        reject(err)
+      }
+
+      ws.onopen = () => {
+        listeners.connect.forEach(cb => cb())
+        resolve()
+      }
+      ws.onerror = () => {
+        listeners.error.forEach(cb => cb())
+        reject()
+      }
+      ws.onclose = async () => {
+        listeners.disconnect.forEach(cb => cb())
+      }
+
+      let incomingMessageQueue: string[] = []
+      let handleNextInterval: any
+
+      ws.onmessage = e => {
+        incomingMessageQueue.push(e.data)
+        if (!handleNextInterval) {
+          handleNextInterval = setInterval(handleNext, 0)
+        }
+      }
+
+      function handleNext() {
+        if (incomingMessageQueue.length === 0) {
+          clearInterval(handleNextInterval)
+          handleNextInterval = null
+          return
+        }
+
+        var json = incomingMessageQueue.shift()
+        if (!json) return
+
+        let subid = getSubscriptionId(json)
+        if (subid) {
+          let so = openSubs[subid]
+          if (
+            so &&
+            so.alreadyHaveEvent &&
+            so.alreadyHaveEvent(getHex64(json, 'id'), url)
+          ) {
+            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':
+              let id = data[1]
+              let event = data[2]
+              if (
+                validateEvent(event) &&
+                openSubs[id] &&
+                (openSubs[id].skipVerification || verifySignature(event)) &&
+                matchFilters(openSubs[id].filters, event)
+              ) {
+                openSubs[id]
+                ;(subListeners[id]?.event || []).forEach(cb => cb(event))
+              }
+              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
+              }
+              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 = []
+              }
+              return
+            }
+            case 'NOTICE':
+              let notice = data[1]
+              listeners.notice.forEach(cb => cb(notice))
+              return
+          }
+        } catch (err) {
+          return
+        }
+      }
     })
   }
 
-  function connectRelay() {
-    ws = new WebSocket(url)
-
-    ws.onopen = () => {
-      listeners.connect.forEach(cb => cb())
-      resolveOpen()
-      isConnected = true
-
-      // restablish old subscriptions
-      if (wasClosed) {
-        wasClosed = false
-        for (let id in openSubs) {
-          let {filters} = openSubs[id]
-          sub(filters, openSubs[id])
-        }
-      }
-    }
-    ws.onerror = () => {
-      isConnected = false
-      listeners.error.forEach(cb => cb())
-    }
-    ws.onclose = async () => {
-      isConnected = false
-      listeners.disconnect.forEach(cb => cb())
-
-      if (closed) {
-        // we've closed this because we wanted, so end everything
-        resolveClose()
-        return
-      }
-
-      // otherwise keep trying to reconnect
-      resetOpenState()
-      attemptNumber++
-      nextAttemptSeconds += attemptNumber ** 3
-      if (nextAttemptSeconds > 14400) {
-        nextAttemptSeconds = 14400 // 4 hours
-      }
-      console.log(
-        `relay ${url} connection closed. reconnecting in ${nextAttemptSeconds} seconds.`
-      )
-      setTimeout(async () => {
-        try {
-          connectRelay()
-        } catch (err) {}
-      }, nextAttemptSeconds * 1000)
-
-      wasClosed = true
-    }
-
-    ws.onmessage = async e => {
-      var data
-      try {
-        data = JSON.parse(e.data)
-      } catch (err) {
-        data = e.data
-      }
-
-      if (data.length >= 1) {
-        switch (data[0]) {
-          case 'EVENT':
-            if (data.length !== 3) return // ignore empty or malformed EVENT
-
-            let id = data[1]
-            let event = data[2]
-            if (
-              validateEvent(event) &&
-              openSubs[id] &&
-              (openSubs[id].skipVerification || verifySignature(event)) &&
-              matchFilters(openSubs[id].filters, event)
-            ) {
-              openSubs[id]
-              subListeners[id]?.event.forEach(cb => cb(event))
-            }
-            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] || ''
-            if (ok) pubListeners[id]?.ok.forEach(cb => cb())
-            else pubListeners[id]?.failed.forEach(cb => cb(reason))
-            return
-          }
-          case 'NOTICE':
-            if (data.length !== 2) return // ignore empty or malformed NOTICE
-            let notice = data[1]
-            listeners.notice.forEach(cb => cb(notice))
-            return
-        }
-      }
-    }
+  function connected() {
+    return ws?.readyState === 1
   }
 
-  resetOpenState()
-
   async function connect(): Promise<void> {
-    if (ws?.readyState && ws.readyState === 1) return // ws already open
-    try {
-      connectRelay()
-    } catch (err) {}
+    if (connected()) return // ws already open
+    await connectRelay()
   }
 
   async function trySend(params: [string, ...any]) {
     let msg = JSON.stringify(params)
-
-    await untilOpen
-    ws.send(msg)
+    if (!connected()) {
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      if (!connected()) {
+        return
+      }
+    }
+    try {
+      ws.send(msg)
+    } catch (err) {
+      console.log(err)
+    }
   }
 
   const sub = (
     filters: Filter[],
     {
       skipVerification = false,
+      alreadyHaveEvent = null,
       id = Math.random().toString().slice(2)
     }: SubscriptionOptions = {}
   ): Sub => {
@@ -201,7 +224,8 @@ export function relayInit(url: string): Relay {
     openSubs[subid] = {
       id: subid,
       filters,
-      skipVerification
+      skipVerification,
+      alreadyHaveEvent
     }
     trySend(['REQ', subid, ...filters])
 
@@ -209,6 +233,7 @@ export function relayInit(url: string): Relay {
       sub: (newFilters, newOpts = {}) =>
         sub(newFilters || filters, {
           skipVerification: newOpts.skipVerification || skipVerification,
+          alreadyHaveEvent: newOpts.alreadyHaveEvent || alreadyHaveEvent,
           id: subid
         }),
       unsub: () => {
@@ -216,16 +241,23 @@ export function relayInit(url: string): Relay {
         delete subListeners[subid]
         trySend(['CLOSE', subid])
       },
-      on: (type: 'event' | 'eose', cb: any): void => {
+      on: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
         subListeners[subid] = subListeners[subid] || {
           event: [],
           eose: []
         }
         subListeners[subid][type].push(cb)
       },
-      off: (type: 'event' | 'eose', cb: any): void => {
-        let idx = subListeners[subid][type].indexOf(cb)
-        if (idx >= 0) subListeners[subid][type].splice(idx, 1)
+      off: <T extends keyof SubEvent, U extends SubEvent[T]>(
+        type: T,
+        cb: U
+      ): void => {
+        let listeners = subListeners[subid]
+        let idx = listeners[type].indexOf(cb)
+        if (idx >= 0) listeners[type].splice(idx, 1)
       }
     }
   }
@@ -233,79 +265,86 @@ export function relayInit(url: string): Relay {
   return {
     url,
     sub,
-    on: (type: 'connect' | 'disconnect' | 'notice', cb: any): void => {
+    on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       listeners[type].push(cb)
-      if (type === 'connect' && isConnected) {
-        cb()
+      if (type === 'connect' && ws?.readyState === 1) {
+        // i would love to know why we need this
+        ;(cb as () => void)()
       }
     },
-    off: (type: 'connect' | 'disconnect' | 'notice', cb: any): void => {
+    off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(
+      type: T,
+      cb: U
+    ): void => {
       let index = listeners[type].indexOf(cb)
       if (index !== -1) listeners[type].splice(index, 1)
     },
+    list: (filters: Filter[], opts?: SubscriptionOptions): Promise<Event[]> =>
+      new Promise(resolve => {
+        let s = sub(filters, opts)
+        let events: Event[] = []
+        let timeout = setTimeout(() => {
+          s.unsub()
+          resolve(events)
+        }, listTimeout)
+        s.on('eose', () => {
+          s.unsub()
+          clearTimeout(timeout)
+          resolve(events)
+        })
+        s.on('event', (event: Event) => {
+          events.push(event)
+        })
+      }),
+    get: (filter: Filter, opts?: SubscriptionOptions): Promise<Event | null> =>
+      new Promise(resolve => {
+        let s = sub([filter], opts)
+        let timeout = setTimeout(() => {
+          s.unsub()
+          resolve(null)
+        }, getTimeout)
+        s.on('event', (event: Event) => {
+          s.unsub()
+          clearTimeout(timeout)
+          resolve(event)
+        })
+      }),
     publish(event: Event): Pub {
       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' | 'seen' | 'failed', cb: any) => {
+        on: (type: 'ok' | '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' | 'seen' | 'failed', cb: any) => {
-          let idx = pubListeners[id][type].indexOf(cb)
-          if (idx >= 0) pubListeners[id][type].splice(idx, 1)
+        off: (type: 'ok' | 'failed', cb: any) => {
+          let listeners = pubListeners[id]
+          if (!listeners) return
+          let idx = listeners[type].indexOf(cb)
+          if (idx >= 0) listeners[type].splice(idx, 1)
         }
       }
     },
     connect,
-    close(): Promise<void> {
-      closed = true // prevent ws from trying to reconnect
-      ws.close()
-      return new Promise(resolve => {
-        resolveClose = resolve
-      })
+    close(): void {
+      listeners = {connect: [], disconnect: [], error: [], notice: []}
+      subListeners = {}
+      pubListeners = {}
+      if (ws.readyState === WebSocket.OPEN) {
+        ws?.close()
+      }
     },
     get status() {
-      return ws.readyState
+      return ws?.readyState ?? 3
     }
   }
 }

tsconfig.json

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

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

@@ -0,0 +1,111 @@
+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
+//
+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
+}