nostr-tools 2.23.8 → 2.23.11

package/lib/cjs/nip46.js

@@ -372,12 +372,14 @@ var AbstractRelay = class {
   openSubs = /* @__PURE__ */ new Map();
   enablePing;
   enableReconnect;
+  idleTimeout = 0;
   idleSince = Date.now();
   ongoingOperations = 0;
   reconnectTimeoutHandle;
   pingIntervalHandle;
   reconnectAttempts = 0;
   skipReconnection = false;
+  idleTimeoutHandle;
   connectionPromise;
   openCountRequests = /* @__PURE__ */ new Map();
   openEventPublishes = /* @__PURE__ */ new Map();
@@ -393,6 +395,8 @@ var AbstractRelay = class {
     this._WebSocket = opts.websocketImplementation || WebSocket;
     this.enablePing = opts.enablePing;
     this.enableReconnect = opts.enableReconnect || false;
+    if (opts.idleTimeout)
+      this.idleTimeout = opts.idleTimeout;
   }
   static async connect(url, opts) {
     const relay = new AbstractRelay(url, opts);
@@ -416,6 +420,22 @@ var AbstractRelay = class {
   get connected() {
     return this._connected;
   }
+  clearIdleTimeout() {
+    if (this.idleTimeoutHandle) {
+      clearTimeout(this.idleTimeoutHandle);
+      this.idleTimeoutHandle = void 0;
+    }
+  }
+  scheduleIdleClose() {
+    this.clearIdleTimeout();
+    if (this.idleTimeout > 0) {
+      this.idleTimeoutHandle = setTimeout(() => {
+        if (this.ongoingOperations === 0 && this.idleSince) {
+          this.close();
+        }
+      }, this.idleTimeout);
+    }
+  }
   async reconnect() {
     const backoff = this.resubscribeBackoff[Math.min(this.reconnectAttempts, this.resubscribeBackoff.length - 1)];
     this.reconnectAttempts++;
@@ -434,6 +454,7 @@ var AbstractRelay = class {
     this._connected = false;
     this.connectionPromise = void 0;
     this.idleSince = void 0;
+    this.clearIdleTimeout();
     if (this.enableReconnect && !this.skipReconnection) {
       this.reconnect();
     } else {
@@ -591,6 +612,7 @@ var AbstractRelay = class {
   }
   async publish(event) {
     this.idleSince = void 0;
+    this.clearIdleTimeout();
     this.ongoingOperations++;
     const ret = new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -602,24 +624,46 @@ var AbstractRelay = class {
       }, this.publishTimeout);
       this.openEventPublishes.set(event.id, { resolve, reject, timeout });
     });
-    this.send('["EVENT",' + JSON.stringify(event) + "]");
+    try {
+      await this.send('["EVENT",' + JSON.stringify(event) + "]");
+    } catch (err) {
+      const ep = this.openEventPublishes.get(event.id);
+      if (ep) {
+        ep.reject(err);
+        this.openEventPublishes.delete(event.id);
+      }
+    }
     this.ongoingOperations--;
-    if (this.ongoingOperations === 0)
+    if (this.ongoingOperations === 0) {
       this.idleSince = Date.now();
+      this.scheduleIdleClose();
+    }
     return ret;
   }
   async count(filters, params) {
+    return (await this.countWithHLL(filters, params)).count;
+  }
+  async countWithHLL(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));
+    try {
+      await this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
+    } catch (err) {
+      const cr = this.openCountRequests.get(id);
+      if (cr) {
+        cr.reject(err);
+        this.openCountRequests.delete(id);
+      }
+    }
     return ret;
   }
   subscribe(filters, params) {
     if (params.label !== "<forced-ping>") {
       this.idleSince = void 0;
+      this.clearIdleTimeout();
       this.ongoingOperations++;
     }
     const sub = this.prepareSubscription(filters, params);
@@ -649,6 +693,7 @@ var AbstractRelay = class {
     this.closeAllSubscriptions("relay connection closed by us");
     this._connected = false;
     this.idleSince = void 0;
+    this.clearIdleTimeout();
     this.onclose?.();
     if (this.ws?.readyState === this._WebSocket.OPEN) {
       this.ws?.close();
@@ -692,7 +737,7 @@ var AbstractRelay = class {
           const payload = data[2];
           const cr = this.openCountRequests.get(id);
           if (cr) {
-            cr.resolve(payload.count);
+            cr.resolve(payload);
             this.openCountRequests.delete(id);
           }
           return;
@@ -722,8 +767,14 @@ var AbstractRelay = class {
         case "CLOSED": {
           const id = data[1];
           const so = this.openSubs.get(id);
-          if (!so)
+          if (!so) {
+            const cr = this.openCountRequests.get(id);
+            if (cr) {
+              cr.reject(new Error(data[2]));
+              this.openCountRequests.delete(id);
+            }
             return;
+          }
           so.closed = true;
           so.close(data[2]);
           return;
@@ -820,8 +871,10 @@ var Subscription = class {
     }
     this.relay.openSubs.delete(this.id);
     this.relay.ongoingOperations--;
-    if (this.relay.ongoingOperations === 0)
+    if (this.relay.ongoingOperations === 0) {
       this.relay.idleSince = Date.now();
+      this.relay.scheduleIdleClose();
+    }
     this.onclose?.(reason);
   }
 };
@@ -832,6 +885,63 @@ var alwaysTrue = (t) => {
   return true;
 };
 
+// nip45.ts
+var import_sha23 = require("@noble/hashes/sha2.js");
+var import_utils8 = require("@noble/hashes/utils.js");
+var M = 256;
+var HLL_HEX_LENGTH = M * 2;
+var utf8Encoder2 = new TextEncoder();
+function getCountManyFilter(target, directive) {
+  switch (directive) {
+    case "reactions":
+      return { "#e": [target], kinds: [7] };
+    case "reposts":
+      return { "#e": [target], kinds: [6] };
+    case "quotes":
+      return { "#q": [target], kinds: [1, 1111] };
+    case "replies":
+      return { "#e": [target], kinds: [1] };
+    case "comments":
+      return { "#E": [target], kinds: [1111] };
+    case "followers":
+      return { "#p": [target], kinds: [3] };
+  }
+}
+function newHll() {
+  return new Uint8Array(M);
+}
+function hllDecode(hex) {
+  if (hex.length !== HLL_HEX_LENGTH || !/^[0-9a-fA-F]+$/.test(hex))
+    return void 0;
+  const registers = new Uint8Array(M);
+  for (let i2 = 0; i2 < M; i2++) {
+    registers[i2] = parseInt(hex.slice(i2 * 2, i2 * 2 + 2), 16);
+  }
+  return registers;
+}
+function hllEncode(registers) {
+  if (registers.length !== M)
+    throw new Error(`invalid number of registers ${registers.length}`);
+  let hex = "";
+  for (let i2 = 0; i2 < M; i2++) {
+    hex += registers[i2].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function mergeHll(target, source) {
+  if (target.length === 0)
+    target = newHll();
+  if (target.length !== M)
+    throw new Error(`invalid number of registers ${target.length}`);
+  if (source.length !== M)
+    throw new Error(`invalid number of registers ${source.length}`);
+  for (let i2 = 0; i2 < M; i2++) {
+    if (source[i2] > target[i2])
+      target[i2] = source[i2];
+  }
+  return target;
+}
+
 // abstract-pool.ts
 var AbstractSimplePool = class {
   relays = /* @__PURE__ */ new Map();
@@ -840,6 +950,7 @@ var AbstractSimplePool = class {
   verifyEvent;
   enablePing;
   enableReconnect;
+  idleTimeout = 2e4;
   automaticallyAuth;
   trustedRelayURLs = /* @__PURE__ */ new Set();
   onRelayConnectionFailure;
@@ -852,6 +963,8 @@ var AbstractSimplePool = class {
     this._WebSocket = opts.websocketImplementation;
     this.enablePing = opts.enablePing;
     this.enableReconnect = opts.enableReconnect || false;
+    if (opts.idleTimeout)
+      this.idleTimeout = opts.idleTimeout;
     this.automaticallyAuth = opts.automaticallyAuth;
     this.onRelayConnectionFailure = opts.onRelayConnectionFailure;
     this.onRelayConnectionSuccess = opts.onRelayConnectionSuccess;
@@ -866,7 +979,8 @@ var AbstractSimplePool = class {
         verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
         websocketImplementation: this._WebSocket,
         enablePing: this.enablePing,
-        enableReconnect: this.enableReconnect
+        enableReconnect: this.enableReconnect,
+        idleTimeout: this.idleTimeout
       });
       relay.onclose = () => {
         this.relays.delete(url);
@@ -1059,6 +1173,48 @@ var AbstractSimplePool = class {
     events.sort((a, b) => b.created_at - a.created_at);
     return events[0] || null;
   }
+  async countMany(relays, target, directive, params) {
+    const filter = getCountManyFilter(target, directive);
+    const urls = [];
+    for (let i2 = 0; i2 < relays.length; i2++) {
+      const url = normalizeURL(relays[i2]);
+      if (urls.indexOf(url) === -1)
+        urls.push(url);
+    }
+    const responses = await Promise.all(
+      urls.map(async (url) => {
+        if (this.allowConnectingToRelay?.(url, ["read", [filter]]) === false)
+          return null;
+        let relay;
+        try {
+          relay = 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 null;
+        }
+        this.onRelayConnectionSuccess?.(url);
+        return relay.countWithHLL([filter], { id: params?.id }).catch(() => null);
+      })
+    );
+    let count = 0;
+    let hll;
+    for (const response of responses) {
+      if (!response)
+        continue;
+      if (response.count > count)
+        count = response.count;
+      if (!response.hll || response.hll.length !== 512)
+        continue;
+      const registers = hllDecode(response.hll);
+      if (!registers)
+        continue;
+      hll = mergeHll(hll || new Uint8Array(0), registers);
+    }
+    return hll ? { count, hll: hllEncode(hll) } : { count };
+  }
   publish(relays, event, params) {
     return relays.map(normalizeURL).map(async (url, i2, arr) => {
       if (arr.indexOf(url) !== i2) {