@openclaw/nostr 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/nostr-tools/lib/esm/nip46.js

@@ -419,7 +419,9 @@ var AbstractRelay = class {
         connectionTimeoutHandle = setTimeout(() => {
           reject("connection timed out");
           this.connectionPromise = void 0;
-          this.skipReconnection = true;
+          if (this.reconnectAttempts === 0) {
+            this.skipReconnection = true;
+          }
           this.onclose?.();
           this.handleHardClose("relay connection timed out");
         }, opts.timeout);
@@ -463,7 +465,9 @@ var AbstractRelay = class {
         clearTimeout(connectionTimeoutHandle);
         reject("connection failed");
         this.connectionPromise = void 0;
-        this.skipReconnection = true;
+        if (this.reconnectAttempts === 0) {
+          this.skipReconnection = true;
+        }
         this.onclose?.();
         this.handleHardClose("relay connection failed");
       };
@@ -564,19 +568,38 @@ 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)
       this.idleSince = Date.now();
     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) {
@@ -654,7 +677,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;
@@ -684,8 +707,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;
@@ -794,6 +823,63 @@ var alwaysTrue = (t) => {
   return true;
 };
 
+// nip45.ts
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
+import { bytesToHex as bytesToHex3 } from "@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();
@@ -1021,6 +1107,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) {
@@ -1310,7 +1438,8 @@ var BunkerSigner = class {
   }
   async close() {
     this.isOpen = false;
-    this.subCloser.close();
+    this.subCloser?.close();
+    this.subCloser = void 0;
   }
   async sendRequest(method, params) {
     return new Promise(async (resolve, reject) => {
@@ -1344,8 +1473,19 @@ var BunkerSigner = class {
     if (resp !== "pong")
       throw new Error(`result is not pong: ${resp}`);
   }
-  async connect() {
-    await this.sendRequest("connect", [this.bp.pubkey, this.bp.secret || ""]);
+  async connect(clientMetadata) {
+    const params = [this.bp.pubkey, this.bp.secret || ""];
+    if (clientMetadata) {
+      params.push("");
+      params.push(JSON.stringify(clientMetadata));
+    }
+    await this.sendRequest("connect", params);
+  }
+  async logout() {
+    let resp = await this.sendRequest("logout", []);
+    if (resp !== "ack")
+      throw new Error(`result is not ack: ${resp}`);
+    await this.close();
   }
   async getPublicKey() {
     if (!this.cachedPubKey) {