nostr-tools 2.22.0 → 2.23.0

package/lib/cjs/abstract-pool.js

@@ -52,54 +52,6 @@ function normalizeURL(url) {
     throw new Error(`Invalid URL: ${url}`);
   }
 }
-var QueueNode = class {
-  value;
-  next = null;
-  prev = null;
-  constructor(message) {
-    this.value = message;
-  }
-};
-var Queue = class {
-  first;
-  last;
-  constructor() {
-    this.first = null;
-    this.last = null;
-  }
-  enqueue(value) {
-    const newNode = new QueueNode(value);
-    if (!this.last) {
-      this.first = newNode;
-      this.last = newNode;
-    } else if (this.last === this.first) {
-      this.last = newNode;
-      this.last.prev = this.first;
-      this.first.next = newNode;
-    } else {
-      newNode.prev = this.last;
-      this.last.next = newNode;
-      this.last = newNode;
-    }
-    return true;
-  }
-  dequeue() {
-    if (!this.first)
-      return null;
-    if (this.first === this.last) {
-      const target2 = this.first;
-      this.first = null;
-      this.last = null;
-      return target2.value;
-    }
-    const target = this.first;
-    this.first = target.next;
-    if (this.first) {
-      this.first.prev = null;
-    }
-    return target.value;
-  }
-};
 
 // kinds.ts
 var ClientAuth = 22242;
@@ -173,39 +125,6 @@ function makeAuthEvent(relayURL, challenge) {
   };
 }
 
-// helpers.ts
-async function yieldThread() {
-  return new Promise((resolve, reject) => {
-    try {
-      if (typeof MessageChannel !== "undefined") {
-        const ch = new MessageChannel();
-        const handler = () => {
-          ch.port1.removeEventListener("message", handler);
-          resolve();
-        };
-        ch.port1.addEventListener("message", handler);
-        ch.port2.postMessage(0);
-        ch.port1.start();
-      } else {
-        if (typeof setImmediate !== "undefined") {
-          setImmediate(resolve);
-        } else if (typeof setTimeout !== "undefined") {
-          setTimeout(resolve, 0);
-        } else {
-          resolve();
-        }
-      }
-    } catch (e) {
-      console.error("during yield: ", e);
-      reject(e);
-    }
-  });
-}
-var alwaysTrue = (t) => {
-  t[verifiedSymbol] = true;
-  return true;
-};
-
 // abstract-relay.ts
 var SendingOnClosedConnection = class extends Error {
   constructor(message, relay) {
@@ -227,16 +146,16 @@ var AbstractRelay = class {
   openSubs = /* @__PURE__ */ new Map();
   enablePing;
   enableReconnect;
+  idleSince = Date.now();
+  ongoingOperations = 0;
   reconnectTimeoutHandle;
   pingIntervalHandle;
   reconnectAttempts = 0;
-  closedIntentionally = false;
+  skipReconnection = false;
   connectionPromise;
   openCountRequests = /* @__PURE__ */ new Map();
   openEventPublishes = /* @__PURE__ */ new Map();
   ws;
-  incomingMessageQueue = new Queue();
-  queueRunning = false;
   challenge;
   authPromise;
   serial = 0;
@@ -288,12 +207,11 @@ var AbstractRelay = class {
     }
     this._connected = false;
     this.connectionPromise = void 0;
-    const wasIntentional = this.closedIntentionally;
-    this.closedIntentionally = false;
-    this.onclose?.();
-    if (this.enableReconnect && !wasIntentional) {
+    this.idleSince = void 0;
+    if (this.enableReconnect && !this.skipReconnection) {
       this.reconnect();
     } else {
+      this.onclose?.();
       this.closeAllSubscriptions(reason);
     }
   }
@@ -303,13 +221,15 @@ var AbstractRelay = class {
       return this.connectionPromise;
     this.challenge = void 0;
     this.authPromise = void 0;
+    this.skipReconnection = false;
     this.connectionPromise = new Promise((resolve, reject) => {
       if (opts?.timeout) {
         connectionTimeoutHandle = setTimeout(() => {
           reject("connection timed out");
           this.connectionPromise = void 0;
+          this.skipReconnection = true;
           this.onclose?.();
-          this.closeAllSubscriptions("relay connection timed out");
+          this.handleHardClose("relay connection timed out");
         }, opts.timeout);
       }
       if (opts?.abort) {
@@ -347,10 +267,13 @@ var AbstractRelay = class {
         }
         resolve();
       };
-      this.ws.onerror = (ev) => {
+      this.ws.onerror = () => {
         clearTimeout(connectionTimeoutHandle);
-        reject(ev.message || "websocket error");
-        this.handleHardClose("relay connection errored");
+        reject("connection failed");
+        this.connectionPromise = void 0;
+        this.skipReconnection = true;
+        this.onclose?.();
+        this.handleHardClose("relay connection failed");
       };
       this.ws.onclose = (ev) => {
         clearTimeout(connectionTimeoutHandle);
@@ -376,7 +299,7 @@ var AbstractRelay = class {
         const sub = this.subscribe(
           [{ ids: ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], limit: 0 }],
           {
-            label: "forced-ping",
+            label: "<forced-ping>",
             oneose: () => {
               resolve(true);
               sub.close();
@@ -405,20 +328,106 @@ var AbstractRelay = class {
       }
     }
   }
-  async runQueue() {
-    this.queueRunning = true;
-    while (true) {
-      if (false === this.handleNext()) {
-        break;
+  async send(message) {
+    if (!this.connectionPromise)
+      throw new SendingOnClosedConnection(message, this.url);
+    this.connectionPromise.then(() => {
+      this.ws?.send(message);
+    });
+  }
+  async auth(signAuthEvent) {
+    const challenge = this.challenge;
+    if (!challenge)
+      throw new Error("can't perform auth, no challenge was received");
+    if (this.authPromise)
+      return this.authPromise;
+    this.authPromise = new Promise(async (resolve, reject) => {
+      try {
+        let evt = await signAuthEvent(makeAuthEvent(this.url, challenge));
+        let timeout = setTimeout(() => {
+          let ep = this.openEventPublishes.get(evt.id);
+          if (ep) {
+            ep.reject(new Error("auth timed out"));
+            this.openEventPublishes.delete(evt.id);
+          }
+        }, this.publishTimeout);
+        this.openEventPublishes.set(evt.id, { resolve, reject, timeout });
+        this.send('["AUTH",' + JSON.stringify(evt) + "]");
+      } catch (err) {
+        console.warn("subscribe auth function failed:", err);
       }
-      await yieldThread();
+    });
+    return this.authPromise;
+  }
+  async publish(event) {
+    this.idleSince = void 0;
+    this.ongoingOperations++;
+    const ret = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const ep = this.openEventPublishes.get(event.id);
+        if (ep) {
+          ep.reject(new Error("publish timed out"));
+          this.openEventPublishes.delete(event.id);
+        }
+      }, this.publishTimeout);
+      this.openEventPublishes.set(event.id, { resolve, reject, timeout });
+    });
+    this.send('["EVENT",' + JSON.stringify(event) + "]");
+    this.ongoingOperations--;
+    if (this.ongoingOperations === 0)
+      this.idleSince = Date.now();
+    return ret;
+  }
+  async count(filters, params) {
+    this.serial++;
+    const id = params?.id || "count:" + this.serial;
+    const ret = new Promise((resolve, reject) => {
+      this.openCountRequests.set(id, { resolve, reject });
+    });
+    this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
+    return ret;
+  }
+  subscribe(filters, params) {
+    if (params.label !== "<forced-ping>") {
+      this.idleSince = void 0;
+      this.ongoingOperations++;
+    }
+    const sub = this.prepareSubscription(filters, params);
+    sub.fire();
+    if (params.abort) {
+      params.abort.onabort = () => sub.close(String(params.abort.reason || "<aborted>"));
     }
-    this.queueRunning = false;
+    return sub;
   }
-  handleNext() {
-    const json = this.incomingMessageQueue.dequeue();
+  prepareSubscription(filters, params) {
+    this.serial++;
+    const id = params.id || (params.label ? params.label + ":" : "sub:") + this.serial;
+    const sub = new Subscription(this, id, filters, params);
+    this.openSubs.set(id, sub);
+    return sub;
+  }
+  close() {
+    this.skipReconnection = true;
+    if (this.reconnectTimeoutHandle) {
+      clearTimeout(this.reconnectTimeoutHandle);
+      this.reconnectTimeoutHandle = void 0;
+    }
+    if (this.pingIntervalHandle) {
+      clearInterval(this.pingIntervalHandle);
+      this.pingIntervalHandle = void 0;
+    }
+    this.closeAllSubscriptions("relay connection closed by us");
+    this._connected = false;
+    this.idleSince = void 0;
+    this.onclose?.();
+    if (this.ws?.readyState === this._WebSocket.OPEN) {
+      this.ws?.close();
+    }
+  }
+  _onmessage(ev) {
+    const json = ev.data;
     if (!json) {
-      return false;
+      return;
     }
     const subid = getSubscriptionId(json);
     if (subid) {
@@ -505,101 +514,11 @@ var AbstractRelay = class {
         }
       }
     } catch (err) {
+      const [_, __, event] = JSON.parse(json);
+      window.printer.maybe(event.pubkey, ":: caught err", event, this.url, err);
       return;
     }
   }
-  async send(message) {
-    if (!this.connectionPromise)
-      throw new SendingOnClosedConnection(message, this.url);
-    this.connectionPromise.then(() => {
-      this.ws?.send(message);
-    });
-  }
-  async auth(signAuthEvent) {
-    const challenge = this.challenge;
-    if (!challenge)
-      throw new Error("can't perform auth, no challenge was received");
-    if (this.authPromise)
-      return this.authPromise;
-    this.authPromise = new Promise(async (resolve, reject) => {
-      try {
-        let evt = await signAuthEvent(makeAuthEvent(this.url, challenge));
-        let timeout = setTimeout(() => {
-          let ep = this.openEventPublishes.get(evt.id);
-          if (ep) {
-            ep.reject(new Error("auth timed out"));
-            this.openEventPublishes.delete(evt.id);
-          }
-        }, this.publishTimeout);
-        this.openEventPublishes.set(evt.id, { resolve, reject, timeout });
-        this.send('["AUTH",' + JSON.stringify(evt) + "]");
-      } catch (err) {
-        console.warn("subscribe auth function failed:", err);
-      }
-    });
-    return this.authPromise;
-  }
-  async publish(event) {
-    const ret = new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        const ep = this.openEventPublishes.get(event.id);
-        if (ep) {
-          ep.reject(new Error("publish timed out"));
-          this.openEventPublishes.delete(event.id);
-        }
-      }, this.publishTimeout);
-      this.openEventPublishes.set(event.id, { resolve, reject, timeout });
-    });
-    this.send('["EVENT",' + JSON.stringify(event) + "]");
-    return ret;
-  }
-  async count(filters, params) {
-    this.serial++;
-    const id = params?.id || "count:" + this.serial;
-    const ret = new Promise((resolve, reject) => {
-      this.openCountRequests.set(id, { resolve, reject });
-    });
-    this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
-    return ret;
-  }
-  subscribe(filters, params) {
-    const sub = this.prepareSubscription(filters, params);
-    sub.fire();
-    if (params.abort) {
-      params.abort.onabort = () => sub.close(String(params.abort.reason || "<aborted>"));
-    }
-    return sub;
-  }
-  prepareSubscription(filters, params) {
-    this.serial++;
-    const id = params.id || (params.label ? params.label + ":" : "sub:") + this.serial;
-    const subscription = new Subscription(this, id, filters, params);
-    this.openSubs.set(id, subscription);
-    return subscription;
-  }
-  close() {
-    this.closedIntentionally = true;
-    if (this.reconnectTimeoutHandle) {
-      clearTimeout(this.reconnectTimeoutHandle);
-      this.reconnectTimeoutHandle = void 0;
-    }
-    if (this.pingIntervalHandle) {
-      clearInterval(this.pingIntervalHandle);
-      this.pingIntervalHandle = void 0;
-    }
-    this.closeAllSubscriptions("relay connection closed by us");
-    this._connected = false;
-    this.onclose?.();
-    if (this.ws?.readyState === this._WebSocket.OPEN) {
-      this.ws?.close();
-    }
-  }
-  _onmessage(ev) {
-    this.incomingMessageQueue.enqueue(ev.data);
-    if (!this.queueRunning) {
-      this.runQueue();
-    }
-  }
 };
 var Subscription = class {
   relay;
@@ -658,10 +577,19 @@ var Subscription = class {
       this.closed = true;
     }
     this.relay.openSubs.delete(this.id);
+    this.relay.ongoingOperations--;
+    if (this.relay.ongoingOperations === 0)
+      this.relay.idleSince = Date.now();
     this.onclose?.(reason);
   }
 };
 
+// helpers.ts
+var alwaysTrue = (t) => {
+  t[verifiedSymbol] = true;
+  return true;
+};
+
 // abstract-pool.ts
 var AbstractSimplePool = class {
   relays = /* @__PURE__ */ new Map();
@@ -672,6 +600,10 @@ var AbstractSimplePool = class {
   enableReconnect;
   automaticallyAuth;
   trustedRelayURLs = /* @__PURE__ */ new Set();
+  onRelayConnectionFailure;
+  onRelayConnectionSuccess;
+  allowConnectingToRelay;
+  maxWaitForConnection;
   _WebSocket;
   constructor(opts) {
     this.verifyEvent = opts.verifyEvent;
@@ -679,6 +611,10 @@ var AbstractSimplePool = class {
     this.enablePing = opts.enablePing;
     this.enableReconnect = opts.enableReconnect || false;
     this.automaticallyAuth = opts.automaticallyAuth;
+    this.onRelayConnectionFailure = opts.onRelayConnectionFailure;
+    this.onRelayConnectionSuccess = opts.onRelayConnectionSuccess;
+    this.allowConnectingToRelay = opts.allowConnectingToRelay;
+    this.maxWaitForConnection = opts.maxWaitForConnection || 3e3;
   }
   async ensureRelay(url, params) {
     url = normalizeURL(url);
@@ -691,9 +627,7 @@ var AbstractSimplePool = class {
         enableReconnect: this.enableReconnect
       });
       relay.onclose = () => {
-        if (relay && !relay.enableReconnect) {
-          this.relays.delete(url);
-        }
+        this.relays.delete(url);
       };
       this.relays.set(url, relay);
     }
@@ -703,10 +637,15 @@ var AbstractSimplePool = class {
         relay.onauth = authSignerFn;
       }
     }
-    await relay.connect({
-      timeout: params?.connectionTimeout,
-      abort: params?.abort
-    });
+    try {
+      await relay.connect({
+        timeout: params?.connectionTimeout,
+        abort: params?.abort
+      });
+    } catch (err) {
+      this.relays.delete(url);
+      throw err;
+    }
     return relay;
   }
   close(relays) {
@@ -717,25 +656,20 @@ var AbstractSimplePool = class {
   }
   subscribe(relays, filter, params) {
     const request = [];
+    const uniqUrls = [];
     for (let i = 0; i < relays.length; i++) {
       const url = normalizeURL(relays[i]);
       if (!request.find((r) => r.url === url)) {
-        request.push({ url, filter });
+        if (uniqUrls.indexOf(url) === -1) {
+          uniqUrls.push(url);
+          request.push({ url, filter });
+        }
       }
     }
     return this.subscribeMap(request, params);
   }
   subscribeMany(relays, filter, params) {
-    const request = [];
-    const uniqUrls = [];
-    for (let i = 0; i < relays.length; i++) {
-      const url = normalizeURL(relays[i]);
-      if (uniqUrls.indexOf(url) === -1) {
-        uniqUrls.push(url);
-        request.push({ url, filter });
-      }
-    }
-    return this.subscribeMap(request, params);
+    return this.subscribe(relays, filter, params);
   }
   subscribeMap(requests, params) {
     const grouped = /* @__PURE__ */ new Map();
@@ -791,16 +725,22 @@ var AbstractSimplePool = class {
     };
     const allOpened = Promise.all(
       groupedRequests.map(async ({ url, filters }, i) => {
+        if (this.allowConnectingToRelay?.(url, ["read", filters]) === false) {
+          handleClose(i, "connection skipped by allowConnectingToRelay");
+          return;
+        }
         let relay;
         try {
           relay = await this.ensureRelay(url, {
-            connectionTimeout: params.maxWait ? Math.max(params.maxWait * 0.8, params.maxWait - 1e3) : void 0,
+            connectionTimeout: this.maxWaitForConnection < (params.maxWait || 0) ? Math.max(params.maxWait * 0.8, params.maxWait - 1e3) : this.maxWaitForConnection,
             abort: params.abort
           });
         } catch (err) {
+          this.onRelayConnectionFailure?.(url);
           handleClose(i, err?.message || String(err));
           return;
         }
+        this.onRelayConnectionSuccess?.(url);
         let subscription = relay.subscribe(filters, {
           ...params,
           oneose: () => handleEose(i),
@@ -850,13 +790,7 @@ var AbstractSimplePool = class {
     return subcloser;
   }
   subscribeManyEose(relays, filter, params) {
-    const subcloser = this.subscribeMany(relays, filter, {
-      ...params,
-      oneose() {
-        subcloser.close("closed automatically on eose");
-      }
-    });
-    return subcloser;
+    return this.subscribeEose(relays, filter, params);
   }
   async querySync(relays, filter, params) {
     return new Promise(async (resolve) => {
@@ -878,15 +812,27 @@ var AbstractSimplePool = class {
     events.sort((a, b) => b.created_at - a.created_at);
     return events[0] || null;
   }
-  publish(relays, event, options) {
+  publish(relays, event, params) {
     return relays.map(normalizeURL).map(async (url, i, arr) => {
       if (arr.indexOf(url) !== i) {
         return Promise.reject("duplicate url");
       }
-      let r = await this.ensureRelay(url);
+      if (this.allowConnectingToRelay?.(url, ["write", event]) === false) {
+        return Promise.reject("connection skipped by allowConnectingToRelay");
+      }
+      let r;
+      try {
+        r = await this.ensureRelay(url, {
+          connectionTimeout: this.maxWaitForConnection < (params?.maxWait || 0) ? Math.max(params.maxWait * 0.8, params.maxWait - 1e3) : this.maxWaitForConnection,
+          abort: params?.abort
+        });
+      } catch (err) {
+        this.onRelayConnectionFailure?.(url);
+        return String("connection failure: " + String(err));
+      }
       return r.publish(event).catch(async (err) => {
-        if (err instanceof Error && err.message.startsWith("auth-required: ") && options?.onauth) {
-          await r.auth(options.onauth);
+        if (err instanceof Error && err.message.startsWith("auth-required: ") && params?.onauth) {
+          await r.auth(params.onauth);
           return r.publish(event);
         }
         throw err;
@@ -912,4 +858,15 @@ var AbstractSimplePool = class {
     this.relays.forEach((conn) => conn.close());
     this.relays = /* @__PURE__ */ new Map();
   }
+  pruneIdleRelays(idleThresholdMs = 1e4) {
+    const prunedUrls = [];
+    for (const [url, relay] of this.relays) {
+      if (relay.idleSince && Date.now() - relay.idleSince >= idleThresholdMs) {
+        this.relays.delete(url);
+        prunedUrls.push(url);
+        relay.close();
+      }
+    }
+    return prunedUrls;
+  }
 };