bump version.

when updating subscription or adding new relays, subsequent events that are received have the relay as undefined. by updating cb property for the subControllers entries to be an arrow function (when calling sub.sub or sub.addRelay), subsequent events now return the relay url appropriately

.gitignore

@@ -2,3 +2,4 @@ node_modules
 dist
 yarn.lock
 package-lock.json
+nostr.js

README.md

@@ -15,7 +15,7 @@ pool.addRelay('ws://some.relay.com', {read: true, write: true})
 pool.addRelay('ws://other.relay.cool', {read: true, write: true})
 
 // example callback function for a subscription
-function onEvent(event, relay) => {
+function onEvent(event, relay) {
   console.log(`got an event from ${relay.url} which is already validated.`, event)
 }
 
@@ -70,3 +70,20 @@ pool.addRelay('<url>')
 All functions expect bytearrays as hex strings and output bytearrays as hex strings.
 
 For other utils please read the source (for now).
+
+### Using from the browser (if you don't want to use a bundler)
+
+You can import nostr-tools as an ES module. Just add a script tag like this:
+
+```html
+<script type="module">
+  import {generatePrivateKey} from 'https://unpkg.com/nostr-tools/nostr.js'
+  console.log(generatePrivateKey())
+</script>
+```
+
+And import whatever function you would import from `"nostr-tools"` in a bundler.
+
+## License
+
+Public domain.

build.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const esbuild = require('esbuild')
+const alias = require('esbuild-plugin-alias')
+const nodeGlobals = require('@esbuild-plugins/node-globals-polyfill').default
+
+const buildOptions = {
+  entryPoints: ['index.js'],
+  outfile: 'nostr.js',
+  bundle: true,
+  format: 'esm',
+  plugins: [
+    alias({
+      stream: require.resolve('readable-stream')
+    }),
+    nodeGlobals({buffer: true})
+  ],
+  define: {
+    window: 'self',
+    global: 'self'
+  },
+  loader: {'.js': 'jsx'}
+}
+
+esbuild.build(buildOptions).then(() => console.log('build success.'))

event.js

@@ -52,5 +52,7 @@ export function verifySignature(event) {
 }
 
 export async function signEvent(event, key) {
-  return secp256k1.schnorr.sign(getEventHash(event), key)
+  return Buffer.from(
+    await secp256k1.schnorr.sign(getEventHash(event), key)
+  ).toString('hex')
 }

filter.js

@@ -1,6 +1,6 @@
 export function matchFilter(filter, event) {
-  if (filter.ids && filter.ids.indexOf(event.id) !== -1) return false
-  if (filter.kinds && filter.kinds.indexOf(event.kind) !== -1) return false
+  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
 
@@ -8,7 +8,9 @@ export function matchFilter(filter, event) {
     if (f[0] === '#') {
       if (
         filter[f] &&
-        !event.tags.find(([t, v]) => t === f.slice(1) && v === filter[f])
+        !event.tags.find(
+          ([t, v]) => t === f.slice(1) && filter[f].indexOf(v) !== -1
+        )
       )
         return false
     }

keys.js

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

nip04.js

@@ -5,7 +5,7 @@ import * as secp256k1 from '@noble/secp256k1'
 
 export function encrypt(privkey, pubkey, text) {
   const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
-  const normalizedKey = getOnlyXFromFullSharedSecret(key)
+  const normalizedKey = getNormalizedX(key)
 
   let iv = Uint8Array.from(randomBytes(16))
   var cipher = aes.createCipheriv(
@@ -16,24 +16,27 @@ export function encrypt(privkey, pubkey, text) {
   let encryptedMessage = cipher.update(text, 'utf8', 'base64')
   encryptedMessage += cipher.final('base64')
 
-  return [encryptedMessage, Buffer.from(iv.buffer).toString('base64')]
+  return `${encryptedMessage}?iv=${Buffer.from(iv.buffer).toString('base64')}`
 }
 
-export function decrypt(privkey, pubkey, ciphertext, iv) {
-  const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
-  const normalizedKey = getOnlyXFromFullSharedSecret(key)
+export function decrypt(privkey, pubkey, ciphertext) {
+  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(ciphertext, 'base64')
+  let decryptedMessage = decipher.update(cip, 'base64')
   decryptedMessage += decipher.final('utf8')
 
   return decryptedMessage
 }
 
-function getOnlyXFromFullSharedSecret(fullSharedSecretCoordinates) {
-  return fullSharedSecretCoordinates.substr(2, 64)
+function getNormalizedX(key) {
+  return typeof key === 'string'
+    ? key.substr(2, 64)
+    : Buffer.from(key.slice(1, 33)).toString('hex')
 }

nip05.js

@@ -1,52 +1,28 @@
-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++
+import fetch from 'cross-fetch'
 
+export async function searchDomain(domain, query = '') {
   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)
+    let res = await (
+      await fetch(`https://${domain}/.well-known/nostr.json?name=${query}`)
+    ).json()
+
+    return res.names
+  } catch (_) {
+    return []
+  }
+}
+
+export async function queryName(fullname) {
+  try {
+    let [name, domain] = fullname.split('@')
+    if (!domain) return null
+
+    let res = await (
+      await fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)
+    ).json()
+
+    return res.names && res.names[name]
+  } catch (_) {
     return null
   }
 }

nip06.js

@@ -8,13 +8,13 @@ import {HDKey} from 'micro-bip32'
 
 export function privateKeyFromSeed(seed) {
   let root = HDKey.fromMasterSeed(Buffer.from(seed, 'hex'))
-  return Buffer.from(root.derive(`m/44'/1237'/0'/0'`).privateKey).toString(
+  return Buffer.from(root.derive(`m/44'/1237'/0'/0/0`).privateKey).toString(
     'hex'
   )
 }
 
 export function seedFromWords(mnemonic) {
-  return Buffer.from(mnemonicToSeedSync(mnemonic, wordlist)).toString('hex')
+  return Buffer.from(mnemonicToSeedSync(mnemonic)).toString('hex')
 }
 
 export function generateSeedWords() {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "0.16.0",
+  "version": "0.23.4",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -8,11 +8,11 @@
   },
   "dependencies": {
     "@noble/hashes": "^0.5.7",
-    "@noble/secp256k1": "^1.3.0",
+    "@noble/secp256k1": "^1.5.2",
     "browserify-cipher": ">=1",
     "buffer": ">=5",
     "create-hash": "^1.2.0",
-    "dns-packet": "^5.2.4",
+    "cross-fetch": "^3.1.4",
     "micro-bip32": "^0.1.0",
     "micro-bip39": "^0.1.3",
     "websocket-polyfill": "^0.0.3"
@@ -30,7 +30,15 @@
     "client"
   ],
   "devDependencies": {
+    "@esbuild-plugins/node-globals-polyfill": "^0.1.1",
+    "esbuild": "^0.14.38",
+    "esbuild-plugin-alias": "^0.2.1",
     "eslint": "^8.5.0",
-    "eslint-plugin-babel": "^5.3.1"
+    "eslint-plugin-babel": "^5.3.1",
+    "events": "^3.3.0",
+    "readable-stream": "^3.6.0"
+  },
+  "scripts": {
+    "prepublish": "node build.js"
   }
 }

pool.js

@@ -1,12 +1,18 @@
-import {getEventHash, signEvent} from './event'
+import {getEventHash, verifySignature, signEvent} from './event'
 import {relayConnect, normalizeRelayURL} from './relay'
 
 export function relayPool() {
   var globalPrivateKey
+  var globalSigningFunction
+
   const poolPolicy = {
     // setting this to a number will cause events to be published to a random
     // set of relays only, instead of publishing to all relays all the time
-    randomChoice: null
+    randomChoice: null,
+
+    // setting this to true will cause .publish() calls to wait until the event has
+    // been published -- or at least attempted to be published -- to all relays
+    wait: false
   }
   const relays = {}
   const noticeCallbacks = []
@@ -20,32 +26,42 @@ export function relayPool() {
 
   const activeSubscriptions = {}
 
-  const sub = ({cb, filter}, id = Math.random().toString().slice(2)) => {
+  const sub = ({cb, filter, beforeSend}, id) => {
+    if (!id) 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)}, id)
+          relay.sub({cb: event => cb(event, relay.url), filter, beforeSend}, id)
         ])
     )
 
     const activeCallback = cb
     const activeFilters = filter
+    const activeBeforeSend = beforeSend
 
     const unsub = () => {
       Object.values(subControllers).forEach(sub => sub.unsub())
       delete activeSubscriptions[id]
     }
-    const sub = ({cb = activeCallback, filter = activeFilters}) => {
+    const sub = ({
+      cb = activeCallback,
+      filter = activeFilters,
+      beforeSend = activeBeforeSend
+    }) => {
       Object.entries(subControllers).map(([relayURL, sub]) => [
         relayURL,
-        sub.sub({cb, filter}, id)
+        sub.sub({cb: event => cb(event, relayURL), filter, beforeSend}, id)
       ])
       return activeSubscriptions[id]
     }
     const addRelay = relay => {
-      subControllers[relay.url] = relay.sub({cb, filter}, id)
+      subControllers[relay.url] = relay.sub(
+        {cb: event => cb(event, relay.url), filter, beforeSend},
+        id
+      )
       return activeSubscriptions[id]
     }
     const removeRelay = relayURL => {
@@ -72,6 +88,9 @@ export function relayPool() {
     setPrivateKey(privateKey) {
       globalPrivateKey = privateKey
     },
+    registerSigningFunction(fn) {
+      globalSigningFunction = fn
+    },
     setPolicy(key, value) {
       poolPolicy[key] = value
     },
@@ -111,7 +130,7 @@ export function relayPool() {
       let index = noticeCallbacks.indexOf(cb)
       if (index !== -1) noticeCallbacks.splice(index, 1)
     },
-    async publish(event, statusCallback = (status, relayURL) => {}) {
+    async publish(event, statusCallback) {
       event.id = getEventHash(event)
 
       if (!event.sig) {
@@ -119,9 +138,21 @@ export function relayPool() {
 
         if (globalPrivateKey) {
           event.sig = await signEvent(event, globalPrivateKey)
+        } else if (globalSigningFunction) {
+          event.sig = await globalSigningFunction(event)
+          if (!event.sig) {
+            // abort here
+            return
+          } else {
+            // check
+            if (!(await verifySignature(event)))
+              throw new Error(
+                'signature provided by custom signing function is invalid.'
+              )
+          }
         } 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."
+            "can't publish unsigned event. either sign this event beforehand, provide a signing function or pass a private key while initializing this relay pool so it can be signed automatically."
           )
         }
       }
@@ -136,6 +167,7 @@ export function relayPool() {
 
       let successes = 0
 
+      if (poolPolicy.wait) {
         for (let i = 0; i < writeable.length; i++) {
           let {relay} = writeable[i]
 
@@ -143,11 +175,11 @@ export function relayPool() {
             await new Promise(async (resolve, reject) => {
               try {
                 await relay.publish(event, status => {
-                statusCallback(status, relay.url)
+                  if (statusCallback) statusCallback(status, relay.url)
                   resolve()
                 })
               } catch (err) {
-              statusCallback(-1, relay.url)
+                if (statusCallback) statusCallback(-1, relay.url)
               }
             })
 
@@ -159,6 +191,14 @@ export function relayPool() {
             /***/
           }
         }
+      } else {
+        writeable.forEach(async ({relay}) => {
+          let callback = statusCallback
+            ? status => statusCallback(status, relay.url)
+            : null
+          relay.publish(event, callback)
+        })
+      }
 
       return event
     }

relay.js

@@ -119,7 +119,10 @@ export function relayConnect(url, onNotice = () => {}, onError = () => {}) {
     ws.send(msg)
   }
 
-  const sub = ({cb, filter}, channel = Math.random().toString().slice(2)) => {
+  const sub = (
+    {cb, filter, beforeSend},
+    channel = Math.random().toString().slice(2)
+  ) => {
     var filters = []
     if (Array.isArray(filter)) {
       filters = filter
@@ -127,16 +130,25 @@ export function relayConnect(url, onNotice = () => {}, onError = () => {}) {
       filters.push(filter)
     }
 
+    if (beforeSend) {
+      const beforeSendResult = beforeSend({filter, relay: url, channel})
+      filters = beforeSendResult.filter
+    }
+
     trySend(['REQ', channel, ...filters])
     channels[channel] = cb
     openSubs[channel] = filters
 
     const activeCallback = cb
     const activeFilters = filters
+    const activeBeforeSend = beforeSend
 
     return {
-      sub: ({cb = activeCallback, filter = activeFilters}) =>
-        sub({cb, filter}, channel),
+      sub: ({
+        cb = activeCallback,
+        filter = activeFilters,
+        beforeSend = activeBeforeSend
+      }) => sub({cb, filter, beforeSend}, channel),
       unsub: () => {
         delete openSubs[channel]
         delete channels[channel]
@@ -160,7 +172,7 @@ export function relayConnect(url, onNotice = () => {}, onError = () => {}) {
                 unsub()
                 clearTimeout(willUnsub)
               },
-              filter: {id: event.id}
+              filter: {ids: [event.id]}
             },
             `monitor-${event.id.slice(0, 5)}`
           )