nostr-tools 1.13.1 → 1.14.2

package/README.md

@@ -108,13 +108,7 @@ let event = {
 event.id = getEventHash(event)
 event.sig = getSignature(event, sk)
 
-let pub = relay.publish(event)
-pub.on('ok', () => {
-  console.log(`${relay.url} has accepted our event`)
-})
-pub.on('failed', reason => {
-  console.log(`failed to publish to ${relay.url}: ${reason}`)
-})
+await relay.publish(event)
 
 let events = await relay.list([{kinds: [0, 1]}])
 let event = await relay.get({

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 */) {
@@ -491,12 +492,11 @@ function relayInit(url, options = {}) {
               let ok = data[2];
               let reason = data[3] || "";
               if (id2 in pubListeners) {
+                let { resolve: resolve2, reject: reject2 } = pubListeners[id2];
                 if (ok)
-                  pubListeners[id2].ok.forEach((cb) => cb());
+                  resolve2(null);
                 else
-                  pubListeners[id2].failed.forEach((cb) => cb(reason));
-                pubListeners[id2].ok = [];
-                pubListeners[id2].failed = [];
+                  reject2(new Error(reason));
               }
               return;
             }
@@ -581,27 +581,15 @@ function relayInit(url, options = {}) {
     };
   };
   function _publishEvent(event, type) {
-    if (!event.id)
-      throw new Error(`event ${event} has no id`);
-    let id = event.id;
-    trySend([type, event]);
-    return {
-      on: (type2, cb) => {
-        pubListeners[id] = pubListeners[id] || {
-          ok: [],
-          failed: []
-        };
-        pubListeners[id][type2].push(cb);
-      },
-      off: (type2, cb) => {
-        let listeners2 = pubListeners[id];
-        if (!listeners2)
-          return;
-        let idx = listeners2[type2].indexOf(cb);
-        if (idx >= 0)
-          listeners2[type2].splice(idx, 1);
+    return new Promise((resolve, reject) => {
+      if (!event.id) {
+        reject(new Error(`event ${event} has no id`));
+        return;
       }
-    };
+      let id = event.id;
+      trySend([type, event]);
+      pubListeners[id] = { resolve, reject };
+    });
   }
   return {
     url,
@@ -658,19 +646,19 @@ function relayInit(url, options = {}) {
         resolve(event);
       });
     }),
-    publish(event) {
-      return _publishEvent(event, "EVENT");
+    async publish(event) {
+      await _publishEvent(event, "EVENT");
     },
-    auth(event) {
-      return _publishEvent(event, "AUTH");
+    async auth(event) {
+      await _publishEvent(event, "AUTH");
     },
     connect,
     close() {
       listeners = newListeners();
       subListeners = {};
       pubListeners = {};
-      if (ws.readyState === WebSocket.OPEN) {
-        ws?.close();
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.close();
       }
     },
     get status() {
@@ -683,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) => {
@@ -735,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);
@@ -817,38 +808,54 @@ var SimplePool = class {
       });
     });
   }
-  publish(relays, event) {
-    const pubPromises = relays.map(async (relay) => {
-      let r;
-      try {
-        r = await this.ensureRelay(relay);
-        return r.publish(event);
-      } catch (_) {
-        return { on() {
-        }, off() {
-        } };
-      }
-    });
-    const callbackMap = /* @__PURE__ */ new Map();
-    return {
-      on(type, cb) {
-        relays.forEach(async (relay, i) => {
-          let pub = await pubPromises[i];
-          let callback = () => cb(relay);
-          callbackMap.set(cb, callback);
-          pub.on(type, callback);
-        });
-      },
-      off(type, cb) {
-        relays.forEach(async (_, i) => {
-          let callback = callbackMap.get(cb);
-          if (callback) {
-            let pub = await pubPromises[i];
-            pub.off(type, callback);
+  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);
+      return r.publish(event);
+    });
   }
   seenOn(id) {
     return Array.from(this._seenOn[id]?.values?.() || []);
@@ -1578,6 +1585,107 @@ function replaceAll(content, replacer) {
   });
 }
 
+// nip28.ts
+var nip28_exports = {};
+__export(nip28_exports, {
+  channelCreateEvent: () => channelCreateEvent,
+  channelHideMessageEvent: () => channelHideMessageEvent,
+  channelMessageEvent: () => channelMessageEvent,
+  channelMetadataEvent: () => channelMetadataEvent,
+  channelMuteUserEvent: () => channelMuteUserEvent
+});
+var channelCreateEvent = (t, privateKey) => {
+  let content;
+  if (typeof t.content === "object") {
+    content = JSON.stringify(t.content);
+  } else if (typeof t.content === "string") {
+    content = t.content;
+  } else {
+    return void 0;
+  }
+  return finishEvent(
+    {
+      kind: 40 /* ChannelCreation */,
+      tags: [...t.tags ?? []],
+      content,
+      created_at: t.created_at
+    },
+    privateKey
+  );
+};
+var channelMetadataEvent = (t, privateKey) => {
+  let content;
+  if (typeof t.content === "object") {
+    content = JSON.stringify(t.content);
+  } else if (typeof t.content === "string") {
+    content = t.content;
+  } else {
+    return void 0;
+  }
+  return finishEvent(
+    {
+      kind: 41 /* ChannelMetadata */,
+      tags: [["e", t.channel_create_event_id], ...t.tags ?? []],
+      content,
+      created_at: t.created_at
+    },
+    privateKey
+  );
+};
+var channelMessageEvent = (t, privateKey) => {
+  const tags = [["e", t.channel_create_event_id, t.relay_url, "root"]];
+  if (t.reply_to_channel_message_event_id) {
+    tags.push(["e", t.reply_to_channel_message_event_id, t.relay_url, "reply"]);
+  }
+  return finishEvent(
+    {
+      kind: 42 /* ChannelMessage */,
+      tags: [...tags, ...t.tags ?? []],
+      content: t.content,
+      created_at: t.created_at
+    },
+    privateKey
+  );
+};
+var channelHideMessageEvent = (t, privateKey) => {
+  let content;
+  if (typeof t.content === "object") {
+    content = JSON.stringify(t.content);
+  } else if (typeof t.content === "string") {
+    content = t.content;
+  } else {
+    return void 0;
+  }
+  return finishEvent(
+    {
+      kind: 43 /* ChannelHideMessage */,
+      tags: [["e", t.channel_message_event_id], ...t.tags ?? []],
+      content,
+      created_at: t.created_at
+    },
+    privateKey
+  );
+};
+var channelMuteUserEvent = (t, privateKey) => {
+  let content;
+  if (typeof t.content === "object") {
+    content = JSON.stringify(t.content);
+  } else if (typeof t.content === "string") {
+    content = t.content;
+  } else {
+    return void 0;
+  }
+  return finishEvent(
+    {
+      kind: 44 /* ChannelMuteUser */,
+      tags: [["p", t.pubkey_to_mute], ...t.tags ?? []],
+      content,
+      created_at: t.created_at
+    },
+    privateKey
+  );
+};
+
 // nip39.ts
 var nip39_exports = {};
 __export(nip39_exports, {
@@ -1620,19 +1728,46 @@ var authenticate = async ({
     ],
     content: ""
   };
-  const pub = relay.auth(await sign(e));
-  return new Promise((resolve, reject) => {
-    pub.on("ok", function ok() {
-      pub.off("ok", ok);
-      resolve();
-    });
-    pub.on("failed", function fail(reason) {
-      pub.off("failed", fail);
-      reject(reason);
-    });
-  });
+  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, {
@@ -1754,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],
@@ -1771,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");
   }
@@ -1832,8 +1979,10 @@ export {
   nip25_exports as nip25,
   nip26_exports as nip26,
   nip27_exports as nip27,
+  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,