nostr-tools 1.8.4 → 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 = {};
@@ -166,7 +168,7 @@ 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) {
@@ -196,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)
   );
 }
 
@@ -721,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) {
@@ -739,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)) : []
         }
       };
@@ -755,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
         }
       };
     }
@@ -777,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}`);
   }
@@ -816,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);
@@ -830,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);
@@ -843,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]) => {
@@ -860,7 +879,7 @@ function encodeTLV(tlv) {
       entries.push(entry);
     });
   });
-  return secp256k13.utils.concatBytes(...entries);
+  return concatBytes(...entries);
 }
 
 // references.ts
@@ -959,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);
@@ -984,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",
@@ -1063,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,
@@ -1076,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);
@@ -1148,9 +1167,9 @@ var nip13_exports = {};
 __export(nip13_exports, {
   getPow: () => getPow
 });
-import * as secp256k16 from "@noble/secp256k1";
+import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
 function getPow(id) {
-  return getLeadingZeroBits(secp256k16.utils.hexToBytes(id));
+  return getLeadingZeroBits(hexToBytes2(id));
 }
 function getLeadingZeroBits(hash) {
   let total, i, bits;
@@ -1180,7 +1199,8 @@ __export(nip26_exports, {
   createDelegation: () => createDelegation,
   getDelegator: () => getDelegator
 });
-import * as secp256k17 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 = [];
@@ -1196,8 +1216,8 @@ function createDelegation(privateKey, parameters) {
   let sighash = sha2562(
     utf8Encoder.encode(`nostr:delegation:${parameters.pubkey}:${cond}`)
   );
-  let sig = secp256k17.utils.bytesToHex(
-    secp256k17.schnorr.signSync(sighash, privateKey)
+  let sig = bytesToHex5(
+    schnorr3.sign(sighash, privateKey)
   );
   return {
     from: getPublicKey(privateKey),
@@ -1228,7 +1248,7 @@ function getDelegator(event) {
   let sighash = sha2562(
     utf8Encoder.encode(`nostr:delegation:${event.pubkey}:${cond}`)
   );
-  if (!secp256k17.schnorr.verifySync(sig, sighash, pubkey))
+  if (!schnorr3.verify(sig, sighash, pubkey))
     return null;
   return pubkey;
 }
@@ -1372,13 +1392,6 @@ function makeZapReceipt({
   }
   return zap;
 }
-
-// index.ts
-import * as secp256k18 from "@noble/secp256k1";
-import { hmac } from "@noble/hashes/hmac";
-import { sha256 as sha2563 } from "@noble/hashes/sha256";
-secp256k18.utils.hmacSha256Sync = (key, ...msgs) => hmac(sha2563, key, secp256k18.utils.concatBytes(...msgs));
-secp256k18.utils.sha256Sync = (...msgs) => sha2563(secp256k18.utils.concatBytes(...msgs));
 export {
   Kind,
   SimplePool,