fix buffer import and use rollup for transpiling the package.

.eslintrc.json

@@ -1,9 +1,4 @@
 {
-  "root": true,
-
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint"],
-
   "parserOptions": {
     "ecmaVersion": 9,
     "ecmaFeatures": {
@@ -18,7 +13,9 @@
     "node": true
   },
 
-  "plugins": ["babel"],
+  "plugins": [
+    "babel"
+  ],
 
   "globals": {
     "document": false,
@@ -35,23 +32,23 @@
 
   "rules": {
     "accessor-pairs": 2,
-    "arrow-spacing": [2, {"before": true, "after": true}],
+    "arrow-spacing": [2, { "before": true, "after": true }],
     "block-spacing": [2, "always"],
-    "brace-style": [2, "1tbs", {"allowSingleLine": true}],
+    "brace-style": [2, "1tbs", { "allowSingleLine": true }],
     "comma-dangle": 0,
-    "comma-spacing": [2, {"before": false, "after": true}],
+    "comma-spacing": [2, { "before": false, "after": true }],
     "comma-style": [2, "last"],
     "constructor-super": 2,
     "curly": [0, "multi-line"],
     "dot-location": [2, "property"],
     "eol-last": 2,
     "eqeqeq": [2, "allow-null"],
-    "generator-star-spacing": [2, {"before": true, "after": true}],
-    "handle-callback-err": [2, "^(err|error)$"],
+    "generator-star-spacing": [2, { "before": true, "after": true }],
+    "handle-callback-err": [2, "^(err|error)$" ],
     "indent": 0,
     "jsx-quotes": [2, "prefer-double"],
-    "key-spacing": [2, {"beforeColon": false, "afterColon": true}],
-    "keyword-spacing": [2, {"before": true, "after": true}],
+    "key-spacing": [2, { "beforeColon": false, "afterColon": true }],
+    "keyword-spacing": [2, { "before": true, "after": true }],
     "new-cap": 0,
     "new-parens": 0,
     "no-array-constructor": 2,
@@ -83,12 +80,12 @@
     "no-irregular-whitespace": 2,
     "no-iterator": 2,
     "no-label-var": 2,
-    "no-labels": [2, {"allowLoop": false, "allowSwitch": false}],
+    "no-labels": [2, { "allowLoop": false, "allowSwitch": false }],
     "no-lone-blocks": 2,
     "no-mixed-spaces-and-tabs": 2,
     "no-multi-spaces": 2,
     "no-multi-str": 2,
-    "no-multiple-empty-lines": [2, {"max": 2}],
+    "no-multiple-empty-lines": [2, { "max": 2 }],
     "no-native-reassign": 2,
     "no-negated-in-lhs": 2,
     "no-new": 0,
@@ -117,34 +114,23 @@
     "no-undef": 2,
     "no-undef-init": 2,
     "no-unexpected-multiline": 2,
-    "no-unneeded-ternary": [2, {"defaultAssignment": false}],
+    "no-unneeded-ternary": [2, { "defaultAssignment": false }],
     "no-unreachable": 2,
-    "no-unused-vars": [
-      2,
-      {"vars": "local", "args": "none", "varsIgnorePattern": "^_"}
-    ],
+    "no-unused-vars": [2, { "vars": "local", "args": "none", "varsIgnorePattern": "^_"}],
     "no-useless-call": 2,
     "no-useless-constructor": 2,
     "no-with": 2,
-    "one-var": [0, {"initialized": "never"}],
-    "operator-linebreak": [
-      2,
-      "after",
-      {"overrides": {"?": "before", ":": "before"}}
-    ],
+    "one-var": [0, { "initialized": "never" }],
+    "operator-linebreak": [2, "after", { "overrides": { "?": "before", ":": "before" } }],
     "padded-blocks": [2, "never"],
-    "quotes": [
-      2,
-      "single",
-      {"avoidEscape": true, "allowTemplateLiterals": true}
-    ],
+    "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
     "semi": [2, "never"],
-    "semi-spacing": [2, {"before": false, "after": true}],
+    "semi-spacing": [2, { "before": false, "after": true }],
     "space-before-blocks": [2, "always"],
     "space-before-function-paren": 0,
     "space-in-parens": [2, "never"],
     "space-infix-ops": 2,
-    "space-unary-ops": [2, {"words": true, "nonwords": false}],
+    "space-unary-ops": [2, { "words": true, "nonwords": false }],
     "spaced-comment": 0,
     "template-curly-spacing": [2, "never"],
     "use-isnan": 2,

.github/workflows/npm-publish.yml

@@ -1,18 +0,0 @@
-name: publish npm package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  publish-npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

.github/workflows/test.yml

@@ -1,15 +0,0 @@
-name: test every commit
-on:
-  - push
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-      - run: yarn --ignore-engines
-      - run: node build.cjs
-      - run: yarn test

.gitignore

@@ -2,8 +2,3 @@ node_modules
 dist
 yarn.lock
 package-lock.json
-.envrc
-standalone
-cjs
-esm
-test.html

README.md

@@ -4,161 +4,67 @@ Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 ## Usage
 
-### Generating a private key and a public key
-
 ```js
-import { generatePrivateKey, getPublicKey } from 'nostr-tools'
+import {relayPool} from 'nostr-tools'
 
-let sk = generatePrivateKey() # `sk` is a hex string
-let pk = getPublicKey(sk) # `pk` is a hex string
-```
+const pool = relayPool()
 
-### Creating, signing and verifying events
+pool.setPrivateKey('<hex>') // optional
 
-```js
-import {
-  validateEvent,
-  verifySignature,
-  signEvent,
-  getEventHash,
-  getPublicKey
-} from 'nostr-tools'
+pool.addRelay('ws://some.relay.com', {read: true, write: true})
+pool.addRelay('ws://other.relay.cool', {read: true, write: true})
 
-let event = {
-  kind: 1,
-  created_at: Math.floor(Date.now() / 1000),
-  tags: [],
-  content: 'hello'
+// example callback function for a subscription
+function onEvent(event, relay) => {
+  console.log(`got an event from ${relay.url} which is already validated.`, event)
 }
 
-event.id = getEventHash(event.id)
-event.pubkey = getPublicKey(privateKey)
-event.sig = await signEvent(event, privateKey)
+// subscribing to a single user
+// author is the user's public key
+pool.sub({cb: onEvent, filter: {author: '<hex>'}})
 
-let ok = validateEvent(event)
-let veryOk = await verifySignature(event)
-```
+//  or bulk follow
+pool.sub({cb:(event, relay) => {...}, filter: {authors: ['<hex1>', '<hex2>', ..., '<hexn>']}})
 
-### Interacting with a relay
+// reuse a subscription channel
+const mySubscription = pool.sub({cb: ..., filter: ....})
+mySubscription.sub({filter: ....})
+mySubscription.sub({cb: ...})
+mySubscription.unsub()
 
-```js
-import {
-  relayInit,
-  generatePrivateKey,
-  getPublicKey,
-  getEventHash,
-  signEvent
-} from 'nostr-tools'
-
-const relay = relayInit('wss://relay.example.com')
-relay.connect()
-
-relay.on('connect', () => {
-  console.log(`connected to ${relay.url}`)
-})
-relay.on('error', () => {
-  console.log(`failed to connect to ${relay.url}`)
+// get specific event
+const specificChannel = pool.sub({
+  cb: (event, relay) => {
+    console.log('got specific event from relay', event, relay)
+    specificChannel.unsub()
+  },
+  filter: {id: '<hex>'}
 })
 
-// let's query for an event that exists
-let sub = relay.sub([
-  {
-    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027']
+// or get a specific event plus all the events that reference it in the 'e' tag
+pool.sub({ cb: (event, relay) => { ... }, filter: [{id: '<hex>'}, {'#e': '<hex>'}] })
+
+// get all events
+pool.sub({cb: (event, relay) => {...}, filter: {}})
+
+// get recent events
+pool.sub({cb: (event, relay) => {...}, filter: {since: timestamp}})
+
+// publishing events(inside an async function):
+const ev = await pool.publish(eventObject, (status, url) => {
+  if (status === 0) {
+    console.log(`publish request sent to ${url}`)
   }
-])
-sub.on('event', event => {
-  console.log('we got the event we wanted:', event)
-})
-sub.on('eose', () => {
-  sub.unsub()
-})
-
-// let's publish a new event while simultaneously monitoring the relay for it
-let sk = generatePrivateKey()
-let pk = getPublicKey(sk)
-
-let sub = relay.sub([
-  {
-    kinds: [1],
-    authors: [pk]
+  if (status === 1) {
+    console.log(`event published by ${url}`, ev)
   }
-])
-
-sub.on('event', event => {
-  console.log('got event:', event)
 })
+// it will be signed automatically with the key supplied above
+// or pass an already signed event to bypass this
 
-let event = {
-  kind: 1,
-  pubkey: pk,
-  created_at: Math.floor(Date.now() / 1000),
-  tags: [],
-  content: 'hello world'
-}
-event.id = getEventHash(event)
-event.sig = await 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}`)
-})
-pub.on('failed', reason => {
-  console.log(`failed to publish to {relay.url}: ${reason}`)
-})
-
-await relay.close()
+// subscribing to a new relay
+pool.addRelay('<url>')
+// will automatically subscribe to the all the events called with .sub above
 ```
 
-### Encrypting and decrypting direct messages
-
-```js
-import {nip04, getPublicKey, generatePrivateKey} from 'nostr-tools'
-
-// sender
-let sk1 = generatePrivateKey()
-let pk1 = getPublicKey(sk1)
-
-// receiver
-let sk2 = generatePrivateKey()
-let pk2 = getPublicKey(sk2)
-
-// on the sender side
-let message = 'hello'
-let ciphertext = nip04.encrypt(sk1, pk2, 'hello')
-
-let event = {
-  kind: 4,
-  pubkey: pk1,
-  tags: [['p', pk2]],
-  content: ciphertext,
-  ...otherProperties
-}
-
-sendEvent(event)
-
-// on the receiver side
-
-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)
-})
-```
-
-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)
-
-```html
-<script src="https://unpkg.com/nostr-tools/standalone/index.js"></script>
-<script>
-  window.NostrTools.generatePrivateKey('...') // and so on
-</script>
-```
-
-## License
-
-Public domain.
+For other utils please read the source (for now).

build.cjs

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-
-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, outdir: 'esm/', format: 'esm', packages: 'external'})
-  .then(() => console.log('esm build success.'))
-
-esbuild
-  .build({...common, outdir: 'cjs/', format: 'cjs', packages: 'external'})
-  .then(() => console.log('cjs build success.'))
-
-esbuild
-  .build({
-    ...common,
-    outdir: 'standalone/',
-    format: 'iife',
-    globalName: 'NostrTools',
-    define: {
-      window: 'self',
-      global: 'self',
-      process: '{"env": {}}'
-    }
-  })
-  .then(() => console.log('standalone build success.'))

event.js

@@ -0,0 +1,43 @@
+import Buffer from 'buffer'
+import * as secp256k1 from '@noble/secp256k1'
+
+import {sha256} from './utils'
+
+export function getBlankEvent() {
+  return {
+    kind: 255,
+    pubkey: null,
+    content: '',
+    tags: [],
+    created_at: 0
+  }
+}
+
+export function serializeEvent(evt) {
+  return JSON.stringify([
+    0,
+    evt.pubkey,
+    evt.created_at,
+    evt.kind,
+    evt.tags || [],
+    evt.content
+  ])
+}
+
+export async function getEventHash(event) {
+  let eventHash = await sha256(Buffer.from(serializeEvent(event)))
+  return Buffer.from(eventHash).toString('hex')
+}
+
+export async function verifySignature(event) {
+  return await secp256k1.schnorr.verify(
+    event.sig,
+    await getEventHash(event),
+    event.pubkey
+  )
+}
+
+export async function signEvent(event, key) {
+  let eventHash = await getEventHash(event)
+  return await secp256k1.schnorr.sign(eventHash, key)
+}

event.test.js

@@ -1,49 +0,0 @@
-/* eslint-env jest */
-
-const {
-  validateEvent,
-  verifySignature,
-  signEvent,
-  getEventHash,
-  getPublicKey
-} = require('./cjs')
-
-const event = {
-  id: 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027',
-  kind: 1,
-  pubkey: '22a12a128a3be27cd7fb250cbe796e692896398dc1440ae3fa567812c8107c1c',
-  created_at: 1670869179,
-  content:
-    'NOSTR "WINE-ACCOUNT" WITH HARVEST DATE STAMPED\n\n\n"The older the wine, the greater its reputation"\n\n\n22a12a128a3be27cd7fb250cbe796e692896398dc1440ae3fa567812c8107c1c\n\n\nNWA 2022-12-12\nAA',
-  tags: [['client', 'astral']],
-  sig: 'f110e4fdf67835fb07abc72469933c40bdc7334615610cade9554bf00945a1cebf84f8d079ec325d26fefd76fe51cb589bdbe208ac9cdbd63351ddad24a57559'
-}
-
-const unsigned = {
-  created_at: 1671217411,
-  kind: 0,
-  tags: [],
-  content:
-    '{"name":"fiatjaf","about":"buy my merch at fiatjaf store","picture":"https://fiatjaf.com/static/favicon.jpg","nip05":"_@fiatjaf.com"}'
-}
-
-const privateKey =
-  '5c6c25b7ef18d8633e97512159954e1aa22809c6b763e94b9f91071836d00217'
-
-test('validate event', () => {
-  expect(validateEvent(event)).toBeTruthy()
-})
-
-test('check signature', async () => {
-  expect(await verifySignature(event)).toBeTruthy()
-})
-
-test('sign event', async () => {
-  let sig = await signEvent(unsigned, privateKey)
-  let hash = getEventHash(unsigned)
-  let pubkey = getPublicKey(privateKey)
-
-  let signed = {...unsigned, id: hash, sig, pubkey}
-
-  expect(await verifySignature(signed)).toBeTruthy()
-})

event.ts

@@ -1,69 +0,0 @@
-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
-  tags: string[][]
-  pubkey: string
-  content: string
-  created_at: number
-}
-
-export function getBlankEvent(): Event {
-  return {
-    kind: 255,
-    pubkey: '',
-    content: '',
-    tags: [],
-    created_at: 0
-  }
-}
-
-export function serializeEvent(evt: Event): string {
-  return JSON.stringify([
-    0,
-    evt.pubkey,
-    evt.created_at,
-    evt.kind,
-    evt.tags,
-    evt.content
-  ])
-}
-
-export function getEventHash(event: Event): string {
-  let eventHash = sha256(Buffer.from(serializeEvent(event)))
-  return Buffer.from(eventHash).toString('hex')
-}
-
-export function validateEvent(event: Event): boolean {
-  if (event.id !== getEventHash(event)) return false
-  if (typeof event.content !== 'string') return false
-  if (typeof event.created_at !== 'number') return false
-
-  if (!Array.isArray(event.tags)) return false
-  for (let i = 0; i < event.tags.length; i++) {
-    let tag = event.tags[i]
-    if (!Array.isArray(tag)) return false
-    for (let j = 0; j < tag.length; j++) {
-      if (typeof tag[j] === 'object') return false
-    }
-  }
-
-  return true
-}
-
-export function verifySignature(
-  event: Event & {id: string; sig: string}
-): Promise<boolean> {
-  return secp256k1.schnorr.verify(event.sig, event.id, 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')
-}

filter.test.js

@@ -1,42 +0,0 @@
-/* eslint-env jest */
-
-const {matchFilters} = require('./cjs')
-
-test('test if filters match', () => {
-  ;[
-    {
-      filters: [{ids: ['i']}],
-      good: [{id: 'i'}],
-      bad: [{id: 'j'}]
-    },
-    {
-      filters: [{authors: ['abc']}, {kinds: [1, 3]}],
-      good: [
-        {pubkey: 'xyz', kind: 3},
-        {pubkey: 'abc', kind: 12},
-        {pubkey: 'abc', kind: 1}
-      ],
-      bad: [{pubkey: 'hhh', kind: 12}]
-    },
-    {
-      filters: [{'#e': ['yyy'], since: 444}],
-      good: [
-        {
-          tags: [
-            ['e', 'uuu'],
-            ['e', 'yyy']
-          ],
-          created_at: 555
-        }
-      ],
-      bad: [{tags: [['e', 'uuu']], created_at: 111}]
-    }
-  ].forEach(({filters, good, bad}) => {
-    good.forEach(ev => {
-      expect(matchFilters(filters, ev)).toBeTruthy()
-    })
-    bad.forEach(ev => {
-      expect(matchFilters(filters, ev)).toBeFalsy()
-    })
-  })
-})

filter.ts

@@ -1,49 +0,0 @@
-import {Event} from './event'
-
-export type Filter = {
-  ids?: string[]
-  kinds?: number[]
-  authors?: string[]
-  since?: number
-  until?: number
-  [key: `#${string}`]: string[]
-}
-
-export function matchFilter(
-  filter: Filter,
-  event: Event & {id: string}
-): boolean {
-  if (filter.ids && filter.ids.indexOf(event.id) === -1) return false
-  if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) return false
-  if (filter.authors && filter.authors.indexOf(event.pubkey) === -1)
-    return false
-
-  for (let f in filter) {
-    if (f[0] === '#') {
-      let tagName = f.slice(1)
-      let values = filter[`#${tagName}`]
-      if (
-        values &&
-        !event.tags.find(
-          ([t, v]) => t === f.slice(1) && values.indexOf(v) !== -1
-        )
-      )
-        return false
-    }
-  }
-
-  if (filter.since && event.created_at < filter.since) return false
-  if (filter.until && event.created_at >= filter.until) return false
-
-  return true
-}
-
-export function matchFilters(
-  filters: Filter[],
-  event: Event & {id: string}
-): boolean {
-  for (let i = 0; i < filters.length; i++) {
-    if (matchFilter(filters[i], event)) return true
-  }
-  return false
-}

index.js

@@ -0,0 +1,25 @@
+import {relayConnect} from './relay'
+import {relayPool} from './pool'
+import {
+  getBlankEvent,
+  signEvent,
+  verifySignature,
+  serializeEvent,
+  getEventHash
+} from './event'
+import {makeRandom32, sha256, getPublicKey} from './utils'
+
+export {
+  relayConnect,
+  relayPool,
+  signEvent,
+  verifySignature,
+  serializeEvent,
+  getEventHash,
+  makeRandom32,
+  sha256,
+  getPublicKey,
+  getBlankEvent
+}
+export * from './nip04'
+export * from './nip05'

index.ts

@@ -1,8 +0,0 @@
-export * from './keys'
-export * from './relay'
-export * from './event'
-export * from './filter'
-
-export * as nip04 from './nip04'
-export * as nip05 from './nip05'
-export * as nip06 from './nip06'

keys.test.js

@@ -1,20 +0,0 @@
-/* eslint-env jest */
-
-const {generatePrivateKey, getPublicKey} = require('./cjs')
-
-test('test private key generation', () => {
-  expect(generatePrivateKey()).toMatch(/[a-f0-9]{64}/)
-})
-
-test('test public key generation', () => {
-  expect(getPublicKey(generatePrivateKey())).toMatch(/[a-f0-9]{64}/)
-})
-
-test('test public key from private key deterministic', () => {
-  let sk = generatePrivateKey()
-  let pk = getPublicKey(sk)
-
-  for (let i = 0; i < 5; i++) {
-    expect(getPublicKey(sk)).toEqual(pk)
-  }
-})

keys.ts

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

nip04.js

@@ -0,0 +1,37 @@
+import Buffer from 'buffer'
+import * as secp256k1 from '@noble/secp256k1'
+
+export function encrypt(privkey, pubkey, text) {
+  const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
+  const normalizedKey = getOnlyXFromFullSharedSecret(key)
+
+  let iv = crypto.randomFillSync(new Uint8Array(16))
+  var cipher = crypto.createCipheriv(
+    'aes-256-cbc',
+    Buffer.from(normalizedKey, 'hex'),
+    iv
+  )
+  let encryptedMessage = cipher.update(text, 'utf8', 'base64')
+  encryptedMessage += cipher.final('base64')
+
+  return [encryptedMessage, Buffer.from(iv.buffer).toString('base64')]
+}
+
+export function decrypt(privkey, pubkey, ciphertext, iv) {
+  const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
+  const normalizedKey = getOnlyXFromFullSharedSecret(key)
+
+  var decipher = crypto.createDecipheriv(
+    'aes-256-cbc',
+    Buffer.from(normalizedKey, 'hex'),
+    Buffer.from(iv, 'base64')
+  )
+  let decryptedMessage = decipher.update(ciphertext, 'base64')
+  decryptedMessage += decipher.final('utf8')
+
+  return decryptedMessage
+}
+
+function getOnlyXFromFullSharedSecret(fullSharedSecretCoordinates) {
+  return fullSharedSecretCoordinates.substr(2, 64)
+}

nip04.test.js

@@ -1,14 +0,0 @@
-/* eslint-env jest */
-
-const {nip04, getPublicKey, generatePrivateKey} = require('./cjs')
-
-test('encrypt and decrypt message', () => {
-  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'
-  )
-})

nip04.ts

@@ -1,45 +0,0 @@
-import {Buffer} from 'buffer'
-import {randomBytes} from '@noble/hashes/utils'
-import * as secp256k1 from '@noble/secp256k1'
-// @ts-ignore
-import aes from 'browserify-cipher'
-
-export function encrypt(privkey: string, pubkey: string, text: string): 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 encryptedMessage = cipher.update(text, 'utf8', 'base64')
-  encryptedMessage += cipher.final('base64')
-
-  return `${encryptedMessage}?iv=${Buffer.from(iv.buffer).toString('base64')}`
-}
-
-export function decrypt(
-  privkey: string,
-  pubkey: string,
-  ciphertext: string
-): string {
-  let [cip, iv] = ciphertext.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 decryptedMessage = decipher.update(cip, 'base64', 'utf8')
-  decryptedMessage += decipher.final('utf8')
-
-  return decryptedMessage
-}
-
-function getNormalizedX(key: Uint8Array): string {
-  return Buffer.from(key.slice(1, 33)).toString('hex')
-}

nip05.js

@@ -0,0 +1,52 @@
+import Buffer from 'buffer'
+import dnsPacket from 'dns-packet'
+
+const dohProviders = [
+  'cloudflare-dns.com',
+  'fi.doh.dns.snopyta.org',
+  'basic.bravedns.com',
+  'hydra.plan9-ns1.com',
+  'doh.pl.ahadns.net',
+  'dns.flatuslifir.is',
+  'doh.dns.sb',
+  'doh.li'
+]
+
+let counter = 0
+
+export async function keyFromDomain(domain) {
+  let host = dohProviders[counter % dohProviders.length]
+
+  let buf = dnsPacket.encode({
+    type: 'query',
+    id: Math.floor(Math.random() * 65534),
+    flags: dnsPacket.RECURSION_DESIRED,
+    questions: [
+      {
+        type: 'TXT',
+        name: `_nostrkey.${domain}`
+      }
+    ]
+  })
+
+  let fetching = fetch(`https://${host}/dns-query`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/dns-message',
+      'Content-Length': Buffer.byteLength(buf)
+    },
+    body: buf
+  })
+
+  counter++
+
+  try {
+    let response = Buffer.from(await (await fetching).arrayBuffer())
+    let {answers} = dnsPacket.decode(response)
+    if (answers.length === 0) return null
+    return Buffer.from(answers[0].data[0]).toString()
+  } catch (err) {
+    console.log(`error querying DNS for ${domain} on ${host}`, err)
+    return null
+  }
+}

nip05.ts

@@ -1,31 +0,0 @@
-var _fetch = fetch
-
-export function useFetchImplementation(fetchImplementation: any) {
-  _fetch = fetchImplementation
-}
-
-export async function searchDomain(
-  domain: string,
-  query = ''
-): Promise<{[name: string]: string}> {
-  try {
-    let res = await (
-      await _fetch(`https://${domain}/.well-known/nostr.json?name=${query}`)
-    ).json()
-
-    return res.names
-  } catch (_) {
-    return {}
-  }
-}
-
-export async function queryName(fullname: string): Promise<string> {
-  let [name, domain] = fullname.split('@')
-  if (!domain) throw new Error('invalid identifier, must contain an @')
-
-  let res = await (
-    await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
-  ).json()
-
-  return res.names && res.names[name]
-}

nip06.ts

@@ -1,26 +0,0 @@
-import {wordlist} from '@scure/bip39/wordlists/english.js'
-import {
-  generateMnemonic,
-  mnemonicToSeedSync,
-  validateMnemonic
-} from '@scure/bip39'
-import {HDKey} from '@scure/bip32'
-
-export function privateKeyFromSeed(seed: string): string {
-  let root = HDKey.fromMasterSeed(Buffer.from(seed, 'hex'))
-  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')
-}
-
-export function generateSeedWords(): string {
-  return generateMnemonic(wordlist)
-}
-
-export function validateWords(words: string): boolean {
-  return validateMnemonic(words, wordlist)
-}

package.json

@@ -1,47 +1,39 @@
 {
   "name": "nostr-tools",
-  "version": "1.0.0-alpha",
+  "version": "0.6.2",
   "description": "Tools for making a Nostr client.",
+  "main": "dist/nostr-tools.esm.min.js",
+  "module": "dist/nostr-tools.esm.min.js",
+  "browser": "dist/nostr-tools.umd.min.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/fiatjaf/nostr-tools.git"
   },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
   "dependencies": {
-    "@noble/hashes": "^0.5.7",
-    "@noble/secp256k1": "^1.7.0",
-    "@scure/bip32": "^1.1.1",
-    "@scure/bip39": "^1.1.0",
-    "browserify-cipher": ">=1",
+    "@noble/secp256k1": "^1.3.0",
     "buffer": "^6.0.3",
+    "dns-packet": "^5.2.4",
     "websocket-polyfill": "^0.0.3"
   },
   "keywords": [
     "decentralization",
+    "twitter",
+    "p2p",
+    "mastodon",
+    "ssb",
     "social",
+    "unstoppable",
+    "censorship",
     "censorship-resistance",
-    "client",
-    "nostr"
+    "client"
   ],
   "devDependencies": {
-    "@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.30.0",
-    "eslint-plugin-babel": "^5.3.1",
-    "esm-loader-typescript": "^1.0.1",
-    "events": "^3.3.0",
-    "jest": "^29.3.1",
-    "ts-jest": "^29.0.3",
-    "tsd": "^0.22.0",
-    "typescript": "^4.9.4"
+    "rollup": "^2.61.1"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "node build.cjs",
-    "pretest": "node build.cjs",
-    "test": "jest"
+    "prepublish": "rollup -c"
   }
 }

pool.js

@@ -0,0 +1,122 @@
+import {getEventHash, signEvent} from './event'
+import {relayConnect, normalizeRelayURL} from './relay'
+
+export function relayPool(globalPrivateKey) {
+  const relays = {}
+  const globalSub = []
+  const noticeCallbacks = []
+
+  function propagateNotice(notice, relayURL) {
+    for (let i = 0; i < noticeCallbacks.length; i++) {
+      let {relay} = relays[relayURL]
+      noticeCallbacks[i](notice, relay)
+    }
+  }
+
+  const activeSubscriptions = {}
+
+  const sub = ({cb, filter}, id = Math.random().toString().slice(2)) => {
+    const subControllers = Object.fromEntries(
+      Object.values(relays)
+        .filter(({policy}) => policy.read)
+        .map(({relay}) => [
+          relay.url,
+          relay.sub({filter, cb: event => cb(event, relay.url)})
+        ])
+    )
+
+    const activeCallback = cb
+    const activeFilters = filter
+
+    activeSubscriptions[id] = {
+      sub: ({cb = activeCallback, filter = activeFilters}) =>
+        Object.entries(subControllers).map(([relayURL, sub]) => [
+          relayURL,
+          sub.sub({cb, filter}, id)
+        ]),
+      addRelay: relay => {
+        subControllers[relay.url] = relay.sub({cb, filter})
+      },
+      removeRelay: relayURL => {
+        if (relayURL in subControllers) {
+          subControllers[relayURL].unsub()
+          if (Object.keys(subControllers).length === 0) unsub()
+        }
+      },
+      unsub: () => {
+        Object.values(subControllers).forEach(sub => sub.unsub())
+        delete activeSubscriptions[id]
+      }
+    }
+
+    return activeSubscriptions[id]
+  }
+
+  return {
+    sub,
+    relays,
+    setPrivateKey(privateKey) {
+      globalPrivateKey = privateKey
+    },
+    async addRelay(url, policy = {read: true, write: true}) {
+      let relayURL = normalizeRelayURL(url)
+      if (relayURL in relays) return
+
+      let relay = await relayConnect(url, notice => {
+        propagateNotice(notice, relayURL)
+      })
+      relays[relayURL] = {relay, policy}
+
+      Object.values(activeSubscriptions).forEach(subscription =>
+        subscription.addRelay(relay)
+      )
+
+      return relay
+    },
+    removeRelay(url) {
+      let relayURL = normalizeRelayURL(url)
+      let {relay} = relays[relayURL]
+      if (!relay) return
+      Object.values(activeSubscriptions).forEach(subscription =>
+        subscription.removeRelay(relay)
+      )
+      relay.close()
+      delete relays[relayURL]
+    },
+    onNotice(cb) {
+      noticeCallbacks.push(cb)
+    },
+    offNotice(cb) {
+      let index = noticeCallbacks.indexOf(cb)
+      if (index !== -1) noticeCallbacks.splice(index, 1)
+    },
+    async publish(event, statusCallback = (status, relayURL) => {}) {
+      if (!event.sig) {
+        event.tags = event.tags || []
+
+        if (globalPrivateKey) {
+          event.id = await getEventHash(event)
+          event.sig = await signEvent(event, globalPrivateKey)
+        } else {
+          throw new Error(
+            "can't publish unsigned event. either sign this event beforehand or pass a private key while initializing this relay pool so it can be signed automatically."
+          )
+        }
+      }
+
+      Object.values(relays)
+        .filter(({policy}) => policy.write)
+        .map(async ({relay}) => {
+          try {
+            await relay.publish(event, status =>
+              statusCallback(status, relay.url)
+            )
+          } catch (err) {
+            statusCallback(-1, relay.url)
+          }
+        })
+
+      return event
+    }
+  }
+}

relay.js

@@ -0,0 +1,160 @@
+import 'websocket-polyfill'
+
+import {verifySignature} from './event'
+
+export function normalizeRelayURL(url) {
+  let [host, ...qs] = url.split('?')
+  if (host.slice(0, 4) === 'http') host = 'ws' + host.slice(4)
+  if (host.slice(0, 2) !== 'ws') host = 'wss://' + host
+  if (host.length && host[host.length - 1] === '/') host = host.slice(0, -1)
+  return [host, ...qs].join('?')
+}
+
+export function relayConnect(url, onNotice) {
+  url = normalizeRelayURL(url)
+
+  var ws, resolveOpen, untilOpen
+  var openSubs = {}
+  let attemptNumber = 1
+  let nextAttemptSeconds = 1
+
+  function resetOpenState() {
+    untilOpen = new Promise(resolve => {
+      resolveOpen = resolve
+    })
+  }
+
+  var channels = {}
+
+  function connect() {
+    ws = new WebSocket(url)
+
+    ws.onopen = () => {
+      console.log('connected to', url)
+      resolveOpen()
+
+      // restablish old subscriptions
+      for (let channel in openSubs) {
+        let filters = openSubs[channel]
+        let cb = channels[channel]
+        sub({cb, filter: filters}, channel)
+      }
+    }
+    ws.onerror = () => {
+      console.log('error connecting to relay', url)
+    }
+    ws.onclose = () => {
+      resetOpenState()
+      attemptNumber++
+      nextAttemptSeconds += attemptNumber
+      console.log(
+        `relay ${url} connection closed. reconnecting in ${nextAttemptSeconds} seconds.`
+      )
+      setTimeout(async () => {
+        try {
+          connect()
+        } catch (err) {}
+      }, nextAttemptSeconds * 1000)
+    }
+
+    ws.onmessage = async e => {
+      var data
+      try {
+        data = JSON.parse(e.data)
+      } catch (err) {
+        data = e.data
+      }
+
+      if (data.length > 1) {
+        if (data[0] === 'NOTICE') {
+          if (data.length < 2) return
+
+          console.log('message from relay ' + url + ': ' + data[1])
+          onNotice(data[1])
+          return
+        }
+
+        if (data[0] === 'EVENT') {
+          if (data.length < 3) return
+
+          let channel = data[1]
+          let event = data[2]
+
+          if (await verifySignature(event)) {
+            if (channels[channel]) {
+              channels[channel](event)
+            }
+          } else {
+            console.warn('got event with invalid signature from ' + url, event)
+          }
+          return
+        }
+      }
+    }
+  }
+
+  resetOpenState()
+
+  try {
+    connect()
+  } catch (err) {}
+
+  async function trySend(params) {
+    let msg = JSON.stringify(params)
+
+    await untilOpen
+    ws.send(msg)
+  }
+
+  const sub = ({cb, filter}, channel = Math.random().toString().slice(2)) => {
+    var filters = []
+    if (Array.isArray(filter)) {
+      filters = filter
+    } else {
+      filters.push(filter)
+    }
+
+    trySend(['REQ', channel, ...filters])
+    channels[channel] = cb
+    openSubs[channel] = filters
+
+    const activeCallback = cb
+    const activeFilters = filters
+
+    return {
+      sub: ({cb = activeCallback, filter = activeFilters}) =>
+        sub({cb, filter}, channel),
+      unsub: () => {
+        delete openSubs[channel]
+        delete channels[channel]
+        trySend(['CLOSE', channel])
+      }
+    }
+  }
+
+  return {
+    url,
+    sub,
+    async publish(event, statusCallback = status => {}) {
+      try {
+        await trySend(['EVENT', event])
+        statusCallback(0)
+        let {unsub} = relay.sub({
+          cb: () => {
+            statusCallback(1)
+          },
+          filter: {id: event.id}
+        })
+        setTimeout(unsub, 5000)
+      } catch (err) {
+        statusCallback(-1)
+      }
+    },
+    close() {
+      ws.close()
+    },
+    get status() {
+      return ws.readyState
+    }
+  }
+}

relay.test.js

@@ -1,117 +0,0 @@
-/* eslint-env jest */
-
-const {
-  relayInit,
-  generatePrivateKey,
-  getPublicKey,
-  getEventHash,
-  signEvent
-} = require('./cjs')
-
-describe('relay interaction', () => {
-  let relay = relayInit('wss://nostr-pub.wellorder.net/')
-
-  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])
-  })
-})

relay.ts

@@ -1,311 +0,0 @@
-/* global WebSocket */
-
-import 'websocket-polyfill'
-
-import {Event, verifySignature, validateEvent} from './event'
-import {Filter, matchFilters} from './filter'
-
-export type Relay = {
-  url: string
-  status: number
-  connect: () => void
-  close: () => void
-  sub: (filters: Filter[], opts: SubscriptionOptions) => Sub
-  publish: (event: Event) => Pub
-  on: (type: 'connect' | 'disconnect' | 'notice', cb: any) => void
-  off: (type: 'connect' | 'disconnect' | 'notice', cb: any) => void
-}
-export type Pub = {
-  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: (type: 'event' | 'eose', cb: any) => void
-  off: (type: 'event' | 'eose', cb: any) => void
-}
-
-type SubscriptionOptions = {
-  skipVerification?: boolean
-  id?: string
-}
-
-export function relayInit(url: string): Relay {
-  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>
-  } = {
-    connect: [],
-    disconnect: [],
-    error: [],
-    notice: []
-  }
-  var subListeners: {
-    [subid: string]: {
-      event: Array<(event: Event) => void>
-      eose: Array<() => void>
-    }
-  } = {}
-  var pubListeners: {
-    [eventid: string]: {
-      ok: Array<() => void>
-      seen: Array<() => void>
-      failed: Array<(reason: string) => void>
-    }
-  } = {}
-  let attemptNumber = 1
-  let nextAttemptSeconds = 1
-  let isConnected = false
-
-  function resetOpenState() {
-    untilOpen = new Promise(resolve => {
-      resolveOpen = resolve
-    })
-  }
-
-  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
-        }
-      }
-    }
-  }
-
-  resetOpenState()
-
-  async function connect(): Promise<void> {
-    if (ws?.readyState && ws.readyState === 1) return // ws already open
-    try {
-      connectRelay()
-    } catch (err) {}
-  }
-
-  async function trySend(params: [string, ...any]) {
-    let msg = JSON.stringify(params)
-
-    await untilOpen
-    ws.send(msg)
-  }
-
-  const sub = (
-    filters: Filter[],
-    {
-      skipVerification = false,
-      id = Math.random().toString().slice(2)
-    }: SubscriptionOptions = {}
-  ): Sub => {
-    let subid = id
-
-    openSubs[subid] = {
-      id: subid,
-      filters,
-      skipVerification
-    }
-    trySend(['REQ', subid, ...filters])
-
-    return {
-      sub: (newFilters, newOpts = {}) =>
-        sub(newFilters || filters, {
-          skipVerification: newOpts.skipVerification || skipVerification,
-          id: subid
-        }),
-      unsub: () => {
-        delete openSubs[subid]
-        delete subListeners[subid]
-        trySend(['CLOSE', subid])
-      },
-      on: (type: 'event' | 'eose', cb: any): 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)
-      }
-    }
-  }
-
-  return {
-    url,
-    sub,
-    on: (type: 'connect' | 'disconnect' | 'notice', cb: any): void => {
-      listeners[type].push(cb)
-      if (type === 'connect' && isConnected) {
-        cb()
-      }
-    },
-    off: (type: 'connect' | 'disconnect' | 'notice', cb: any): void => {
-      let index = listeners[type].indexOf(cb)
-      if (index !== -1) listeners[type].splice(index, 1)
-    },
-    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) => {
-          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)
-        }
-      }
-    },
-    connect,
-    close(): Promise<void> {
-      closed = true // prevent ws from trying to reconnect
-      ws.close()
-      return new Promise(resolve => {
-        resolveClose = resolve
-      })
-    },
-    get status() {
-      return ws.readyState
-    }
-  }
-}

rollup.config.js

@@ -0,0 +1,16 @@
+import pkg from './package.json'
+
+export default {
+  input: 'index.js',
+  output: [
+    {
+      name: 'nostrtools',
+      file: pkg.browser,
+      format: 'umd'
+    },
+    {
+      file: pkg.module,
+      format: 'es'
+    }
+  ]
+}

tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "esnext",
-    "target": "esnext",
-    "lib": ["dom", "dom.iterable", "esnext"],
-    "declaration": true,
-    "strict": true,
-    "moduleResolution": "node",
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "emitDeclarationOnly": true,
-    "outDir": "dist",
-    "rootDir": "."
-  }
-}

utils.js

@@ -0,0 +1,6 @@
+import * as secp256k1 from '@noble/secp256k1'
+
+export const makeRandom32 = () => secp256k1.utils.randomPrivateKey()
+export const sha256 = m => secp256k1.utils.sha256(Uint8Array.from(m))
+export const getPublicKey = privateKey =>
+  secp256k1.schnorr.getPublicKey(privateKey)