nostr-tools 2.23.3 → 2.23.4

package/lib/cjs/index.js

@@ -41,6 +41,7 @@ __export(nostr_tools_exports, {
   nip18: () => nip18_exports,
   nip19: () => nip19_exports,
   nip21: () => nip21_exports,
+  nip22: () => nip22_exports,
   nip25: () => nip25_exports,
   nip27: () => nip27_exports,
   nip28: () => nip28_exports,
@@ -2030,7 +2031,8 @@ var import_sha23 = require("@noble/hashes/sha2.js");
 var import_utils13 = require("@noble/hashes/utils.js");
 var import_base3 = require("@scure/base");
 var minPlaintextSize = 1;
-var maxPlaintextSize = 65535;
+var maxPlaintextSize = 4294967295;
+var extendedPrefixThreshold = 65536;
 function getConversationKey(privkeyA, pubkeyB) {
   const sharedX = import_secp256k13.secp256k1.getSharedSecret(privkeyA, (0, import_utils13.hexToBytes)("02" + pubkeyB)).subarray(1, 33);
   return (0, import_hkdf.extract)(import_sha23.sha256, sharedX, utf8Encoder.encode("nip44-v2"));
@@ -2048,28 +2050,49 @@ function calcPaddedLen(len) {
     throw new Error("expected positive integer");
   if (len <= 32)
     return 32;
-  const nextPower = 1 << Math.floor(Math.log2(len - 1)) + 1;
+  const nextPower = 2 ** (Math.floor(Math.log2(len - 1)) + 1);
   const chunk = nextPower <= 256 ? 32 : nextPower / 8;
   return chunk * (Math.floor((len - 1) / chunk) + 1);
 }
 function writeU16BE(num) {
-  if (!Number.isSafeInteger(num) || num < minPlaintextSize || num > maxPlaintextSize)
+  if (!Number.isSafeInteger(num) || num < minPlaintextSize || num > 65535)
     throw new Error("invalid plaintext size: must be between 1 and 65535 bytes");
   const arr = new Uint8Array(2);
   new DataView(arr.buffer).setUint16(0, num, false);
   return arr;
 }
+function writeU32BE(num) {
+  if (!Number.isSafeInteger(num) || num < extendedPrefixThreshold || num > maxPlaintextSize)
+    throw new Error("invalid plaintext size: must be between 65536 and 4294967295 bytes");
+  const arr = new Uint8Array(4);
+  new DataView(arr.buffer).setUint32(0, num, false);
+  return arr;
+}
 function pad(plaintext) {
   const unpadded = utf8Encoder.encode(plaintext);
   const unpaddedLen = unpadded.length;
-  const prefix = writeU16BE(unpaddedLen);
+  if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize)
+    throw new Error("invalid plaintext size: must be between 1 and 4294967295 bytes");
+  const prefix = unpaddedLen >= extendedPrefixThreshold ? (0, import_utils13.concatBytes)(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
   const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);
   return (0, import_utils13.concatBytes)(prefix, unpadded, suffix);
 }
 function unpad(padded) {
-  const unpaddedLen = new DataView(padded.buffer).getUint16(0);
-  const unpadded = padded.subarray(2, 2 + unpaddedLen);
-  if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize || unpadded.length !== unpaddedLen || padded.length !== 2 + calcPaddedLen(unpaddedLen))
+  const dv = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+  const firstTwo = dv.getUint16(0);
+  let unpaddedLen;
+  let prefixLen;
+  if (firstTwo === 0) {
+    unpaddedLen = dv.getUint32(2);
+    if (unpaddedLen < extendedPrefixThreshold)
+      throw new Error("invalid padding");
+    prefixLen = 6;
+  } else {
+    unpaddedLen = firstTwo;
+    prefixLen = 2;
+  }
+  const unpadded = padded.subarray(prefixLen, prefixLen + unpaddedLen);
+  if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize || unpadded.length !== unpaddedLen || padded.length !== prefixLen + calcPaddedLen(unpaddedLen))
     throw new Error("invalid padding");
   return utf8Decoder.decode(unpadded);
 }
@@ -2083,7 +2106,7 @@ function decodePayload(payload) {
   if (typeof payload !== "string")
     throw new Error("payload must be a valid string");
   const plen = payload.length;
-  if (plen < 132 || plen > 87472)
+  if (plen < 132)
     throw new Error("invalid payload length: " + plen);
   if (payload[0] === "#")
     throw new Error("unknown encryption version");
@@ -2094,7 +2117,7 @@ function decodePayload(payload) {
     throw new Error("invalid base64: " + error.message);
   }
   const dlen = data.length;
-  if (dlen < 99 || dlen > 65603)
+  if (dlen < 99)
     throw new Error("invalid data length: " + dlen);
   const vers = data[0];
   if (vers !== 2)
@@ -2124,7 +2147,9 @@ function decrypt2(payload, conversationKey) {
 var v2 = {
   utils: {
     getConversationKey,
-    calcPaddedLen
+    calcPaddedLen,
+    pad,
+    unpad
   },
   encrypt: encrypt2,
   decrypt: decrypt2
@@ -2329,6 +2354,141 @@ function parse2(uri) {
   };
 }
 
+// nip22.ts
+var nip22_exports = {};
+__export(nip22_exports, {
+  parse: () => parse3
+});
+function parseKind(kind) {
+  if (!kind)
+    return void 0;
+  return /^\d+$/.test(kind) ? parseInt(kind, 10) : kind;
+}
+function parseAddressPointer(value, relayUrl) {
+  const idx = value.indexOf(":");
+  const idx2 = value.indexOf(":", idx + 1);
+  if (idx === -1 || idx2 === -1)
+    return void 0;
+  const kind = parseInt(value.slice(0, idx), 10);
+  if (Number.isNaN(kind))
+    return void 0;
+  return {
+    kind,
+    pubkey: value.slice(idx + 1, idx2),
+    identifier: value.slice(idx2 + 1),
+    relays: relayUrl ? [relayUrl] : []
+  };
+}
+function parsePointer(tag) {
+  switch (tag[0]) {
+    case "E":
+    case "e":
+      if (!tag[1])
+        return void 0;
+      return {
+        id: tag[1],
+        relays: tag[2] ? [tag[2]] : [],
+        author: tag[3]
+      };
+    case "A":
+    case "a":
+      if (!tag[1])
+        return void 0;
+      return parseAddressPointer(tag[1], tag[2]);
+    case "I":
+    case "i":
+      if (!tag[1])
+        return void 0;
+      return {
+        value: tag[1],
+        hint: tag[2]
+      };
+  }
+}
+function parseQuote(tag) {
+  if (!tag[1])
+    return void 0;
+  if (tag[1].includes(":")) {
+    return parseAddressPointer(tag[1], tag[2]);
+  }
+  return {
+    id: tag[1],
+    relays: tag[2] ? [tag[2]] : [],
+    author: tag[3]
+  };
+}
+function choosePointer(candidates) {
+  return candidates.findLast((candidate) => candidate.tagName === "A" || candidate.tagName === "a")?.pointer || candidates.findLast((candidate) => candidate.tagName === "I" || candidate.tagName === "i")?.pointer || candidates.findLast((candidate) => candidate.tagName === "E" || candidate.tagName === "e")?.pointer;
+}
+function inheritRelayHints(pointer, profiles) {
+  if (!pointer || !("id" in pointer) || !pointer.author)
+    return;
+  const author = profiles.find((profile) => profile.pubkey === pointer.author);
+  if (!author || !author.relays)
+    return;
+  if (!pointer.relays) {
+    pointer.relays = [];
+  }
+  author.relays.forEach((url) => {
+    if (pointer.relays.indexOf(url) === -1)
+      pointer.relays.push(url);
+  });
+  author.relays = pointer.relays;
+}
+function parse3(event) {
+  const result = {
+    root: void 0,
+    rootKind: void 0,
+    reply: void 0,
+    replyKind: void 0,
+    mentions: [],
+    quotes: [],
+    profiles: []
+  };
+  const rootCandidates = [];
+  const replyCandidates = [];
+  for (const tag of event.tags) {
+    if ((tag[0] === "E" || tag[0] === "A" || tag[0] === "I") && tag[1]) {
+      const pointer = parsePointer(tag);
+      if (pointer)
+        rootCandidates.push({ tagName: tag[0], pointer });
+      continue;
+    }
+    if ((tag[0] === "e" || tag[0] === "a" || tag[0] === "i") && tag[1]) {
+      const pointer = parsePointer(tag);
+      if (pointer)
+        replyCandidates.push({ tagName: tag[0], pointer });
+      continue;
+    }
+    if (tag[0] === "K") {
+      result.rootKind = parseKind(tag[1]);
+      continue;
+    }
+    if (tag[0] === "k") {
+      result.replyKind = parseKind(tag[1]);
+      continue;
+    }
+    if (tag[0] === "q") {
+      const pointer = parseQuote(tag);
+      if (pointer)
+        result.quotes.push(pointer);
+      continue;
+    }
+    if ((tag[0] === "P" || tag[0] === "p") && tag[1]) {
+      result.profiles.push({
+        pubkey: tag[1],
+        relays: tag[2] ? [tag[2]] : []
+      });
+    }
+  }
+  result.root = choosePointer(rootCandidates);
+  result.reply = choosePointer(replyCandidates);
+  inheritRelayHints(result.root, result.profiles);
+  inheritRelayHints(result.reply, result.profiles);
+  result.quotes.forEach((pointer) => inheritRelayHints(pointer, result.profiles));
+  return result;
+}
+
 // nip25.ts
 var nip25_exports = {};
 __export(nip25_exports, {
@@ -2376,12 +2536,12 @@ function getReactedEventPointer(event) {
 // nip27.ts
 var nip27_exports = {};
 __export(nip27_exports, {
-  parse: () => parse3
+  parse: () => parse4
 });
 var noCharacter = /\W/m;
 var noURLCharacter = /[^\w\/] |[^\w\/]$|$|,| /m;
 var MAX_HASHTAG_LENGTH = 42;
-function* parse3(content) {
+function* parse4(content) {
   let emojis = [];
   if (typeof content !== "string") {
     for (let i2 = 0; i2 < content.tags.length; i2++) {
@@ -2692,12 +2852,12 @@ __export(nip47_exports, {
 function parseConnectionString(connectionString) {
   const { host, pathname, searchParams } = new URL(connectionString);
   const pubkey = pathname || host;
-  const relay = searchParams.get("relay");
+  const relays = searchParams.getAll("relay");
   const secret = searchParams.get("secret");
-  if (!pubkey || !relay || !secret) {
+  if (!pubkey || relays.length === 0 || !secret) {
     throw new Error("invalid connection string");
   }
-  return { pubkey, relay, secret };
+  return { pubkey, relay: relays[0], relays, secret };
 }
 async function makeNwcRequestEvent(pubkey, secretKey, invoice) {
   const content = {