nostr-tools 0.5.0 → 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

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

package/dist/nostr-tools.esm.min.js

@@ -0,0 +1,411 @@
+import 'websocket-polyfill';
+import Buffer from 'buffer';
+import * as secp256k1 from '@noble/secp256k1';
+import dnsPacket from 'dns-packet';
+
+const makeRandom32 = () => secp256k1.utils.randomPrivateKey();
+const sha256 = m => secp256k1.utils.sha256(Uint8Array.from(m));
+const getPublicKey = privateKey =>
+  secp256k1.schnorr.getPublicKey(privateKey);
+
+function getBlankEvent() {
+  return {
+    kind: 255,
+    pubkey: null,
+    content: '',
+    tags: [],
+    created_at: 0
+  }
+}
+
+function serializeEvent(evt) {
+  return JSON.stringify([
+    0,
+    evt.pubkey,
+    evt.created_at,
+    evt.kind,
+    evt.tags || [],
+    evt.content
+  ])
+}
+
+async function getEventHash(event) {
+  let eventHash = await sha256(Buffer.from(serializeEvent(event)));
+  return Buffer.from(eventHash).toString('hex')
+}
+
+async function verifySignature(event) {
+  return await secp256k1.schnorr.verify(
+    event.sig,
+    await getEventHash(event),
+    event.pubkey
+  )
+}
+
+async function signEvent(event, key) {
+  let eventHash = await getEventHash(event);
+  return await secp256k1.schnorr.sign(eventHash, key)
+}
+
+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('?')
+}
+
+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
+    }
+  }
+}
+
+function relayPool(globalPrivateKey) {
+  const relays = {};
+  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
+    }
+  }
+}
+
+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')]
+}
+
+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)
+}
+
+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;
+
+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
+  }
+}
+
+export { decrypt, encrypt, getBlankEvent, getEventHash, getPublicKey, keyFromDomain, makeRandom32, relayConnect, relayPool, serializeEvent, sha256, signEvent, verifySignature };

package/dist/nostr-tools.umd.min.js

@@ -0,0 +1,452 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('websocket-polyfill'), require('buffer'), require('@noble/secp256k1'), require('dns-packet')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'websocket-polyfill', 'buffer', '@noble/secp256k1', 'dns-packet'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.nostrtools = {}, null, global.Buffer, global.secp256k1, global.dnsPacket));
+})(this, (function (exports, websocketPolyfill, Buffer, secp256k1, dnsPacket) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+  }
+
+  var Buffer__default = /*#__PURE__*/_interopDefaultLegacy(Buffer);
+  var secp256k1__namespace = /*#__PURE__*/_interopNamespace(secp256k1);
+  var dnsPacket__default = /*#__PURE__*/_interopDefaultLegacy(dnsPacket);
+
+  const makeRandom32 = () => secp256k1__namespace.utils.randomPrivateKey();
+  const sha256 = m => secp256k1__namespace.utils.sha256(Uint8Array.from(m));
+  const getPublicKey = privateKey =>
+    secp256k1__namespace.schnorr.getPublicKey(privateKey);
+
+  function getBlankEvent() {
+    return {
+      kind: 255,
+      pubkey: null,
+      content: '',
+      tags: [],
+      created_at: 0
+    }
+  }
+
+  function serializeEvent(evt) {
+    return JSON.stringify([
+      0,
+      evt.pubkey,
+      evt.created_at,
+      evt.kind,
+      evt.tags || [],
+      evt.content
+    ])
+  }
+
+  async function getEventHash(event) {
+    let eventHash = await sha256(Buffer__default["default"].from(serializeEvent(event)));
+    return Buffer__default["default"].from(eventHash).toString('hex')
+  }
+
+  async function verifySignature(event) {
+    return await secp256k1__namespace.schnorr.verify(
+      event.sig,
+      await getEventHash(event),
+      event.pubkey
+    )
+  }
+
+  async function signEvent(event, key) {
+    let eventHash = await getEventHash(event);
+    return await secp256k1__namespace.schnorr.sign(eventHash, key)
+  }
+
+  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('?')
+  }
+
+  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
+      }
+    }
+  }
+
+  function relayPool(globalPrivateKey) {
+    const relays = {};
+    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
+      }
+    }
+  }
+
+  function encrypt(privkey, pubkey, text) {
+    const key = secp256k1__namespace.getSharedSecret(privkey, '02' + pubkey);
+    const normalizedKey = getOnlyXFromFullSharedSecret(key);
+
+    let iv = crypto.randomFillSync(new Uint8Array(16));
+    var cipher = crypto.createCipheriv(
+      'aes-256-cbc',
+      Buffer__default["default"].from(normalizedKey, 'hex'),
+      iv
+    );
+    let encryptedMessage = cipher.update(text, 'utf8', 'base64');
+    encryptedMessage += cipher.final('base64');
+
+    return [encryptedMessage, Buffer__default["default"].from(iv.buffer).toString('base64')]
+  }
+
+  function decrypt(privkey, pubkey, ciphertext, iv) {
+    const key = secp256k1__namespace.getSharedSecret(privkey, '02' + pubkey);
+    const normalizedKey = getOnlyXFromFullSharedSecret(key);
+
+    var decipher = crypto.createDecipheriv(
+      'aes-256-cbc',
+      Buffer__default["default"].from(normalizedKey, 'hex'),
+      Buffer__default["default"].from(iv, 'base64')
+    );
+    let decryptedMessage = decipher.update(ciphertext, 'base64');
+    decryptedMessage += decipher.final('utf8');
+
+    return decryptedMessage
+  }
+
+  function getOnlyXFromFullSharedSecret(fullSharedSecretCoordinates) {
+    return fullSharedSecretCoordinates.substr(2, 64)
+  }
+
+  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;
+
+  async function keyFromDomain(domain) {
+    let host = dohProviders[counter % dohProviders.length];
+
+    let buf = dnsPacket__default["default"].encode({
+      type: 'query',
+      id: Math.floor(Math.random() * 65534),
+      flags: dnsPacket__default["default"].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__default["default"].byteLength(buf)
+      },
+      body: buf
+    });
+
+    counter++;
+
+    try {
+      let response = Buffer__default["default"].from(await (await fetching).arrayBuffer());
+      let {answers} = dnsPacket__default["default"].decode(response);
+      if (answers.length === 0) return null
+      return Buffer__default["default"].from(answers[0].data[0]).toString()
+    } catch (err) {
+      console.log(`error querying DNS for ${domain} on ${host}`, err);
+      return null
+    }
+  }
+
+  exports.decrypt = decrypt;
+  exports.encrypt = encrypt;
+  exports.getBlankEvent = getBlankEvent;
+  exports.getEventHash = getEventHash;
+  exports.getPublicKey = getPublicKey;
+  exports.keyFromDomain = keyFromDomain;
+  exports.makeRandom32 = makeRandom32;
+  exports.relayConnect = relayConnect;
+  exports.relayPool = relayPool;
+  exports.serializeEvent = serializeEvent;
+  exports.sha256 = sha256;
+  exports.signEvent = signEvent;
+  exports.verifySignature = verifySignature;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/event.js

@@ -1,4 +1,5 @@
-import * as secp256k1 from 'noble-secp256k1'
+import Buffer from 'buffer'
+import * as secp256k1 from '@noble/secp256k1'
 
 import {sha256} from './utils'
 

package/index.js

@@ -21,3 +21,5 @@ export {
   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

@@ -1,3 +1,4 @@
+import Buffer from 'buffer'
 import dnsPacket from 'dns-packet'
 
 const dohProviders = [

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "nostr-tools",
-  "version": "0.5.0",
+  "version": "0.6.3",
   "description": "Tools for making a Nostr client.",
-  "main": "index.js",
+  "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"
   },
   "dependencies": {
+    "@noble/secp256k1": "^1.3.0",
     "buffer": "^6.0.3",
     "dns-packet": "^5.2.4",
-    "noble-secp256k1": "^1.1.1",
     "websocket-polyfill": "^0.0.3"
   },
   "keywords": [
@@ -24,5 +26,11 @@
     "censorship",
     "censorship-resistance",
     "client"
-  ]
+  ],
+  "devDependencies": {
+    "rollup": "^2.61.1"
+  },
+  "scripts": {
+    "prepublish": "rollup -c"
+  }
 }

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

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