nostr-tools 1.14.0 → 1.14.2

package/lib/esm/nostr.mjs

@@ -211,6 +211,7 @@ var Kind = /* @__PURE__ */ ((Kind3) => {
   Kind3[Kind3["ProfileBadge"] = 30008] = "ProfileBadge";
   Kind3[Kind3["BadgeDefinition"] = 30009] = "BadgeDefinition";
   Kind3[Kind3["Article"] = 30023] = "Article";
+  Kind3[Kind3["FileMetadata"] = 1063] = "FileMetadata";
   return Kind3;
 })(Kind || {});
 function getBlankEvent(kind = 255 /* Blank */) {
@@ -656,8 +657,8 @@ function relayInit(url, options = {}) {
       listeners = newListeners();
       subListeners = {};
       pubListeners = {};
-      if (ws.readyState === WebSocket.OPEN) {
-        ws?.close();
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.close();
       }
     },
     get status() {
@@ -670,14 +671,17 @@ function relayInit(url, options = {}) {
 var SimplePool = class {
   _conn;
   _seenOn = {};
+  batchedByKey = {};
   eoseSubTimeout;
   getTimeout;
   seenOnEnabled = true;
+  batchInterval = 100;
   constructor(options = {}) {
     this._conn = {};
     this.eoseSubTimeout = options.eoseSubTimeout || 3400;
     this.getTimeout = options.getTimeout || 3400;
     this.seenOnEnabled = options.seenOnEnabled !== false;
+    this.batchInterval = options.batchInterval || 100;
   }
   close(relays) {
     relays.forEach((url) => {
@@ -722,7 +726,7 @@ var SimplePool = class {
       for (let cb of eoseListeners.values())
         cb();
     }, this.eoseSubTimeout);
-    relays.forEach(async (relay) => {
+    relays.filter((r, i, a) => a.indexOf(r) == i).forEach(async (relay) => {
       let r;
       try {
         r = await this.ensureRelay(relay);
@@ -804,6 +808,49 @@ var SimplePool = class {
       });
     });
   }
+  batchedList(batchKey, relays, filters) {
+    return new Promise((resolve) => {
+      if (!this.batchedByKey[batchKey]) {
+        this.batchedByKey[batchKey] = [
+          {
+            filters,
+            relays,
+            resolve,
+            events: []
+          }
+        ];
+        setTimeout(() => {
+          Object.keys(this.batchedByKey).forEach(async (batchKey2) => {
+            const batchedRequests = this.batchedByKey[batchKey2];
+            const filters2 = [];
+            const relays2 = [];
+            batchedRequests.forEach((br) => {
+              filters2.push(...br.filters);
+              relays2.push(...br.relays);
+            });
+            const sub = this.sub(relays2, filters2);
+            sub.on("event", (event) => {
+              batchedRequests.forEach(
+                (br) => matchFilters(br.filters, event) && br.events.push(event)
+              );
+            });
+            sub.on("eose", () => {
+              sub.unsub();
+              batchedRequests.forEach((br) => br.resolve(br.events));
+            });
+            delete this.batchedByKey[batchKey2];
+          });
+        }, this.batchInterval);
+      } else {
+        this.batchedByKey[batchKey].push({
+          filters,
+          relays,
+          resolve,
+          events: []
+        });
+      }
+    });
+  }
   publish(relays, event) {
     return relays.map(async (relay) => {
       let r = await this.ensureRelay(relay);
@@ -1684,6 +1731,43 @@ var authenticate = async ({
   return relay.auth(await sign(e));
 };
 
+// nip44.ts
+var nip44_exports = {};
+__export(nip44_exports, {
+  decrypt: () => decrypt2,
+  encrypt: () => encrypt2,
+  getSharedSecret: () => getSharedSecret
+});
+import { base64 as base642 } from "@scure/base";
+import { randomBytes as randomBytes2 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
+import { sha256 as sha2563 } from "@noble/hashes/sha256";
+import { xchacha20 } from "@noble/ciphers/chacha";
+var getSharedSecret = (privkey, pubkey) => sha2563(secp256k12.getSharedSecret(privkey, "02" + pubkey).subarray(1, 33));
+function encrypt2(key, text, v = 1) {
+  if (v !== 1) {
+    throw new Error("NIP44: unknown encryption version");
+  }
+  const nonce = randomBytes2(24);
+  const plaintext = utf8Encoder.encode(text);
+  const ciphertext = xchacha20(key, nonce, plaintext);
+  const payload = new Uint8Array(25 + ciphertext.length);
+  payload.set([v], 0);
+  payload.set(nonce, 1);
+  payload.set(ciphertext, 25);
+  return base642.encode(payload);
+}
+function decrypt2(key, payload) {
+  let data = base642.decode(payload);
+  if (data[0] !== 1) {
+    throw new Error(`NIP44: unknown encryption version: ${data[0]}`);
+  }
+  const nonce = data.slice(1, 25);
+  const ciphertext = data.slice(25);
+  const plaintext = xchacha20(key, nonce, ciphertext);
+  return utf8Decoder.decode(plaintext);
+}
+
 // nip57.ts
 var nip57_exports = {};
 __export(nip57_exports, {
@@ -1805,15 +1889,15 @@ function makeZapReceipt({
 var nip98_exports = {};
 __export(nip98_exports, {
   getToken: () => getToken,
+  unpackEventFromToken: () => unpackEventFromToken,
+  validateEvent: () => validateEvent2,
   validateToken: () => validateToken
 });
-import { base64 as base642 } from "@scure/base";
+import { base64 as base643 } from "@scure/base";
 var _authorizationScheme = "Nostr ";
 async function getToken(loginUrl, httpMethod, sign, includeAuthorizationScheme = false) {
   if (!loginUrl || !httpMethod)
     throw new Error("Missing loginUrl or httpMethod");
-  if (httpMethod !== "get" /* Get */ && httpMethod !== "post" /* Post */)
-    throw new Error("Unknown httpMethod");
   const event = getBlankEvent(27235 /* HttpAuth */);
   event.tags = [
     ["u", loginUrl],
@@ -1822,18 +1906,30 @@ async function getToken(loginUrl, httpMethod, sign, includeAuthorizationScheme =
   event.created_at = Math.round(new Date().getTime() / 1e3);
   const signedEvent = await sign(event);
   const authorizationScheme = includeAuthorizationScheme ? _authorizationScheme : "";
-  return authorizationScheme + base642.encode(utf8Encoder.encode(JSON.stringify(signedEvent)));
+  return authorizationScheme + base643.encode(utf8Encoder.encode(JSON.stringify(signedEvent)));
 }
 async function validateToken(token, url, method) {
+  const event = await unpackEventFromToken(token).catch((error) => {
+    throw error;
+  });
+  const valid = await validateEvent2(event, url, method).catch((error) => {
+    throw error;
+  });
+  return valid;
+}
+async function unpackEventFromToken(token) {
   if (!token) {
     throw new Error("Missing token");
   }
   token = token.replace(_authorizationScheme, "");
-  const eventB64 = utf8Decoder.decode(base642.decode(token));
+  const eventB64 = utf8Decoder.decode(base643.decode(token));
   if (!eventB64 || eventB64.length === 0 || !eventB64.startsWith("{")) {
     throw new Error("Invalid token");
   }
   const event = JSON.parse(eventB64);
+  return event;
+}
+async function validateEvent2(event, url, method) {
   if (!event) {
     throw new Error("Invalid nostr event");
   }
@@ -1886,6 +1982,7 @@ export {
   nip28_exports as nip28,
   nip39_exports as nip39,
   nip42_exports as nip42,
+  nip44_exports as nip44,
   nip57_exports as nip57,
   nip98_exports as nip98,
   parseReferences,