nostr-tools 1.7.5 → 1.8.0

package/README.md

@@ -170,6 +170,26 @@ let relaysForEvent = pool.seenOn(
 // relaysForEvent will be an array of URLs from relays a given event was seen on
 ```
 
+### Parsing references (mentions) from a content using NIP-10 and NIP-27
+
+```js
+import {parseReferences} from 'nostr-tools'
+
+let references = parseReferences(event)
+let simpleAugmentedContent = event.content
+for (let i = 0; i < references.length; i++) {
+  let {text, profile, event, address} = references[i]
+  let augmentedReference = profile
+    ? `<strong>@${profilesCache[profile.pubkey].name}</strong>`
+    : event
+    ? `<em>${eventsCache[event.id].content.slice(0, 5)}</em>`
+    : address
+    ? `<a href="${text}">[link]</a>`
+    : text
+  simpleAugmentedContent.replaceAll(text, augmentedReference)
+}
+```
+
 ### Querying profile data from a NIP-05 address
 
 ```js

package/lib/esm/nostr.mjs

@@ -569,6 +569,7 @@ var SimplePool = class {
       let set = this._seenOn[id] || /* @__PURE__ */ new Set();
       set.add(url);
       this._seenOn[id] = set;
+      _knownIds.add(id);
       return _knownIds.has(id);
     };
     let subs = [];
@@ -593,7 +594,6 @@ var SimplePool = class {
         return;
       let s = r.sub(filters, modifiedOpts);
       s.on("event", (event) => {
-        _knownIds.add(event.id);
         for (let cb of eventListeners.values())
           cb(event);
       });
@@ -688,139 +688,6 @@ var SimplePool = class {
   }
 };
 
-// nip04.ts
-var nip04_exports = {};
-__export(nip04_exports, {
-  decrypt: () => decrypt,
-  encrypt: () => encrypt
-});
-import { randomBytes } from "@noble/hashes/utils";
-import * as secp256k13 from "@noble/secp256k1";
-import { base64 } from "@scure/base";
-async function encrypt(privkey, pubkey, text) {
-  const key = secp256k13.getSharedSecret(privkey, "02" + pubkey);
-  const normalizedKey = getNormalizedX(key);
-  let iv = Uint8Array.from(randomBytes(16));
-  let plaintext = utf8Encoder.encode(text);
-  let cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    normalizedKey,
-    { name: "AES-CBC" },
-    false,
-    ["encrypt"]
-  );
-  let ciphertext = await crypto.subtle.encrypt(
-    { name: "AES-CBC", iv },
-    cryptoKey,
-    plaintext
-  );
-  let ctb64 = base64.encode(new Uint8Array(ciphertext));
-  let ivb64 = base64.encode(new Uint8Array(iv.buffer));
-  return `${ctb64}?iv=${ivb64}`;
-}
-async function decrypt(privkey, pubkey, data) {
-  let [ctb64, ivb64] = data.split("?iv=");
-  let key = secp256k13.getSharedSecret(privkey, "02" + pubkey);
-  let normalizedKey = getNormalizedX(key);
-  let cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    normalizedKey,
-    { name: "AES-CBC" },
-    false,
-    ["decrypt"]
-  );
-  let ciphertext = base64.decode(ctb64);
-  let iv = base64.decode(ivb64);
-  let plaintext = await crypto.subtle.decrypt(
-    { name: "AES-CBC", iv },
-    cryptoKey,
-    ciphertext
-  );
-  let text = utf8Decoder.decode(plaintext);
-  return text;
-}
-function getNormalizedX(key) {
-  return key.slice(1, 33);
-}
-
-// nip05.ts
-var nip05_exports = {};
-__export(nip05_exports, {
-  queryProfile: () => queryProfile,
-  searchDomain: () => searchDomain,
-  useFetchImplementation: () => useFetchImplementation
-});
-var _fetch;
-try {
-  _fetch = fetch;
-} catch {
-}
-function useFetchImplementation(fetchImplementation) {
-  _fetch = fetchImplementation;
-}
-async function searchDomain(domain, query = "") {
-  try {
-    let res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${query}`)).json();
-    return res.names;
-  } catch (_) {
-    return {};
-  }
-}
-async function queryProfile(fullname) {
-  let [name, domain] = fullname.split("@");
-  if (!domain) {
-    domain = name;
-    name = "_";
-  }
-  if (!name.match(/^[A-Za-z0-9-_]+$/))
-    return null;
-  if (!domain.includes("."))
-    return null;
-  let res;
-  try {
-    res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)).json();
-  } catch (err) {
-    return null;
-  }
-  if (!res?.names?.[name])
-    return null;
-  let pubkey = res.names[name];
-  let relays = res.relays?.[pubkey] || [];
-  return {
-    pubkey,
-    relays
-  };
-}
-
-// nip06.ts
-var nip06_exports = {};
-__export(nip06_exports, {
-  generateSeedWords: () => generateSeedWords,
-  privateKeyFromSeedWords: () => privateKeyFromSeedWords,
-  validateWords: () => validateWords
-});
-import * as secp256k14 from "@noble/secp256k1";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import {
-  generateMnemonic,
-  mnemonicToSeedSync,
-  validateMnemonic
-} from "@scure/bip39";
-import { HDKey } from "@scure/bip32";
-function privateKeyFromSeedWords(mnemonic, passphrase) {
-  let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase));
-  let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey;
-  if (!privateKey)
-    throw new Error("could not derive private key");
-  return secp256k14.utils.bytesToHex(privateKey);
-}
-function generateSeedWords() {
-  return generateMnemonic(wordlist);
-}
-function validateWords(words) {
-  return validateMnemonic(words, wordlist);
-}
-
 // nip19.ts
 var nip19_exports = {};
 __export(nip19_exports, {
@@ -832,7 +699,7 @@ __export(nip19_exports, {
   npubEncode: () => npubEncode,
   nsecEncode: () => nsecEncode
 });
-import * as secp256k15 from "@noble/secp256k1";
+import * as secp256k13 from "@noble/secp256k1";
 import { bech32 } from "@scure/base";
 var Bech32MaxSize = 5e3;
 function decode(nip19) {
@@ -848,7 +715,7 @@ function decode(nip19) {
       return {
         type: "nprofile",
         data: {
-          pubkey: secp256k15.utils.bytesToHex(tlv[0][0]),
+          pubkey: secp256k13.utils.bytesToHex(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
@@ -859,11 +726,14 @@ function decode(nip19) {
         throw new Error("missing TLV 0 for nevent");
       if (tlv[0][0].length !== 32)
         throw new Error("TLV 0 should be 32 bytes");
+      if (tlv[2] && tlv[2][0].length !== 32)
+        throw new Error("TLV 2 should be 32 bytes");
       return {
         type: "nevent",
         data: {
-          id: secp256k15.utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
+          id: secp256k13.utils.bytesToHex(tlv[0][0]),
+          relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : [],
+          author: tlv[2]?.[0] ? secp256k13.utils.bytesToHex(tlv[2][0]) : void 0
         }
       };
     }
@@ -883,8 +753,8 @@ function decode(nip19) {
         type: "naddr",
         data: {
           identifier: utf8Decoder.decode(tlv[0][0]),
-          pubkey: secp256k15.utils.bytesToHex(tlv[2][0]),
-          kind: parseInt(secp256k15.utils.bytesToHex(tlv[3][0]), 16),
+          pubkey: secp256k13.utils.bytesToHex(tlv[2][0]),
+          kind: parseInt(secp256k13.utils.bytesToHex(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
@@ -892,7 +762,7 @@ function decode(nip19) {
     case "nsec":
     case "npub":
     case "note":
-      return { type: prefix, data: secp256k15.utils.bytesToHex(data) };
+      return { type: prefix, data: secp256k13.utils.bytesToHex(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -922,13 +792,13 @@ function noteEncode(hex) {
   return encodeBytes("note", hex);
 }
 function encodeBytes(prefix, hex) {
-  let data = secp256k15.utils.hexToBytes(hex);
+  let data = secp256k13.utils.hexToBytes(hex);
   let words = bech32.toWords(data);
   return bech32.encode(prefix, words, Bech32MaxSize);
 }
 function nprofileEncode(profile) {
   let data = encodeTLV({
-    0: [secp256k15.utils.hexToBytes(profile.pubkey)],
+    0: [secp256k13.utils.hexToBytes(profile.pubkey)],
     1: (profile.relays || []).map((url) => utf8Encoder.encode(url))
   });
   let words = bech32.toWords(data);
@@ -936,8 +806,9 @@ function nprofileEncode(profile) {
 }
 function neventEncode(event) {
   let data = encodeTLV({
-    0: [secp256k15.utils.hexToBytes(event.id)],
-    1: (event.relays || []).map((url) => utf8Encoder.encode(url))
+    0: [secp256k13.utils.hexToBytes(event.id)],
+    1: (event.relays || []).map((url) => utf8Encoder.encode(url)),
+    2: event.author ? [secp256k13.utils.hexToBytes(event.author)] : []
   });
   let words = bech32.toWords(data);
   return bech32.encode("nevent", words, Bech32MaxSize);
@@ -948,7 +819,7 @@ function naddrEncode(addr) {
   let data = encodeTLV({
     0: [utf8Encoder.encode(addr.identifier)],
     1: (addr.relays || []).map((url) => utf8Encoder.encode(url)),
-    2: [secp256k15.utils.hexToBytes(addr.pubkey)],
+    2: [secp256k13.utils.hexToBytes(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   let words = bech32.toWords(data);
@@ -965,7 +836,229 @@ function encodeTLV(tlv) {
       entries.push(entry);
     });
   });
-  return secp256k15.utils.concatBytes(...entries);
+  return secp256k13.utils.concatBytes(...entries);
+}
+
+// references.ts
+var mentionRegex = /\bnostr:((note|npub|naddr|nevent|nprofile)1\w+)\b|#\[(\d+)\]/g;
+function parseReferences(evt) {
+  let references = [];
+  for (let ref of evt.content.matchAll(mentionRegex)) {
+    if (ref[2]) {
+      try {
+        let { type, data } = decode(ref[1]);
+        switch (type) {
+          case "npub": {
+            references.push({
+              text: ref[0],
+              profile: { pubkey: data, relays: [] }
+            });
+            break;
+          }
+          case "nprofile": {
+            references.push({
+              text: ref[0],
+              profile: data
+            });
+            break;
+          }
+          case "note": {
+            references.push({
+              text: ref[0],
+              event: { id: data, relays: [] }
+            });
+            break;
+          }
+          case "nevent": {
+            references.push({
+              text: ref[0],
+              event: data
+            });
+            break;
+          }
+          case "naddr": {
+            references.push({
+              text: ref[0],
+              address: data
+            });
+            break;
+          }
+        }
+      } catch (err) {
+      }
+    } else if (ref[3]) {
+      let idx = parseInt(ref[3], 10);
+      let tag = evt.tags[idx];
+      if (!tag)
+        continue;
+      switch (tag[0]) {
+        case "p": {
+          references.push({
+            text: ref[0],
+            profile: { pubkey: tag[1], relays: tag[2] ? [tag[2]] : [] }
+          });
+          break;
+        }
+        case "e": {
+          references.push({
+            text: ref[0],
+            event: { id: tag[1], relays: tag[2] ? [tag[2]] : [] }
+          });
+          break;
+        }
+        case "a": {
+          try {
+            let [kind, pubkey, identifier] = ref[1].split(":");
+            references.push({
+              text: ref[0],
+              address: {
+                identifier,
+                pubkey,
+                kind: parseInt(kind, 10),
+                relays: tag[2] ? [tag[2]] : []
+              }
+            });
+          } catch (err) {
+          }
+          break;
+        }
+      }
+    }
+  }
+  return references;
+}
+
+// nip04.ts
+var nip04_exports = {};
+__export(nip04_exports, {
+  decrypt: () => decrypt,
+  encrypt: () => encrypt
+});
+import { randomBytes } from "@noble/hashes/utils";
+import * as secp256k14 from "@noble/secp256k1";
+import { base64 } from "@scure/base";
+async function encrypt(privkey, pubkey, text) {
+  const key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
+  const normalizedKey = getNormalizedX(key);
+  let iv = Uint8Array.from(randomBytes(16));
+  let plaintext = utf8Encoder.encode(text);
+  let cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    normalizedKey,
+    { name: "AES-CBC" },
+    false,
+    ["encrypt"]
+  );
+  let ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-CBC", iv },
+    cryptoKey,
+    plaintext
+  );
+  let ctb64 = base64.encode(new Uint8Array(ciphertext));
+  let ivb64 = base64.encode(new Uint8Array(iv.buffer));
+  return `${ctb64}?iv=${ivb64}`;
+}
+async function decrypt(privkey, pubkey, data) {
+  let [ctb64, ivb64] = data.split("?iv=");
+  let key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
+  let normalizedKey = getNormalizedX(key);
+  let cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    normalizedKey,
+    { name: "AES-CBC" },
+    false,
+    ["decrypt"]
+  );
+  let ciphertext = base64.decode(ctb64);
+  let iv = base64.decode(ivb64);
+  let plaintext = await crypto.subtle.decrypt(
+    { name: "AES-CBC", iv },
+    cryptoKey,
+    ciphertext
+  );
+  let text = utf8Decoder.decode(plaintext);
+  return text;
+}
+function getNormalizedX(key) {
+  return key.slice(1, 33);
+}
+
+// nip05.ts
+var nip05_exports = {};
+__export(nip05_exports, {
+  queryProfile: () => queryProfile,
+  searchDomain: () => searchDomain,
+  useFetchImplementation: () => useFetchImplementation
+});
+var _fetch;
+try {
+  _fetch = fetch;
+} catch {
+}
+function useFetchImplementation(fetchImplementation) {
+  _fetch = fetchImplementation;
+}
+async function searchDomain(domain, query = "") {
+  try {
+    let res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${query}`)).json();
+    return res.names;
+  } catch (_) {
+    return {};
+  }
+}
+async function queryProfile(fullname) {
+  let [name, domain] = fullname.split("@");
+  if (!domain) {
+    domain = name;
+    name = "_";
+  }
+  if (!name.match(/^[A-Za-z0-9-_]+$/))
+    return null;
+  if (!domain.includes("."))
+    return null;
+  let res;
+  try {
+    res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)).json();
+  } catch (err) {
+    return null;
+  }
+  if (!res?.names?.[name])
+    return null;
+  let pubkey = res.names[name];
+  let relays = res.relays?.[pubkey] || [];
+  return {
+    pubkey,
+    relays
+  };
+}
+
+// nip06.ts
+var nip06_exports = {};
+__export(nip06_exports, {
+  generateSeedWords: () => generateSeedWords,
+  privateKeyFromSeedWords: () => privateKeyFromSeedWords,
+  validateWords: () => validateWords
+});
+import * as secp256k15 from "@noble/secp256k1";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import {
+  generateMnemonic,
+  mnemonicToSeedSync,
+  validateMnemonic
+} from "@scure/bip39";
+import { HDKey } from "@scure/bip32";
+function privateKeyFromSeedWords(mnemonic, passphrase) {
+  let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase));
+  let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey;
+  if (!privateKey)
+    throw new Error("could not derive private key");
+  return secp256k15.utils.bytesToHex(privateKey);
+}
+function generateSeedWords() {
+  return generateMnemonic(wordlist);
+}
+function validateWords(words) {
+  return validateMnemonic(words, wordlist);
 }
 
 // nip26.ts
@@ -1191,6 +1284,7 @@ export {
   nip26_exports as nip26,
   nip39_exports as nip39,
   nip57_exports as nip57,
+  parseReferences,
   relayInit,
   serializeEvent,
   signEvent,