nostr-tools 1.4.1 → 1.5.0

package/README.md

@@ -4,6 +4,13 @@ Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 Only depends on _@scure_ and _@noble_ packages.
 
+## Installation
+
+```bash
+ npm install nostr-tools # or yarn add nostr-tools
+```
+
+
 ## Usage
 
 ### Generating a private key and a public key
@@ -53,8 +60,6 @@ import {
 } from 'nostr-tools'
 
 const relay = relayInit('wss://relay.example.com')
-await relay.connect()
-
 relay.on('connect', () => {
   console.log(`connected to ${relay.url}`)
 })
@@ -62,6 +67,8 @@ relay.on('error', () => {
   console.log(`failed to connect to ${relay.url}`)
 })
 
+await relay.connect()
+
 // let's query for an event that exists
 let sub = relay.sub([
   {
@@ -104,9 +111,6 @@ let pub = relay.publish(event)
 pub.on('ok', () => {
   console.log(`${relay.url} has accepted our event`)
 })
-pub.on('seen', () => {
-  console.log(`we saw the event on ${relay.url}`)
-})
 pub.on('failed', reason => {
   console.log(`failed to publish to ${relay.url}: ${reason}`)
 })

package/event.ts

@@ -2,6 +2,7 @@ import * as secp256k1 from '@noble/secp256k1'
 import {sha256} from '@noble/hashes/sha256'
 
 import {utf8Encoder} from './utils'
+import {getPublicKey} from './keys'
 
 /* eslint-disable no-unused-vars */
 export enum Kind {
@@ -16,30 +17,49 @@ export enum Kind {
   ChannelMetadata = 41,
   ChannelMessage = 42,
   ChannelHideMessage = 43,
-  ChannelMuteUser = 44
+  ChannelMuteUser = 44,
+  Report = 1984,
+  ZapRequest = 9734,
+  Zap = 9735,
+  RelayList = 10002,
+  ClientAuth = 22242,
+  Article = 30023
 }
 
-export type Event = {
-  id?: string
-  sig?: string
+export type EventTemplate = {
   kind: Kind
   tags: string[][]
-  pubkey: string
   content: string
   created_at: number
 }
 
-export function getBlankEvent(): Event {
+export type UnsignedEvent = EventTemplate & {
+  pubkey: string
+}
+
+export type Event = UnsignedEvent & {
+  id: string
+  sig: string
+}
+
+export function getBlankEvent(): EventTemplate {
   return {
     kind: 255,
-    pubkey: '',
     content: '',
     tags: [],
     created_at: 0
   }
 }
 
-export function serializeEvent(evt: Event): string {
+export function finishEvent(t: EventTemplate, privateKey: string): Event {
+  let event = t as Event
+  event.pubkey = getPublicKey(privateKey)
+  event.id = getEventHash(event)
+  event.sig = signEvent(event, privateKey)
+  return event
+}
+
+export function serializeEvent(evt: UnsignedEvent): string {
   if (!validateEvent(evt))
     throw new Error("can't serialize event with wrong or missing properties")
 
@@ -53,12 +73,13 @@ export function serializeEvent(evt: Event): string {
   ])
 }
 
-export function getEventHash(event: Event): string {
+export function getEventHash(event: UnsignedEvent): string {
   let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
   return secp256k1.utils.bytesToHex(eventHash)
 }
 
-export function validateEvent(event: Event): boolean {
+export function validateEvent(event: UnsignedEvent): boolean {
+  if (typeof event !== 'object') return false
   if (typeof event.content !== 'string') return false
   if (typeof event.created_at !== 'number') return false
   if (typeof event.pubkey !== 'string') return false
@@ -84,7 +105,7 @@ export function verifySignature(event: Event & {sig: string}): boolean {
   )
 }
 
-export function signEvent(event: Event, key: string): string {
+export function signEvent(event: UnsignedEvent, key: string): string {
   return secp256k1.utils.bytesToHex(
     secp256k1.schnorr.signSync(getEventHash(event), key)
   )

package/index.ts

@@ -9,6 +9,7 @@ export * as nip05 from './nip05'
 export * as nip06 from './nip06'
 export * as nip19 from './nip19'
 export * as nip26 from './nip26'
+export * as nip57 from './nip57'
 
 export * as fj from './fakejson'
 export * as utils from './utils'

package/lib/nostr.bundle.js

@@ -3605,6 +3605,7 @@ zoo`.split("\n");
   __export(nostr_tools_exports, {
     Kind: () => Kind,
     SimplePool: () => SimplePool,
+    finishEvent: () => finishEvent,
     fj: () => fakejson_exports,
     generatePrivateKey: () => generatePrivateKey,
     getBlankEvent: () => getBlankEvent,
@@ -3617,6 +3618,7 @@ zoo`.split("\n");
     nip06: () => nip06_exports,
     nip19: () => nip19_exports,
     nip26: () => nip26_exports,
+    nip57: () => nip57_exports,
     relayInit: () => relayInit,
     serializeEvent: () => serializeEvent,
     signEvent: () => signEvent,
@@ -5100,17 +5102,29 @@ zoo`.split("\n");
     Kind2[Kind2["ChannelMessage"] = 42] = "ChannelMessage";
     Kind2[Kind2["ChannelHideMessage"] = 43] = "ChannelHideMessage";
     Kind2[Kind2["ChannelMuteUser"] = 44] = "ChannelMuteUser";
+    Kind2[Kind2["Report"] = 1984] = "Report";
+    Kind2[Kind2["ZapRequest"] = 9734] = "ZapRequest";
+    Kind2[Kind2["Zap"] = 9735] = "Zap";
+    Kind2[Kind2["RelayList"] = 10002] = "RelayList";
+    Kind2[Kind2["ClientAuth"] = 22242] = "ClientAuth";
+    Kind2[Kind2["Article"] = 30023] = "Article";
     return Kind2;
   })(Kind || {});
   function getBlankEvent() {
     return {
       kind: 255,
-      pubkey: "",
       content: "",
       tags: [],
       created_at: 0
     };
   }
+  function finishEvent(t, privateKey) {
+    let event = t;
+    event.pubkey = getPublicKey(privateKey);
+    event.id = getEventHash(event);
+    event.sig = signEvent(event, privateKey);
+    return event;
+  }
   function serializeEvent(evt) {
     if (!validateEvent(evt))
       throw new Error("can't serialize event with wrong or missing properties");
@@ -5128,6 +5142,8 @@ zoo`.split("\n");
     return utils.bytesToHex(eventHash);
   }
   function validateEvent(event) {
+    if (typeof event !== "object")
+      return false;
     if (typeof event.content !== "string")
       return false;
     if (typeof event.created_at !== "number")
@@ -5308,17 +5324,24 @@ zoo`.split("\n");
                 return;
               case "EOSE": {
                 let id2 = data[1];
-                (subListeners[id2]?.eose || []).forEach((cb) => cb());
+                if (id2 in subListeners) {
+                  subListeners[id2].eose.forEach((cb) => cb());
+                  subListeners[id2].eose = [];
+                }
                 return;
               }
               case "OK": {
                 let id2 = data[1];
                 let ok = data[2];
                 let reason = data[3] || "";
-                if (ok)
-                  pubListeners[id2]?.ok.forEach((cb) => cb());
-                else
-                  pubListeners[id2]?.failed.forEach((cb) => cb(reason));
+                if (id2 in pubListeners) {
+                  if (ok)
+                    pubListeners[id2].ok.forEach((cb) => cb());
+                  else
+                    pubListeners[id2].failed.forEach((cb) => cb(reason));
+                  pubListeners[id2].ok = [];
+                  pubListeners[id2].failed = [];
+                }
                 return;
               }
               case "NOTICE":
@@ -5430,46 +5453,14 @@ zoo`.split("\n");
         if (!event.id)
           throw new Error(`event ${event} has no id`);
         let id = event.id;
-        var sent = false;
-        var mustMonitor = false;
-        trySend(["EVENT", event]).then(() => {
-          sent = true;
-          if (mustMonitor) {
-            startMonitoring();
-            mustMonitor = false;
-          }
-        }).catch(() => {
-        });
-        const startMonitoring = () => {
-          let monitor = sub([{ ids: [id] }], {
-            id: `monitor-${id.slice(0, 5)}`
-          });
-          let willUnsub = setTimeout(() => {
-            ;
-            (pubListeners[id]?.failed || []).forEach(
-              (cb) => cb("event not seen after 5 seconds")
-            );
-            monitor.unsub();
-          }, 5e3);
-          monitor.on("event", () => {
-            clearTimeout(willUnsub);
-            (pubListeners[id]?.seen || []).forEach((cb) => cb());
-          });
-        };
+        trySend(["EVENT", event]);
         return {
           on: (type, cb) => {
             pubListeners[id] = pubListeners[id] || {
               ok: [],
-              seen: [],
               failed: []
             };
             pubListeners[id][type].push(cb);
-            if (type === "seen") {
-              if (sent)
-                startMonitoring();
-              else
-                mustMonitor = true;
-            }
           },
           off: (type, cb) => {
             let listeners2 = pubListeners[id];
@@ -5483,6 +5474,9 @@ zoo`.split("\n");
       },
       connect,
       close() {
+        listeners = { connect: [], disconnect: [], error: [], notice: [] };
+        subListeners = {};
+        pubListeners = {};
         if (ws.readyState > 1)
           return Promise.resolve();
         ws.close();
@@ -8267,6 +8261,7 @@ zoo`.split("\n");
   var nip19_exports = {};
   __export(nip19_exports, {
     decode: () => decode,
+    naddrEncode: () => naddrEncode,
     neventEncode: () => neventEncode,
     noteEncode: () => noteEncode,
     nprofileEncode: () => nprofileEncode,
@@ -8278,38 +8273,64 @@ zoo`.split("\n");
   function decode(nip19) {
     let { prefix, words } = bech32.decode(nip19, Bech32MaxSize);
     let data = new Uint8Array(bech32.fromWords(words));
-    if (prefix === "nprofile") {
-      let tlv = parseTLV(data);
-      if (!tlv[0]?.[0])
-        throw new Error("missing TLV 0 for nprofile");
-      if (tlv[0][0].length !== 32)
-        throw new Error("TLV 0 should be 32 bytes");
-      return {
-        type: "nprofile",
-        data: {
-          pubkey: utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1].map((d) => utf8Decoder.decode(d))
-        }
-      };
-    }
-    if (prefix === "nevent") {
-      let tlv = parseTLV(data);
-      if (!tlv[0]?.[0])
-        throw new Error("missing TLV 0 for nevent");
-      if (tlv[0][0].length !== 32)
-        throw new Error("TLV 0 should be 32 bytes");
-      return {
-        type: "nevent",
-        data: {
-          id: utils.bytesToHex(tlv[0][0]),
-          relays: tlv[1].map((d) => utf8Decoder.decode(d))
-        }
-      };
-    }
-    if (prefix === "nsec" || prefix === "npub" || prefix === "note") {
-      return { type: prefix, data: utils.bytesToHex(data) };
+    switch (prefix) {
+      case "nprofile": {
+        let tlv = parseTLV(data);
+        if (!tlv[0]?.[0])
+          throw new Error("missing TLV 0 for nprofile");
+        if (tlv[0][0].length !== 32)
+          throw new Error("TLV 0 should be 32 bytes");
+        return {
+          type: "nprofile",
+          data: {
+            pubkey: utils.bytesToHex(tlv[0][0]),
+            relays: tlv[1].map((d) => utf8Decoder.decode(d))
+          }
+        };
+      }
+      case "nevent": {
+        let tlv = parseTLV(data);
+        if (!tlv[0]?.[0])
+          throw new Error("missing TLV 0 for nevent");
+        if (tlv[0][0].length !== 32)
+          throw new Error("TLV 0 should be 32 bytes");
+        return {
+          type: "nevent",
+          data: {
+            id: utils.bytesToHex(tlv[0][0]),
+            relays: tlv[1].map((d) => utf8Decoder.decode(d))
+          }
+        };
+      }
+      case "naddr": {
+        let tlv = parseTLV(data);
+        if (!tlv[0]?.[0])
+          throw new Error("missing TLV 0 for naddr");
+        if (!tlv[2]?.[0])
+          throw new Error("missing TLV 2 for naddr");
+        if (tlv[2][0].length !== 32)
+          throw new Error("TLV 2 should be 32 bytes");
+        if (!tlv[3]?.[0])
+          throw new Error("missing TLV 3 for naddr");
+        if (tlv[3][0].length !== 4)
+          throw new Error("TLV 3 should be 4 bytes");
+        return {
+          type: "naddr",
+          data: {
+            identifier: utf8Decoder.decode(tlv[0][0]),
+            pubkey: utils.bytesToHex(tlv[2][0]),
+            kind: parseInt(utils.bytesToHex(tlv[3][0]), 16),
+            relays: tlv[1].map((d) => utf8Decoder.decode(d))
+          }
+        };
+      }
+      case "nsec":
+      case "npub":
+      case "note":
+        return { type: prefix, data: utils.bytesToHex(data) };
+      default:
+        throw new Error(`unknown prefix ${prefix}`);
     }
-    throw new Error(`unknown prefix ${prefix}`);
   }
   function parseTLV(data) {
     let result = {};
@@ -8356,6 +8377,18 @@ zoo`.split("\n");
     let words = bech32.toWords(data);
     return bech32.encode("nevent", words, Bech32MaxSize);
   }
+  function naddrEncode(addr) {
+    let kind = new ArrayBuffer(4);
+    new DataView(kind).setUint32(0, addr.kind, false);
+    let data = encodeTLV({
+      0: [utf8Encoder.encode(addr.identifier)],
+      1: (addr.relays || []).map((url) => utf8Encoder.encode(url)),
+      2: [utils.hexToBytes(addr.pubkey)],
+      3: [new Uint8Array(kind)]
+    });
+    let words = bech32.toWords(data);
+    return bech32.encode("naddr", words, Bech32MaxSize);
+  }
   function encodeTLV(tlv) {
     let entries = [];
     Object.entries(tlv).forEach(([t, vs]) => {
@@ -8428,6 +8461,123 @@ zoo`.split("\n");
     return pubkey;
   }
 
+  // nip57.ts
+  var nip57_exports = {};
+  __export(nip57_exports, {
+    getZapEndpoint: () => getZapEndpoint,
+    makeZapReceipt: () => makeZapReceipt,
+    makeZapRequest: () => makeZapRequest,
+    useFetchImplementation: () => useFetchImplementation2,
+    validateZapRequest: () => validateZapRequest
+  });
+  init_define_process();
+  var _fetch2;
+  try {
+    _fetch2 = fetch;
+  } catch {
+  }
+  function useFetchImplementation2(fetchImplementation) {
+    _fetch2 = fetchImplementation;
+  }
+  async function getZapEndpoint(metadata) {
+    try {
+      let lnurl = "";
+      let { lud06, lud16 } = JSON.parse(metadata.content);
+      if (lud06) {
+        let { words } = bech32.decode(lud06, 1e3);
+        let data = bech32.fromWords(words);
+        lnurl = utf8Decoder.decode(data);
+      } else if (lud16) {
+        let [name, domain] = lud16.split("@");
+        lnurl = `https://${domain}/.well-known/lnurlp/${name}`;
+      } else {
+        return null;
+      }
+      let res = await _fetch2(lnurl);
+      let body = await res.json();
+      if (body.allowsNostr && body.nostrPubkey) {
+        return body.callback;
+      }
+    } catch (err) {
+    }
+    return null;
+  }
+  function makeZapRequest({
+    profile,
+    event,
+    amount,
+    relays,
+    comment = ""
+  }) {
+    if (!amount)
+      throw new Error("amount not given");
+    if (!profile)
+      throw new Error("profile not given");
+    let zr = {
+      kind: 9734,
+      created_at: Math.round(Date.now() / 1e3),
+      content: comment,
+      tags: [
+        ["p", profile],
+        ["amount", amount.toString()],
+        ["relays", ...relays]
+      ]
+    };
+    if (event) {
+      zr.tags.push(["e", event]);
+    }
+    return zr;
+  }
+  function validateZapRequest(zapRequestString) {
+    let zapRequest;
+    try {
+      zapRequest = JSON.parse(zapRequestString);
+    } catch (err) {
+      return "Invalid zap request JSON.";
+    }
+    if (!validateEvent(zapRequest))
+      return "Zap request is not a valid Nostr event.";
+    if (!verifySignature(zapRequest))
+      return "Invalid signature on zap request.";
+    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}$/))
+      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}$/))
+      return "Zap request 'e' tag is not valid hex.";
+    let relays = zapRequest.tags.find(([t, v]) => t === "relays" && v);
+    if (!relays)
+      return "Zap request doesn't have a 'relays' tag.";
+    return null;
+  }
+  function makeZapReceipt({
+    zapRequest,
+    preimage,
+    bolt11,
+    paidAt
+  }) {
+    let zr = JSON.parse(zapRequest);
+    let tagsFromZapRequest = zr.tags.filter(
+      ([t]) => t === "e" || t === "p" || t === "a"
+    );
+    let zap = {
+      kind: 9735,
+      created_at: Math.round(paidAt.getTime() / 1e3),
+      content: "",
+      tags: [
+        ...tagsFromZapRequest,
+        ["bolt11", bolt11],
+        ["description", zapRequest]
+      ]
+    };
+    if (preimage) {
+      zap.tags.push(["preimage", preimage]);
+    }
+    return zap;
+  }
+
   // node_modules/@noble/hashes/esm/hmac.js
   init_define_process();
   var HMAC2 = class extends Hash {