nostr-tools 2.11.0 → 2.12.0

package/README.md

@@ -57,43 +57,43 @@ let event = finalizeEvent({
 let isGood = verifyEvent(event)
 ```
 
-### Interacting with a relay
+### Interacting with one or multiple relays
+
+Doesn't matter what you do, you always should be using a `SimplePool`:
 
 ```js
 import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure'
-import { Relay } from 'nostr-tools/relay'
+import { SimplePool } from 'nostr-tools/pool'
 
-const relay = await Relay.connect('wss://relay.example.com')
-console.log(`connected to ${relay.url}`)
+const pool = new SimplePool()
 
 // let's query for an event that exists
-const sub = relay.subscribe([
+const event = relay.get(
+  ['wss://relay.example.com'],
   {
     ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
   },
-], {
-  onevent(event) {
-    console.log('we got the event we wanted:', event)
-  },
-  oneose() {
-    sub.close()
-  }
-})
+)
+if (event) {
+  console.log('it exists indeed on this relay:', event)
+}
 
 // let's publish a new event while simultaneously monitoring the relay for it
 let sk = generateSecretKey()
 let pk = getPublicKey(sk)
 
-relay.subscribe([
+pool.subscribe(
+  ['wss://a.com', 'wss://b.com', 'wss://c.com'],
   {
     kinds: [1],
     authors: [pk],
   },
-], {
-  onevent(event) {
-    console.log('got event:', event)
+  {
+    onevent(event) {
+      console.log('got event:', event)
+    }
   }
-})
+)
 
 let eventTemplate = {
   kind: 1,
@@ -104,7 +104,7 @@ let eventTemplate = {
 
 // this assigns the pubkey, calculates the event id and signs the event in a single step
 const signedEvent = finalizeEvent(eventTemplate, sk)
-await relay.publish(signedEvent)
+await pool.publish(['wss://a.com', 'wss://b.com'], signedEvent)
 
 relay.close()
 ```
@@ -119,59 +119,116 @@ import WebSocket from 'ws'
 useWebSocketImplementation(WebSocket)
 ```
 
-### Interacting with multiple relays
+### Parsing references (mentions) from a content based on NIP-27
 
 ```js
-import { SimplePool } from 'nostr-tools/pool'
+import * as nip27 from '@nostr/tools/nip27'
+
+for (let block of nip27.parse(evt.content)) {
+  switch (block.type) {
+    case 'text':
+      console.log(block.text)
+      break
+    case 'reference': {
+      if ('id' in block.pointer) {
+        console.log("it's a nevent1 uri", block.pointer)
+      } else if ('identifier' in block.pointer) {
+        console.log("it's a naddr1 uri", block.pointer)
+      } else {
+        console.log("it's an npub1 or nprofile1 uri", block.pointer)
+      }
+      break
+    }
+    case 'url': {
+      console.log("it's a normal url:", block.url)
+      break
+    }
+    case 'image':
+    case 'video':
+    case 'audio':
+      console.log("it's a media url:", block.url)
+    case 'relay':
+      console.log("it's a websocket url, probably a relay address:", block.url)
+    default:
+      break
+  }
+}
+```
 
-const pool = new SimplePool()
+### Connecting to a bunker using NIP-46
 
-let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
+```js
+import { generateSecretKey, getPublicKey } from '@nostr/tools/pure'
+import { BunkerSigner, parseBunkerInput } from '@nostr/tools/nip46'
+import { SimplePool } from '@nostr/tools/pool'
 
-let h = pool.subscribeMany(
-  [...relays, 'wss://relay.example3.com'],
-  [
-    {
-      authors: ['32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'],
-    },
-  ],
-  {
-    onevent(event) {
-      // this will only be called once the first time the event is received
-      // ...
-    },
-    oneose() {
-      h.close()
-    }
-  }
-)
+// the client needs a local secret key (which is generally persisted) for communicating with the bunker
+const localSecretKey = generateSecretKey()
 
-await Promise.any(pool.publish(relays, newEvent))
-console.log('published to at least one relay!')
+// parse a bunker URI
+const bunkerPointer = await parseBunkerInput('bunker://abcd...?relay=wss://relay.example.com')
+if (!bunkerPointer) {
+  throw new Error('Invalid bunker input')
+}
 
-let events = await pool.querySync(relays, { kinds: [0, 1] })
-let event = await pool.get(relays, {
-  ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'],
+// create the bunker instance
+const pool = new SimplePool()
+const bunker = new BunkerSigner(localSecretKey, bunkerPointer, { pool })
+await bunker.connect()
+
+// and use it
+const pubkey = await bunker.getPublicKey()
+const event = await bunker.signEvent({
+  kind: 1,
+  created_at: Math.floor(Date.now() / 1000),
+  tags: [],
+  content: 'Hello from bunker!'
 })
+
+// cleanup
+await signer.close()
+pool.close([])
 ```
 
-### Parsing references (mentions) from a content using NIP-10 and NIP-27
+### Parsing thread from any note based on NIP-10
 
 ```js
-import { parseReferences } from 'nostr-tools/references'
-
-let references = parseReferences(event)
-let simpleAugmentedContent = event.content
-for (let i = 0; i < references.length; i++) {
-  let { text, profile, event, address } = references[i]
-  let augmentedReference = profile
-    ? `<strong>@${profilesCache[profile.pubkey].name}</strong>`
-    : event
-    ? `<em>${eventsCache[event.id].content.slice(0, 5)}</em>`
-    : address
-    ? `<a href="${text}">[link]</a>`
-    : text
-  simpleAugmentedContent.replaceAll(text, augmentedReference)
+import * as nip10 from '@nostr/tools/nip10'
+
+// event is a nostr event with tags
+const refs = nip10.parse(event)
+
+// get the root event of the thread
+if (refs.root) {
+  console.log('root event:', refs.root.id)
+  console.log('root event relay hints:', refs.root.relays)
+  console.log('root event author:', refs.root.author)
+}
+
+// get the immediate parent being replied to
+if (refs.reply) {
+  console.log('reply to:', refs.reply.id)
+  console.log('reply relay hints:', refs.reply.relays)
+  console.log('reply author:', refs.reply.author)
+}
+
+// get any mentioned events
+for (let mention of refs.mentions) {
+  console.log('mentioned event:', mention.id)
+  console.log('mention relay hints:', mention.relays)
+  console.log('mention author:', mention.author)
+}
+
+// get any quoted events
+for (let quote of refs.quotes) {
+  console.log('quoted event:', quote.id)
+  console.log('quote relay hints:', quote.relays)
+}
+
+// get any referenced profiles
+for (let profile of refs.profiles) {
+  console.log('referenced profile:', profile.pubkey)
+  console.log('profile relay hints:', profile.relays)
 }
 ```
 
@@ -205,32 +262,6 @@ declare global {
 }
 ```
 
-
-### Generating NIP-06 keys
-```js
-import {
-  privateKeyFromSeedWords,
-  accountFromSeedWords,
-  extendedKeysFromSeedWords,
-  accountFromExtendedKey
-} from 'nostr-tools/nip06'
-
-const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
-const passphrase = '123' // optional
-const accountIndex = 0
-const sk0 = privateKeyFromSeedWords(mnemonic, passphrase, accountIndex)
-
-const { privateKey: sk1, publicKey: pk1 } = accountFromSeedWords(mnemonic, passphrase, accountIndex)
-
-const extendedAccountIndex = 0
-
-const { privateExtendedKey, publicExtendedKey } = extendedKeysFromSeedWords(mnemonic, passphrase, extendedAccountIndex)
-
-const { privateKey: sk2, publicKey: pk2 } = accountFromExtendedKey(privateExtendedKey)
-
-const { publicKey: pk3 } = accountFromExtendedKey(publicExtendedKey)
-```
-
 ### Encoding and decoding NIP-19 codes
 
 ```js

package/lib/cjs/abstract-pool.js

@@ -198,6 +198,7 @@ var AbstractRelay = class {
   incomingMessageQueue = new Queue();
   queueRunning = false;
   challenge;
+  authPromise;
   serial = 0;
   verifyEvent;
   _WebSocket;
@@ -232,6 +233,7 @@ var AbstractRelay = class {
     if (this.connectionPromise)
       return this.connectionPromise;
     this.challenge = void 0;
+    this.authPromise = void 0;
     this.connectionPromise = new Promise((resolve, reject) => {
       this.connectionTimeoutHandle = setTimeout(() => {
         reject("connection timed out");
@@ -356,6 +358,7 @@ var AbstractRelay = class {
           return;
         case "AUTH": {
           this.challenge = data[1];
+          this.authPromise = void 0;
           this._onauth?.(data[1]);
           return;
         }
@@ -374,8 +377,10 @@ var AbstractRelay = class {
   async auth(signAuthEvent) {
     if (!this.challenge)
       throw new Error("can't perform auth, no challenge was received");
+    if (this.authPromise)
+      return this.authPromise;
     const evt = await signAuthEvent(makeAuthEvent(this.url, this.challenge));
-    const ret = new Promise((resolve, reject) => {
+    this.authPromise = new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         const ep = this.openEventPublishes.get(evt.id);
         if (ep) {
@@ -386,7 +391,7 @@ var AbstractRelay = class {
       this.openEventPublishes.set(evt.id, { resolve, reject, timeout });
     });
     this.send('["AUTH",' + JSON.stringify(evt) + "]");
-    return ret;
+    return this.authPromise;
   }
   async publish(event) {
     const ret = new Promise((resolve, reject) => {
@@ -517,8 +522,110 @@ var AbstractSimplePool = class {
       this.relays.get(url)?.close();
     });
   }
+  subscribe(relays, filter, params) {
+    return this.subscribeMap(
+      relays.map((url) => ({ url, filter })),
+      params
+    );
+  }
   subscribeMany(relays, filters, params) {
-    return this.subscribeManyMap(Object.fromEntries(relays.map((url) => [url, filters])), params);
+    return this.subscribeMap(
+      relays.flatMap((url) => filters.map((filter) => ({ url, filter }))),
+      params
+    );
+  }
+  subscribeMap(requests, params) {
+    if (this.trackRelays) {
+      params.receivedEvent = (relay, id) => {
+        let set = this.seenOn.get(id);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          this.seenOn.set(id, set);
+        }
+        set.add(relay);
+      };
+    }
+    const _knownIds = /* @__PURE__ */ new Set();
+    const subs = [];
+    const eosesReceived = [];
+    let handleEose = (i) => {
+      if (eosesReceived[i])
+        return;
+      eosesReceived[i] = true;
+      if (eosesReceived.filter((a) => a).length === requests.length) {
+        params.oneose?.();
+        handleEose = () => {
+        };
+      }
+    };
+    const closesReceived = [];
+    let handleClose = (i, reason) => {
+      if (closesReceived[i])
+        return;
+      handleEose(i);
+      closesReceived[i] = reason;
+      if (closesReceived.filter((a) => a).length === requests.length) {
+        params.onclose?.(closesReceived);
+        handleClose = () => {
+        };
+      }
+    };
+    const localAlreadyHaveEventHandler = (id) => {
+      if (params.alreadyHaveEvent?.(id)) {
+        return true;
+      }
+      const have = _knownIds.has(id);
+      _knownIds.add(id);
+      return have;
+    };
+    const allOpened = Promise.all(
+      requests.map(async ({ url, filter }, i) => {
+        url = normalizeURL(url);
+        let relay;
+        try {
+          relay = await this.ensureRelay(url, {
+            connectionTimeout: params.maxWait ? Math.max(params.maxWait * 0.8, params.maxWait - 1e3) : void 0
+          });
+        } catch (err) {
+          handleClose(i, err?.message || String(err));
+          return;
+        }
+        let subscription = relay.subscribe([filter], {
+          ...params,
+          oneose: () => handleEose(i),
+          onclose: (reason) => {
+            if (reason.startsWith("auth-required:") && params.doauth) {
+              relay.auth(params.doauth).then(() => {
+                relay.subscribe([filter], {
+                  ...params,
+                  oneose: () => handleEose(i),
+                  onclose: (reason2) => {
+                    handleClose(i, reason2);
+                  },
+                  alreadyHaveEvent: localAlreadyHaveEventHandler,
+                  eoseTimeout: params.maxWait
+                });
+              }).catch((err) => {
+                handleClose(i, `auth was required and attempted, but failed with: ${err}`);
+              });
+            } else {
+              handleClose(i, reason);
+            }
+          },
+          alreadyHaveEvent: localAlreadyHaveEventHandler,
+          eoseTimeout: params.maxWait
+        });
+        subs.push(subscription);
+      })
+    );
+    return {
+      async close() {
+        await allOpened;
+        subs.forEach((sub) => {
+          sub.close();
+        });
+      }
+    };
   }
   subscribeManyMap(requests, params) {
     if (this.trackRelays) {
@@ -585,7 +692,25 @@ var AbstractSimplePool = class {
         let subscription = relay.subscribe(filters, {
           ...params,
           oneose: () => handleEose(i),
-          onclose: (reason) => handleClose(i, reason),
+          onclose: (reason) => {
+            if (reason.startsWith("auth-required:") && params.doauth) {
+              relay.auth(params.doauth).then(() => {
+                relay.subscribe(filters, {
+                  ...params,
+                  oneose: () => handleEose(i),
+                  onclose: (reason2) => {
+                    handleClose(i, reason2);
+                  },
+                  alreadyHaveEvent: localAlreadyHaveEventHandler,
+                  eoseTimeout: params.maxWait
+                });
+              }).catch((err) => {
+                handleClose(i, `auth was required and attempted, but failed with: ${err}`);
+              });
+            } else {
+              handleClose(i, reason);
+            }
+          },
           alreadyHaveEvent: localAlreadyHaveEventHandler,
           eoseTimeout: params.maxWait
         });
@@ -601,6 +726,15 @@ var AbstractSimplePool = class {
       }
     };
   }
+  subscribeEose(relays, filter, params) {
+    const subcloser = this.subscribe(relays, filter, {
+      ...params,
+      oneose() {
+        subcloser.close();
+      }
+    });
+    return subcloser;
+  }
   subscribeManyEose(relays, filters, params) {
     const subcloser = this.subscribeMany(relays, filters, {
       ...params,
@@ -613,7 +747,7 @@ var AbstractSimplePool = class {
   async querySync(relays, filter, params) {
     return new Promise(async (resolve) => {
       const events = [];
-      this.subscribeManyEose(relays, [filter], {
+      this.subscribeEose(relays, filter, {
         ...params,
         onevent(event) {
           events.push(event);