nostr-tools 0.6.2 → 0.6.3

package/.eslintrc.json

@@ -0,0 +1,142 @@
+{
+  "parserOptions": {
+    "ecmaVersion": 9,
+    "ecmaFeatures": {
+      "jsx": true
+    },
+    "sourceType": "module",
+    "allowImportExportEverywhere": false
+  },
+
+  "env": {
+    "es6": true,
+    "node": true
+  },
+
+  "plugins": [
+    "babel"
+  ],
+
+  "globals": {
+    "document": false,
+    "navigator": false,
+    "window": false,
+    "location": false,
+    "URL": false,
+    "URLSearchParams": false,
+    "fetch": false,
+    "EventSource": false,
+    "localStorage": false,
+    "sessionStorage": false
+  },
+
+  "rules": {
+    "accessor-pairs": 2,
+    "arrow-spacing": [2, { "before": true, "after": true }],
+    "block-spacing": [2, "always"],
+    "brace-style": [2, "1tbs", { "allowSingleLine": true }],
+    "comma-dangle": 0,
+    "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)$" ],
+    "indent": 0,
+    "jsx-quotes": [2, "prefer-double"],
+    "key-spacing": [2, { "beforeColon": false, "afterColon": true }],
+    "keyword-spacing": [2, { "before": true, "after": true }],
+    "new-cap": 0,
+    "new-parens": 0,
+    "no-array-constructor": 2,
+    "no-caller": 2,
+    "no-class-assign": 2,
+    "no-cond-assign": 2,
+    "no-const-assign": 2,
+    "no-control-regex": 0,
+    "no-debugger": 0,
+    "no-delete-var": 2,
+    "no-dupe-args": 2,
+    "no-dupe-class-members": 2,
+    "no-dupe-keys": 2,
+    "no-duplicate-case": 2,
+    "no-empty-character-class": 2,
+    "no-empty-pattern": 2,
+    "no-eval": 0,
+    "no-ex-assign": 2,
+    "no-extend-native": 2,
+    "no-extra-bind": 2,
+    "no-extra-boolean-cast": 2,
+    "no-extra-parens": [2, "functions"],
+    "no-fallthrough": 2,
+    "no-floating-decimal": 2,
+    "no-func-assign": 2,
+    "no-implied-eval": 2,
+    "no-inner-declarations": [0, "functions"],
+    "no-invalid-regexp": 2,
+    "no-irregular-whitespace": 2,
+    "no-iterator": 2,
+    "no-label-var": 2,
+    "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-native-reassign": 2,
+    "no-negated-in-lhs": 2,
+    "no-new": 0,
+    "no-new-func": 2,
+    "no-new-object": 2,
+    "no-new-require": 2,
+    "no-new-symbol": 2,
+    "no-new-wrappers": 2,
+    "no-obj-calls": 2,
+    "no-octal": 2,
+    "no-octal-escape": 2,
+    "no-path-concat": 0,
+    "no-proto": 2,
+    "no-redeclare": 2,
+    "no-regex-spaces": 2,
+    "no-return-assign": 0,
+    "no-self-assign": 2,
+    "no-self-compare": 2,
+    "no-sequences": 2,
+    "no-shadow-restricted-names": 2,
+    "no-spaced-func": 2,
+    "no-sparse-arrays": 2,
+    "no-this-before-super": 2,
+    "no-throw-literal": 2,
+    "no-trailing-spaces": 2,
+    "no-undef": 2,
+    "no-undef-init": 2,
+    "no-unexpected-multiline": 2,
+    "no-unneeded-ternary": [2, { "defaultAssignment": false }],
+    "no-unreachable": 2,
+    "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" } }],
+    "padded-blocks": [2, "never"],
+    "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
+    "semi": [2, "never"],
+    "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 }],
+    "spaced-comment": 0,
+    "template-curly-spacing": [2, "never"],
+    "use-isnan": 2,
+    "valid-typeof": 2,
+    "wrap-iife": [2, "any"],
+    "yield-star-spacing": [2, "both"],
+    "yoda": [0]
+  }
+}

package/.prettierrc.yaml

@@ -0,0 +1,10 @@
+semi: false
+arrowParens: avoid
+insertPragma: false
+printWidth: 80
+proseWrap: preserve
+singleQuote: true
+trailingComma: none
+useTabs: false
+jsxBracketSameLine: false
+bracketSpacing: false

package/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)
+}

package/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'

package/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)
+}

package/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
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Tools for making a Nostr client.",
   "main": "dist/nostr-tools.esm.min.js",
   "module": "dist/nostr-tools.esm.min.js",
@@ -30,9 +30,6 @@
   "devDependencies": {
     "rollup": "^2.61.1"
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "prepublish": "rollup -c"
   }

package/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
+    }
+  }
+}

package/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
+    }
+  }
+}

package/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'
+    }
+  ]
+}

package/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)