nostr-tools 1.8.3 → 1.9.0

package/lib/esm/nostr.mjs

@@ -5,17 +5,19 @@ var __export = (target, all) => {
 };
 
 // keys.ts
-import * as secp256k1 from "@noble/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1";
+import { bytesToHex } from "@noble/hashes/utils";
 function generatePrivateKey() {
-  return secp256k1.utils.bytesToHex(secp256k1.utils.randomPrivateKey());
+  return bytesToHex(schnorr.utils.randomPrivateKey());
 }
 function getPublicKey(privateKey) {
-  return secp256k1.utils.bytesToHex(secp256k1.schnorr.getPublicKey(privateKey));
+  return bytesToHex(schnorr.getPublicKey(privateKey));
 }
 
 // event.ts
-import * as secp256k12 from "@noble/secp256k1";
+import { schnorr as schnorr2 } from "@noble/curves/secp256k1";
 import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
 
 // utils.ts
 var utils_exports = {};
@@ -121,6 +123,7 @@ var Kind = /* @__PURE__ */ ((Kind2) => {
   Kind2[Kind2["EncryptedDirectMessage"] = 4] = "EncryptedDirectMessage";
   Kind2[Kind2["EventDeletion"] = 5] = "EventDeletion";
   Kind2[Kind2["Reaction"] = 7] = "Reaction";
+  Kind2[Kind2["BadgeAward"] = 8] = "BadgeAward";
   Kind2[Kind2["ChannelCreation"] = 40] = "ChannelCreation";
   Kind2[Kind2["ChannelMetadata"] = 41] = "ChannelMetadata";
   Kind2[Kind2["ChannelMessage"] = 42] = "ChannelMessage";
@@ -131,6 +134,8 @@ var Kind = /* @__PURE__ */ ((Kind2) => {
   Kind2[Kind2["Zap"] = 9735] = "Zap";
   Kind2[Kind2["RelayList"] = 10002] = "RelayList";
   Kind2[Kind2["ClientAuth"] = 22242] = "ClientAuth";
+  Kind2[Kind2["BadgeDefinition"] = 30008] = "BadgeDefinition";
+  Kind2[Kind2["ProfileBadge"] = 30009] = "ProfileBadge";
   Kind2[Kind2["Article"] = 30023] = "Article";
   return Kind2;
 })(Kind || {});
@@ -163,10 +168,11 @@ function serializeEvent(evt) {
 }
 function getEventHash(event) {
   let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)));
-  return secp256k12.utils.bytesToHex(eventHash);
+  return bytesToHex2(eventHash);
 }
+var isRecord = (obj) => obj instanceof Object;
 function validateEvent(event) {
-  if (typeof event !== "object")
+  if (!isRecord(event))
     return false;
   if (typeof event.kind !== "number")
     return false;
@@ -192,15 +198,15 @@ function validateEvent(event) {
   return true;
 }
 function verifySignature(event) {
-  return secp256k12.schnorr.verifySync(
+  return schnorr2.verify(
     event.sig,
     getEventHash(event),
     event.pubkey
   );
 }
 function signEvent(event, key) {
-  return secp256k12.utils.bytesToHex(
-    secp256k12.schnorr.signSync(getEventHash(event), key)
+  return bytesToHex2(
+    schnorr2.sign(getEventHash(event), key)
   );
 }
 
@@ -717,9 +723,10 @@ __export(nip19_exports, {
   noteEncode: () => noteEncode,
   nprofileEncode: () => nprofileEncode,
   npubEncode: () => npubEncode,
+  nrelayEncode: () => nrelayEncode,
   nsecEncode: () => nsecEncode
 });
-import * as secp256k13 from "@noble/secp256k1";
+import { bytesToHex as bytesToHex3, concatBytes, hexToBytes } from "@noble/hashes/utils";
 import { bech32 } from "@scure/base";
 var Bech32MaxSize = 5e3;
 function decode(nip19) {
@@ -735,7 +742,7 @@ function decode(nip19) {
       return {
         type: "nprofile",
         data: {
-          pubkey: secp256k13.utils.bytesToHex(tlv[0][0]),
+          pubkey: bytesToHex3(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
@@ -751,9 +758,9 @@ function decode(nip19) {
       return {
         type: "nevent",
         data: {
-          id: secp256k13.utils.bytesToHex(tlv[0][0]),
+          id: bytesToHex3(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
+          author: tlv[2]?.[0] ? bytesToHex3(tlv[2][0]) : void 0
         }
       };
     }
@@ -773,16 +780,25 @@ function decode(nip19) {
         type: "naddr",
         data: {
           identifier: utf8Decoder.decode(tlv[0][0]),
-          pubkey: secp256k13.utils.bytesToHex(tlv[2][0]),
-          kind: parseInt(secp256k13.utils.bytesToHex(tlv[3][0]), 16),
+          pubkey: bytesToHex3(tlv[2][0]),
+          kind: parseInt(bytesToHex3(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
     }
+    case "nrelay": {
+      let tlv = parseTLV(data);
+      if (!tlv[0]?.[0])
+        throw new Error("missing TLV 0 for nrelay");
+      return {
+        type: "nrelay",
+        data: utf8Decoder.decode(tlv[0][0])
+      };
+    }
     case "nsec":
     case "npub":
     case "note":
-      return { type: prefix, data: secp256k13.utils.bytesToHex(data) };
+      return { type: prefix, data: bytesToHex3(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -812,13 +828,13 @@ function noteEncode(hex) {
   return encodeBytes("note", hex);
 }
 function encodeBytes(prefix, hex) {
-  let data = secp256k13.utils.hexToBytes(hex);
+  let data = hexToBytes(hex);
   let words = bech32.toWords(data);
   return bech32.encode(prefix, words, Bech32MaxSize);
 }
 function nprofileEncode(profile) {
   let data = encodeTLV({
-    0: [secp256k13.utils.hexToBytes(profile.pubkey)],
+    0: [hexToBytes(profile.pubkey)],
     1: (profile.relays || []).map((url) => utf8Encoder.encode(url))
   });
   let words = bech32.toWords(data);
@@ -826,9 +842,9 @@ function nprofileEncode(profile) {
 }
 function neventEncode(event) {
   let data = encodeTLV({
-    0: [secp256k13.utils.hexToBytes(event.id)],
+    0: [hexToBytes(event.id)],
     1: (event.relays || []).map((url) => utf8Encoder.encode(url)),
-    2: event.author ? [secp256k13.utils.hexToBytes(event.author)] : []
+    2: event.author ? [hexToBytes(event.author)] : []
   });
   let words = bech32.toWords(data);
   return bech32.encode("nevent", words, Bech32MaxSize);
@@ -839,12 +855,19 @@ function naddrEncode(addr) {
   let data = encodeTLV({
     0: [utf8Encoder.encode(addr.identifier)],
     1: (addr.relays || []).map((url) => utf8Encoder.encode(url)),
-    2: [secp256k13.utils.hexToBytes(addr.pubkey)],
+    2: [hexToBytes(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   let words = bech32.toWords(data);
   return bech32.encode("naddr", words, Bech32MaxSize);
 }
+function nrelayEncode(url) {
+  let data = encodeTLV({
+    0: [utf8Encoder.encode(url)]
+  });
+  let words = bech32.toWords(data);
+  return bech32.encode("nrelay", words, Bech32MaxSize);
+}
 function encodeTLV(tlv) {
   let entries = [];
   Object.entries(tlv).forEach(([t, vs]) => {
@@ -856,7 +879,7 @@ function encodeTLV(tlv) {
       entries.push(entry);
     });
   });
-  return secp256k13.utils.concatBytes(...entries);
+  return concatBytes(...entries);
 }
 
 // references.ts
@@ -955,10 +978,10 @@ __export(nip04_exports, {
   encrypt: () => encrypt
 });
 import { randomBytes } from "@noble/hashes/utils";
-import * as secp256k14 from "@noble/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1";
 import { base64 } from "@scure/base";
 async function encrypt(privkey, pubkey, text) {
-  const key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
+  const key = secp256k1.getSharedSecret(privkey, "02" + pubkey);
   const normalizedKey = getNormalizedX(key);
   let iv = Uint8Array.from(randomBytes(16));
   let plaintext = utf8Encoder.encode(text);
@@ -980,7 +1003,7 @@ async function encrypt(privkey, pubkey, text) {
 }
 async function decrypt(privkey, pubkey, data) {
   let [ctb64, ivb64] = data.split("?iv=");
-  let key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
+  let key = secp256k1.getSharedSecret(privkey, "02" + pubkey);
   let normalizedKey = getNormalizedX(key);
   let cryptoKey = await crypto.subtle.importKey(
     "raw",
@@ -1032,7 +1055,7 @@ async function queryProfile(fullname) {
     domain = name;
     name = "_";
   }
-  if (!name.match(/^[A-Za-z0-9-_]+$/))
+  if (!name.match(/^[A-Za-z0-9-_.]+$/))
     return null;
   if (!domain.includes("."))
     return null;
@@ -1059,7 +1082,7 @@ __export(nip06_exports, {
   privateKeyFromSeedWords: () => privateKeyFromSeedWords,
   validateWords: () => validateWords
 });
-import * as secp256k15 from "@noble/secp256k1";
+import { bytesToHex as bytesToHex4 } from "@noble/hashes/utils";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
 import {
   generateMnemonic,
@@ -1072,7 +1095,7 @@ function privateKeyFromSeedWords(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);
+  return bytesToHex4(privateKey);
 }
 function generateSeedWords() {
   return generateMnemonic(wordlist);
@@ -1139,13 +1162,45 @@ function parse(event) {
   return result;
 }
 
+// nip13.ts
+var nip13_exports = {};
+__export(nip13_exports, {
+  getPow: () => getPow
+});
+import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
+function getPow(id) {
+  return getLeadingZeroBits(hexToBytes2(id));
+}
+function getLeadingZeroBits(hash) {
+  let total, i, bits;
+  for (i = 0, total = 0; i < hash.length; i++) {
+    bits = msb(hash[i]);
+    total += bits;
+    if (bits !== 8) {
+      break;
+    }
+  }
+  return total;
+}
+function msb(b) {
+  let n = 0;
+  if (b === 0) {
+    return 8;
+  }
+  while (b >>= 1) {
+    n++;
+  }
+  return 7 - n;
+}
+
 // nip26.ts
 var nip26_exports = {};
 __export(nip26_exports, {
   createDelegation: () => createDelegation,
   getDelegator: () => getDelegator
 });
-import * as secp256k16 from "@noble/secp256k1";
+import { schnorr as schnorr3 } from "@noble/curves/secp256k1";
+import { bytesToHex as bytesToHex5 } from "@noble/hashes/utils";
 import { sha256 as sha2562 } from "@noble/hashes/sha256";
 function createDelegation(privateKey, parameters) {
   let conditions = [];
@@ -1161,8 +1216,8 @@ function createDelegation(privateKey, parameters) {
   let sighash = sha2562(
     utf8Encoder.encode(`nostr:delegation:${parameters.pubkey}:${cond}`)
   );
-  let sig = secp256k16.utils.bytesToHex(
-    secp256k16.schnorr.signSync(sighash, privateKey)
+  let sig = bytesToHex5(
+    schnorr3.sign(sighash, privateKey)
   );
   return {
     from: getPublicKey(privateKey),
@@ -1193,7 +1248,7 @@ function getDelegator(event) {
   let sighash = sha2562(
     utf8Encoder.encode(`nostr:delegation:${event.pubkey}:${cond}`)
   );
-  if (!secp256k16.schnorr.verifySync(sig, sighash, pubkey))
+  if (!schnorr3.verify(sig, sighash, pubkey))
     return null;
   return pubkey;
 }
@@ -1337,13 +1392,6 @@ function makeZapReceipt({
   }
   return zap;
 }
-
-// index.ts
-import * as secp256k17 from "@noble/secp256k1";
-import { hmac } from "@noble/hashes/hmac";
-import { sha256 as sha2563 } from "@noble/hashes/sha256";
-secp256k17.utils.hmacSha256Sync = (key, ...msgs) => hmac(sha2563, key, secp256k17.utils.concatBytes(...msgs));
-secp256k17.utils.sha256Sync = (...msgs) => sha2563(secp256k17.utils.concatBytes(...msgs));
 export {
   Kind,
   SimplePool,
@@ -1359,6 +1407,7 @@ export {
   nip05_exports as nip05,
   nip06_exports as nip06,
   nip10_exports as nip10,
+  nip13_exports as nip13,
   nip19_exports as nip19,
   nip26_exports as nip26,
   nip39_exports as nip39,