nostr-tools 2.23.3 → 2.23.4

package/lib/nostr.bundle.js

@@ -42,6 +42,7 @@ var NostrTools = (() => {
     nip18: () => nip18_exports,
     nip19: () => nip19_exports,
     nip21: () => nip21_exports,
+    nip22: () => nip22_exports,
     nip25: () => nip25_exports,
     nip27: () => nip27_exports,
     nip28: () => nip28_exports,
@@ -5704,7 +5705,8 @@ var NostrTools = (() => {
 
   // nip44.ts
   var minPlaintextSize = 1;
-  var maxPlaintextSize = 65535;
+  var maxPlaintextSize = 4294967295;
+  var extendedPrefixThreshold = 65536;
   function getConversationKey(privkeyA, pubkeyB) {
     const sharedX = secp256k1.getSharedSecret(privkeyA, hexToBytes("02" + pubkeyB)).subarray(1, 33);
     return extract(sha256, sharedX, utf8Encoder.encode("nip44-v2"));
@@ -5722,28 +5724,49 @@ var NostrTools = (() => {
       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(num2) {
-    if (!Number.isSafeInteger(num2) || num2 < minPlaintextSize || num2 > maxPlaintextSize)
+    if (!Number.isSafeInteger(num2) || num2 < minPlaintextSize || num2 > 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, num2, false);
     return arr;
   }
+  function writeU32BE(num2) {
+    if (!Number.isSafeInteger(num2) || num2 < extendedPrefixThreshold || num2 > 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, num2, 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 ? concatBytes(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
     const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);
     return 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);
   }
@@ -5757,7 +5780,7 @@ var NostrTools = (() => {
     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");
@@ -5768,7 +5791,7 @@ var NostrTools = (() => {
       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)
@@ -5798,7 +5821,9 @@ var NostrTools = (() => {
   var v2 = {
     utils: {
       getConversationKey,
-      calcPaddedLen
+      calcPaddedLen,
+      pad,
+      unpad
     },
     encrypt: encrypt3,
     decrypt: decrypt3
@@ -6003,6 +6028,141 @@ var NostrTools = (() => {
     };
   }
 
+  // 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, {
@@ -6050,12 +6210,12 @@ var NostrTools = (() => {
   // 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++) {
@@ -6366,12 +6526,12 @@ var NostrTools = (() => {
   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 = {