nostr-tools 2.23.12 → 2.24.0

package/lib/cjs/index.js

@@ -67,48 +67,7 @@ module.exports = __toCommonJS(nostr_tools_exports);
 
 // pure.ts
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
-var import_utils2 = require("@noble/hashes/utils.js");
-
-// core.ts
-var verifiedSymbol = Symbol("verified");
-var isRecord = (obj) => obj instanceof Object;
-function validateEvent(event) {
-  if (!isRecord(event))
-    return false;
-  if (typeof event.kind !== "number")
-    return false;
-  if (typeof event.content !== "string")
-    return false;
-  if (typeof event.created_at !== "number")
-    return false;
-  if (typeof event.pubkey !== "string")
-    return false;
-  if (!event.pubkey.match(/^[a-f0-9]{64}$/))
-    return false;
-  if (!Array.isArray(event.tags))
-    return false;
-  for (let i2 = 0; i2 < event.tags.length; i2++) {
-    let tag = event.tags[i2];
-    if (!Array.isArray(tag))
-      return false;
-    for (let j = 0; j < tag.length; j++) {
-      if (typeof tag[j] !== "string")
-        return false;
-    }
-  }
-  return true;
-}
-function sortEvents(events) {
-  return events.sort((a, b) => {
-    if (a.created_at !== b.created_at) {
-      return b.created_at - a.created_at;
-    }
-    return a.id.localeCompare(b.id);
-  });
-}
-
-// pure.ts
-var import_sha2 = require("@noble/hashes/sha2.js");
+var import_utils3 = require("@noble/hashes/utils.js");
 
 // utils.ts
 var utils_exports = {};
@@ -118,6 +77,7 @@ __export(utils_exports, {
   hexToBytes: () => import_utils.hexToBytes,
   insertEventIntoAscendingList: () => insertEventIntoAscendingList,
   insertEventIntoDescendingList: () => insertEventIntoDescendingList,
+  isHex32: () => isHex32,
   mergeReverseSortedLists: () => mergeReverseSortedLists,
   normalizeURL: () => normalizeURL,
   utf8Decoder: () => utf8Decoder,
@@ -240,20 +200,68 @@ function mergeReverseSortedLists(list1, list2) {
   }
   return result;
 }
+function isHex32(input) {
+  for (let i2 = 0; i2 < 64; i2++) {
+    let cc = input.charCodeAt(i2);
+    if (isNaN(cc) || cc < 48 || cc > 102 || cc > 57 && cc < 97) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// core.ts
+var verifiedSymbol = Symbol("verified");
+var isRecord = (obj) => obj instanceof Object;
+function validateEvent(event) {
+  if (!isRecord(event))
+    return false;
+  if (typeof event.kind !== "number")
+    return false;
+  if (typeof event.content !== "string")
+    return false;
+  if (typeof event.created_at !== "number")
+    return false;
+  if (typeof event.pubkey !== "string")
+    return false;
+  if (!isHex32(event.pubkey))
+    return false;
+  if (!Array.isArray(event.tags))
+    return false;
+  for (let i2 = 0; i2 < event.tags.length; i2++) {
+    let tag = event.tags[i2];
+    if (!Array.isArray(tag))
+      return false;
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string")
+        return false;
+    }
+  }
+  return true;
+}
+function sortEvents(events) {
+  return events.sort((a, b) => {
+    if (a.created_at !== b.created_at) {
+      return b.created_at - a.created_at;
+    }
+    return a.id.localeCompare(b.id);
+  });
+}
 
 // pure.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
 var JS = class {
   generateSecretKey() {
     return import_secp256k1.schnorr.utils.randomSecretKey();
   }
   getPublicKey(secretKey) {
-    return (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
+    return (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event = t;
-    event.pubkey = (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
+    event.pubkey = (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
     event.id = getEventHash(event);
-    event.sig = (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.sign((0, import_utils2.hexToBytes)(getEventHash(event)), secretKey));
+    event.sig = (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.sign((0, import_utils3.hexToBytes)(getEventHash(event)), secretKey));
     event[verifiedSymbol] = true;
     return event;
   }
@@ -266,7 +274,7 @@ var JS = class {
         event[verifiedSymbol] = false;
         return false;
       }
-      const valid = import_secp256k1.schnorr.verify((0, import_utils2.hexToBytes)(event.sig), (0, import_utils2.hexToBytes)(hash), (0, import_utils2.hexToBytes)(event.pubkey));
+      const valid = import_secp256k1.schnorr.verify((0, import_utils3.hexToBytes)(event.sig), (0, import_utils3.hexToBytes)(hash), (0, import_utils3.hexToBytes)(event.pubkey));
       event[verifiedSymbol] = valid;
       return valid;
     } catch (err) {
@@ -282,7 +290,7 @@ function serializeEvent(evt) {
 }
 function getEventHash(event) {
   let eventHash = (0, import_sha2.sha256)(utf8Encoder.encode(serializeEvent(event)));
-  return (0, import_utils2.bytesToHex)(eventHash);
+  return (0, import_utils3.bytesToHex)(eventHash);
 }
 var i = new JS();
 var generateSecretKey = i.generateSecretKey;
@@ -344,6 +352,7 @@ __export(kinds_exports, {
   Emojisets: () => Emojisets,
   EncryptedDirectMessage: () => EncryptedDirectMessage,
   EventDeletion: () => EventDeletion,
+  FavoriteFollowSets: () => FavoriteFollowSets,
   FavoritePodcasts: () => FavoritePodcasts,
   FavoriteRelays: () => FavoriteRelays,
   FedimintAnnouncement: () => FedimintAnnouncement,
@@ -616,6 +625,7 @@ var PrivateEventRelayList = 10013;
 var InterestsList = 10015;
 var NutZapInfo = 10019;
 var MediaFollows = 10020;
+var FavoriteFollowSets = 10021;
 var UserEmojiList = 10030;
 var DecoupledKeyAnnouncement = 10044;
 var DirectMessageRelaysList = 10050;
@@ -1215,7 +1225,7 @@ var AbstractRelay = class {
         case "EVENT": {
           const so = this.openSubs.get(data[1]);
           const event = data[2];
-          if (this.verifyEvent(event) && matchFilters(so.filters, event)) {
+          if (matchFilters(so.filters, event) && this.verifyEvent(event, this.url)) {
             so.onevent(event);
           } else {
             so.oninvalidevent?.(event);
@@ -1388,15 +1398,9 @@ var Relay = class extends AbstractRelay {
   }
 };
 
-// helpers.ts
-var alwaysTrue = (t) => {
-  t[verifiedSymbol] = true;
-  return true;
-};
-
 // nip45.ts
 var import_sha22 = require("@noble/hashes/sha2.js");
-var import_utils5 = require("@noble/hashes/utils.js");
+var import_utils6 = require("@noble/hashes/utils.js");
 var M = 256;
 var HLL_HEX_LENGTH = M * 2;
 var utf8Encoder2 = new TextEncoder();
@@ -1420,7 +1424,7 @@ function newHll() {
   return new Uint8Array(M);
 }
 function hllDecode(hex) {
-  if (hex.length !== HLL_HEX_LENGTH || !/^[0-9a-fA-F]+$/.test(hex))
+  if (hex.length !== HLL_HEX_LENGTH || !/^[0-9a-f]+$/.test(hex))
     return void 0;
   const registers = new Uint8Array(M);
   for (let i2 = 0; i2 < M; i2++) {
@@ -1461,7 +1465,6 @@ var AbstractSimplePool = class {
   enableReconnect;
   idleTimeout = 2e4;
   automaticallyAuth;
-  trustedRelayURLs = /* @__PURE__ */ new Set();
   onRelayConnectionFailure;
   onRelayConnectionSuccess;
   allowConnectingToRelay;
@@ -1485,7 +1488,7 @@ var AbstractSimplePool = class {
     let relay = this.relays.get(url);
     if (!relay) {
       relay = new AbstractRelay(url, {
-        verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
+        verifyEvent: this.verifyEvent,
         websocketImplementation: this._WebSocket,
         enablePing: this.enablePing,
         enableReconnect: this.enableReconnect,
@@ -1569,11 +1572,11 @@ var AbstractSimplePool = class {
       }
     };
     const closesReceived = [];
-    let handleClose = (i2, reason) => {
+    let handleClose = (i2, url, reason) => {
       if (closesReceived[i2])
         return;
       handleEose(i2);
-      closesReceived[i2] = reason;
+      closesReceived[i2] = { url, reason };
       if (closesReceived.filter((a) => a).length === groupedRequests.length) {
         params.onclose?.(closesReceived);
         handleClose = () => {
@@ -1591,7 +1594,7 @@ var AbstractSimplePool = class {
     const allOpened = Promise.all(
       groupedRequests.map(async ({ url, filters }, i2) => {
         if (this.allowConnectingToRelay?.(url, ["read", filters]) === false) {
-          handleClose(i2, "connection skipped by allowConnectingToRelay");
+          handleClose(i2, url, "connection skipped by allowConnectingToRelay");
           return;
         }
         let relay;
@@ -1602,7 +1605,7 @@ var AbstractSimplePool = class {
           });
         } catch (err) {
           this.onRelayConnectionFailure?.(url);
-          handleClose(i2, err?.message || String(err));
+          handleClose(i2, url, err?.message || String(err));
           return;
         }
         this.onRelayConnectionSuccess?.(url);
@@ -1616,17 +1619,17 @@ var AbstractSimplePool = class {
                   ...params,
                   oneose: () => handleEose(i2),
                   onclose: (reason2) => {
-                    handleClose(i2, reason2);
+                    handleClose(i2, url, reason2);
                   },
                   alreadyHaveEvent: localAlreadyHaveEventHandler,
                   eoseTimeout: params.maxWait,
                   abort: params.abort
                 });
               }).catch((err) => {
-                handleClose(i2, `auth was required and attempted, but failed with: ${err}`);
+                handleClose(i2, url, `auth was required and attempted, but failed with: ${err}`);
               });
             } else {
-              handleClose(i2, reason);
+              handleClose(i2, url, reason);
             }
           },
           alreadyHaveEvent: localAlreadyHaveEventHandler,
@@ -1654,7 +1657,7 @@ var AbstractSimplePool = class {
         if (subcloser)
           subcloser.close(reason);
         else
-          params.onclose?.(relays.map((_) => reason));
+          params.onclose?.(relays.map((url) => ({ url, reason })));
       }
     });
     return subcloser;
@@ -1811,7 +1814,7 @@ __export(nip19_exports, {
   npubEncode: () => npubEncode,
   nsecEncode: () => nsecEncode
 });
-var import_utils7 = require("@noble/hashes/utils.js");
+var import_utils8 = require("@noble/hashes/utils.js");
 var import_base = require("@scure/base");
 var NostrTypeGuard = {
   isNProfile: (value) => /^nprofile1[a-z\d]+$/.test(value || ""),
@@ -1854,7 +1857,7 @@ function decode(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: (0, import_utils7.bytesToHex)(tlv[0][0]),
+          pubkey: (0, import_utils8.bytesToHex)(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
@@ -1872,10 +1875,10 @@ function decode(code) {
       return {
         type: "nevent",
         data: {
-          id: (0, import_utils7.bytesToHex)(tlv[0][0]),
+          id: (0, import_utils8.bytesToHex)(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : [],
-          author: tlv[2]?.[0] ? (0, import_utils7.bytesToHex)(tlv[2][0]) : void 0,
-          kind: tlv[3]?.[0] ? parseInt((0, import_utils7.bytesToHex)(tlv[3][0]), 16) : void 0
+          author: tlv[2]?.[0] ? (0, import_utils8.bytesToHex)(tlv[2][0]) : void 0,
+          kind: tlv[3]?.[0] ? parseInt((0, import_utils8.bytesToHex)(tlv[3][0]), 16) : void 0
         }
       };
     }
@@ -1895,8 +1898,8 @@ function decode(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder.decode(tlv[0][0]),
-          pubkey: (0, import_utils7.bytesToHex)(tlv[2][0]),
-          kind: parseInt((0, import_utils7.bytesToHex)(tlv[3][0]), 16),
+          pubkey: (0, import_utils8.bytesToHex)(tlv[2][0]),
+          kind: parseInt((0, import_utils8.bytesToHex)(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
         }
       };
@@ -1905,7 +1908,7 @@ function decode(code) {
       return { type: prefix, data };
     case "npub":
     case "note":
-      return { type: prefix, data: (0, import_utils7.bytesToHex)(data) };
+      return { type: prefix, data: (0, import_utils8.bytesToHex)(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -1931,10 +1934,10 @@ function nsecEncode(key) {
   return encodeBytes("nsec", key);
 }
 function npubEncode(hex) {
-  return encodeBytes("npub", (0, import_utils7.hexToBytes)(hex));
+  return encodeBytes("npub", (0, import_utils8.hexToBytes)(hex));
 }
 function noteEncode(hex) {
-  return encodeBytes("note", (0, import_utils7.hexToBytes)(hex));
+  return encodeBytes("note", (0, import_utils8.hexToBytes)(hex));
 }
 function encodeBech32(prefix, data) {
   let words = import_base.bech32.toWords(data);
@@ -1945,7 +1948,7 @@ function encodeBytes(prefix, bytes) {
 }
 function nprofileEncode(profile) {
   let data = encodeTLV({
-    0: [(0, import_utils7.hexToBytes)(profile.pubkey)],
+    0: [(0, import_utils8.hexToBytes)(profile.pubkey)],
     1: (profile.relays || []).map((url) => utf8Encoder.encode(url))
   });
   return encodeBech32("nprofile", data);
@@ -1956,9 +1959,9 @@ function neventEncode(event) {
     kindArray = integerToUint8Array(event.kind);
   }
   let data = encodeTLV({
-    0: [(0, import_utils7.hexToBytes)(event.id)],
+    0: [(0, import_utils8.hexToBytes)(event.id)],
     1: (event.relays || []).map((url) => utf8Encoder.encode(url)),
-    2: event.author ? [(0, import_utils7.hexToBytes)(event.author)] : [],
+    2: event.author ? [(0, import_utils8.hexToBytes)(event.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech32("nevent", data);
@@ -1969,7 +1972,7 @@ function naddrEncode(addr) {
   let data = encodeTLV({
     0: [utf8Encoder.encode(addr.identifier)],
     1: (addr.relays || []).map((url) => utf8Encoder.encode(url)),
-    2: [(0, import_utils7.hexToBytes)(addr.pubkey)],
+    2: [(0, import_utils8.hexToBytes)(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech32("naddr", data);
@@ -1985,7 +1988,7 @@ function encodeTLV(tlv) {
       entries.push(entry);
     });
   });
-  return (0, import_utils7.concatBytes)(...entries);
+  return (0, import_utils8.concatBytes)(...entries);
 }
 
 // references.ts
@@ -2083,15 +2086,15 @@ __export(nip04_exports, {
   decrypt: () => decrypt,
   encrypt: () => encrypt
 });
-var import_utils9 = require("@noble/hashes/utils.js");
+var import_utils10 = require("@noble/hashes/utils.js");
 var import_secp256k12 = require("@noble/curves/secp256k1.js");
 var import_aes = require("@noble/ciphers/aes.js");
 var import_base2 = require("@scure/base");
 function encrypt(secretKey, pubkey, text) {
-  const privkey = secretKey instanceof Uint8Array ? secretKey : (0, import_utils9.hexToBytes)(secretKey);
-  const key = import_secp256k12.secp256k1.getSharedSecret(privkey, (0, import_utils9.hexToBytes)("02" + pubkey));
+  const privkey = secretKey instanceof Uint8Array ? secretKey : (0, import_utils10.hexToBytes)(secretKey);
+  const key = import_secp256k12.secp256k1.getSharedSecret(privkey, (0, import_utils10.hexToBytes)("02" + pubkey));
   const normalizedKey = getNormalizedX(key);
-  let iv = Uint8Array.from((0, import_utils9.randomBytes)(16));
+  let iv = Uint8Array.from((0, import_utils10.randomBytes)(16));
   let plaintext = utf8Encoder.encode(text);
   let ciphertext = (0, import_aes.cbc)(normalizedKey, iv).encrypt(plaintext);
   let ctb64 = import_base2.base64.encode(new Uint8Array(ciphertext));
@@ -2099,9 +2102,9 @@ function encrypt(secretKey, pubkey, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt(secretKey, pubkey, data) {
-  const privkey = secretKey instanceof Uint8Array ? secretKey : (0, import_utils9.hexToBytes)(secretKey);
+  const privkey = secretKey instanceof Uint8Array ? secretKey : (0, import_utils10.hexToBytes)(secretKey);
   let [ctb64, ivb64] = data.split("?iv=");
-  let key = import_secp256k12.secp256k1.getSharedSecret(privkey, (0, import_utils9.hexToBytes)("02" + pubkey));
+  let key = import_secp256k12.secp256k1.getSharedSecret(privkey, (0, import_utils10.hexToBytes)("02" + pubkey));
   let normalizedKey = getNormalizedX(key);
   let iv = import_base2.base64.decode(ivb64);
   let ciphertext = import_base2.base64.decode(ctb64);
@@ -2174,7 +2177,6 @@ var nip10_exports = {};
 __export(nip10_exports, {
   parse: () => parse
 });
-var HEX64 = /^[0-9a-fA-F]{64}$/;
 function parse(event) {
   const result = {
     reply: void 0,
@@ -2187,12 +2189,12 @@ function parse(event) {
   let maybeRoot;
   for (let i2 = event.tags.length - 1; i2 >= 0; i2--) {
     const tag = event.tags[i2];
-    if (tag[0] === "e" && tag[1] && HEX64.test(tag[1])) {
+    if (tag[0] === "e" && tag[1] && isHex32(tag[1])) {
       const [_, eTagEventId, eTagRelayUrl, eTagMarker, eTagAuthor] = tag;
       const eventPointer = {
         id: eTagEventId,
         relays: eTagRelayUrl ? [eTagRelayUrl] : [],
-        author: eTagAuthor && HEX64.test(eTagAuthor) ? eTagAuthor : void 0
+        author: eTagAuthor && isHex32(eTagAuthor) ? eTagAuthor : void 0
       };
       if (eTagMarker === "root") {
         result.root = eventPointer;
@@ -2214,14 +2216,14 @@ function parse(event) {
       result.mentions.push(eventPointer);
       continue;
     }
-    if (tag[0] === "q" && tag[1] && HEX64.test(tag[1])) {
+    if (tag[0] === "q" && tag[1] && isHex32(tag[1])) {
       const [_, eTagEventId, eTagRelayUrl] = tag;
       result.quotes.push({
         id: eTagEventId,
         relays: eTagRelayUrl ? [eTagRelayUrl] : []
       });
     }
-    if (tag[0] === "p" && tag[1] && HEX64.test(tag[1])) {
+    if (tag[0] === "p" && tag[1] && isHex32(tag[1])) {
       result.profiles.push({
         pubkey: tag[1],
         relays: tag[2] ? [tag[2]] : []
@@ -2301,7 +2303,7 @@ __export(nip13_exports, {
   getPow: () => getPow,
   minePow: () => minePow
 });
-var import_utils11 = require("@noble/hashes/utils.js");
+var import_utils13 = require("@noble/hashes/utils.js");
 var import_sha23 = require("@noble/hashes/sha2.js");
 function getPow(hex) {
   let count = 0;
@@ -2345,7 +2347,7 @@ function minePow(unsigned, difficulty) {
       utf8Encoder.encode(JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]))
     );
     if (getPowFromBytes(hash) >= difficulty) {
-      event.id = (0, import_utils11.bytesToHex)(hash);
+      event.id = (0, import_utils13.bytesToHex)(hash);
       break;
     }
   }
@@ -2382,18 +2384,18 @@ __export(nip44_exports, {
   v2: () => v2
 });
 var import_chacha = require("@noble/ciphers/chacha.js");
-var import_utils13 = require("@noble/ciphers/utils.js");
+var import_utils15 = require("@noble/ciphers/utils.js");
 var import_secp256k13 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_hmac = require("@noble/hashes/hmac.js");
 var import_sha24 = require("@noble/hashes/sha2.js");
-var import_utils14 = require("@noble/hashes/utils.js");
+var import_utils16 = require("@noble/hashes/utils.js");
 var import_base3 = require("@scure/base");
 var minPlaintextSize = 1;
 var maxPlaintextSize = 4294967295;
 var extendedPrefixThreshold = 65536;
 function getConversationKey(privkeyA, pubkeyB) {
-  const sharedX = import_secp256k13.secp256k1.getSharedSecret(privkeyA, (0, import_utils14.hexToBytes)("02" + pubkeyB)).subarray(1, 33);
+  const sharedX = import_secp256k13.secp256k1.getSharedSecret(privkeyA, (0, import_utils16.hexToBytes)("02" + pubkeyB)).subarray(1, 33);
   return (0, import_hkdf.extract)(import_sha24.sha256, sharedX, utf8Encoder.encode("nip44-v2"));
 }
 function getMessageKeys(conversationKey, nonce) {
@@ -2432,9 +2434,9 @@ function pad(plaintext) {
   const unpaddedLen = unpadded.length;
   if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize)
     throw new Error("invalid plaintext size: must be between 1 and 4294967295 bytes");
-  const prefix = unpaddedLen >= extendedPrefixThreshold ? (0, import_utils14.concatBytes)(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
+  const prefix = unpaddedLen >= extendedPrefixThreshold ? (0, import_utils16.concatBytes)(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
   const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);
-  return (0, import_utils14.concatBytes)(prefix, unpadded, suffix);
+  return (0, import_utils16.concatBytes)(prefix, unpadded, suffix);
 }
 function unpad(padded) {
   const dv = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
@@ -2458,7 +2460,7 @@ function unpad(padded) {
 function hmacAad(key, message, aad) {
   if (aad.length !== 32)
     throw new Error("AAD associated data must be 32 bytes");
-  const combined = (0, import_utils14.concatBytes)(aad, message);
+  const combined = (0, import_utils16.concatBytes)(aad, message);
   return (0, import_hmac.hmac)(import_sha24.sha256, key, combined);
 }
 function decodePayload(payload) {
@@ -2487,18 +2489,18 @@ function decodePayload(payload) {
     mac: data.subarray(-32)
   };
 }
-function encrypt2(plaintext, conversationKey, nonce = (0, import_utils14.randomBytes)(32)) {
+function encrypt2(plaintext, conversationKey, nonce = (0, import_utils16.randomBytes)(32)) {
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);
   const padded = pad(plaintext);
   const ciphertext = (0, import_chacha.chacha20)(chacha_key, chacha_nonce, padded);
   const mac = hmacAad(hmac_key, ciphertext, nonce);
-  return import_base3.base64.encode((0, import_utils14.concatBytes)(new Uint8Array([2]), nonce, ciphertext, mac));
+  return import_base3.base64.encode((0, import_utils16.concatBytes)(new Uint8Array([2]), nonce, ciphertext, mac));
 }
 function decrypt2(payload, conversationKey) {
   const { nonce, ciphertext, mac } = decodePayload(payload);
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);
   const calculatedMac = hmacAad(hmac_key, ciphertext, nonce);
-  if (!(0, import_utils13.equalBytes)(calculatedMac, mac))
+  if (!(0, import_utils15.equalBytes)(calculatedMac, mac))
     throw new Error("invalid MAC");
   const padded = (0, import_chacha.chacha20)(chacha_key, chacha_nonce, ciphertext);
   return unpad(padded);
@@ -2718,7 +2720,6 @@ var nip22_exports = {};
 __export(nip22_exports, {
   parse: () => parse3
 });
-var HEX642 = /^[0-9a-fA-F]{64}$/;
 function parseKind(kind) {
   if (!kind)
     return void 0;
@@ -2733,7 +2734,7 @@ function parseAddressPointer(value, relayUrl) {
   if (Number.isNaN(kind))
     return void 0;
   const pubkey = value.slice(idx + 1, idx2);
-  if (!HEX642.test(pubkey))
+  if (!isHex32(pubkey))
     return void 0;
   return {
     kind,
@@ -2746,12 +2747,12 @@ function parsePointer(tag) {
   switch (tag[0]) {
     case "E":
     case "e":
-      if (!tag[1] || !HEX642.test(tag[1]))
+      if (!tag[1] || !isHex32(tag[1]))
         return void 0;
       return {
         id: tag[1],
         relays: tag[2] ? [tag[2]] : [],
-        author: tag[3] && HEX642.test(tag[3]) ? tag[3] : void 0
+        author: tag[3] && isHex32(tag[3]) ? tag[3] : void 0
       };
     case "A":
     case "a":
@@ -2774,12 +2775,12 @@ function parseQuote(tag) {
   if (tag[1].includes(":")) {
     return parseAddressPointer(tag[1], tag[2]);
   }
-  if (!HEX642.test(tag[1]))
+  if (!isHex32(tag[1]))
     return void 0;
   return {
     id: tag[1],
     relays: tag[2] ? [tag[2]] : [],
-    author: tag[3] && HEX642.test(tag[3]) ? tag[3] : void 0
+    author: tag[3] && isHex32(tag[3]) ? tag[3] : void 0
   };
 }
 function choosePointer(candidates) {
@@ -2839,7 +2840,7 @@ function parse3(event) {
         result.quotes.push(pointer);
       continue;
     }
-    if ((tag[0] === "P" || tag[0] === "p") && tag[1] && HEX642.test(tag[1])) {
+    if ((tag[0] === "P" || tag[0] === "p") && tag[1] && isHex32(tag[1])) {
       result.profiles.push({
         pubkey: tag[1],
         relays: tag[2] ? [tag[2]] : []
@@ -3340,10 +3341,10 @@ function validateZapRequest(zapRequestString) {
   let p = zapRequest.tags.find(([t, v]) => t === "p" && v);
   if (!p)
     return "Zap request doesn't have a 'p' tag.";
-  if (!p[1].match(/^[a-f0-9]{64}$/))
+  if (!isHex32(p[1]))
     return "Zap request 'p' tag is not valid hex.";
   let e = zapRequest.tags.find(([t, v]) => t === "e" && v);
-  if (e && !e[1].match(/^[a-f0-9]{64}$/))
+  if (e && !isHex32(e[1]))
     return "Zap request 'e' tag is not valid hex.";
   let relays = zapRequest.tags.find(([t, v]) => t === "relays" && v);
   if (!relays)
@@ -3418,7 +3419,7 @@ __export(nip77_exports, {
   NegentropyStorageVector: () => NegentropyStorageVector,
   NegentropySync: () => NegentropySync
 });
-var import_utils17 = require("@noble/hashes/utils.js");
+var import_utils20 = require("@noble/hashes/utils.js");
 var import_sha25 = require("@noble/hashes/sha2.js");
 var PROTOCOL_VERSION = 97;
 var ID_SIZE = 32;
@@ -3564,7 +3565,7 @@ var NegentropyStorageVector = class {
   insert(timestamp, id) {
     if (this.sealed)
       throw Error("already sealed");
-    const idb = (0, import_utils17.hexToBytes)(id);
+    const idb = (0, import_utils20.hexToBytes)(id);
     if (idb.byteLength !== ID_SIZE)
       throw Error("bad id size for added item");
     this.items.push({ timestamp, id: idb });
@@ -3658,10 +3659,10 @@ var Negentropy = class {
     let output = new WrappedBuffer();
     output.extend(new Uint8Array([PROTOCOL_VERSION]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output);
-    return (0, import_utils17.bytesToHex)(output.unwrap());
+    return (0, import_utils20.bytesToHex)(output.unwrap());
   }
   reconcile(queryMsg, onhave, onneed) {
-    const query = new WrappedBuffer((0, import_utils17.hexToBytes)(queryMsg));
+    const query = new WrappedBuffer((0, import_utils20.hexToBytes)(queryMsg));
     this.lastTimestampIn = this.lastTimestampOut = 0;
     let fullOutput = new WrappedBuffer();
     fullOutput.extend(new Uint8Array([PROTOCOL_VERSION]));
@@ -3704,22 +3705,22 @@ var Negentropy = class {
         let theirElems = {};
         for (let i2 = 0; i2 < numIds; i2++) {
           let e = getBytes(query, ID_SIZE);
-          theirElems[(0, import_utils17.bytesToHex)(e)] = e;
+          theirElems[(0, import_utils20.bytesToHex)(e)] = e;
         }
         skip = true;
         this.storage.iterate(lower, upper, (item) => {
           let k = item.id;
-          const id = (0, import_utils17.bytesToHex)(k);
+          const id = (0, import_utils20.bytesToHex)(k);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[(0, import_utils17.bytesToHex)(k)];
+            delete theirElems[(0, import_utils20.bytesToHex)(k)];
           }
           return true;
         });
         if (onneed) {
           for (let v of Object.values(theirElems)) {
-            onneed((0, import_utils17.bytesToHex)(v));
+            onneed((0, import_utils20.bytesToHex)(v));
           }
         }
       } else {
@@ -3737,7 +3738,7 @@ var Negentropy = class {
       prevIndex = upper;
       prevBound = currBound;
     }
-    return fullOutput.length === 1 ? null : (0, import_utils17.bytesToHex)(fullOutput.unwrap());
+    return fullOutput.length === 1 ? null : (0, import_utils20.bytesToHex)(fullOutput.unwrap());
   }
   splitRange(lower, upper, upperBound, o) {
     let numElems = upper - lower;
@@ -3926,7 +3927,7 @@ __export(nip98_exports, {
   validateToken: () => validateToken
 });
 var import_sha26 = require("@noble/hashes/sha2.js");
-var import_utils18 = require("@noble/hashes/utils.js");
+var import_utils21 = require("@noble/hashes/utils.js");
 var import_base5 = require("@scure/base");
 var _authorizationScheme = "Nostr ";
 async function getToken(loginUrl, httpMethod, sign, includeAuthorizationScheme = false, payload) {
@@ -3992,7 +3993,7 @@ function validateEventMethodTag(event, method) {
 }
 function hashPayload(payload) {
   const hash = (0, import_sha26.sha256)(utf8Encoder.encode(JSON.stringify(payload)));
-  return (0, import_utils18.bytesToHex)(hash);
+  return (0, import_utils21.bytesToHex)(hash);
 }
 function validateEventPayloadTag(event, payload) {
   const payloadTag = event.tags.find((t) => t[0] === "payload");