@openclaw/nostr 2026.7.2-beta.7 → 2026.7.34

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

@@ -34,42 +34,7 @@ module.exports = __toCommonJS(nip46_exports);
 
 // pure.ts
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
-var import_utils3 = require("@noble/hashes/utils.js");
-
-// utils.ts
-var import_utils = require("@noble/hashes/utils.js");
-var utf8Decoder = new TextDecoder("utf-8");
-var utf8Encoder = new TextEncoder();
-function normalizeURL(url) {
-  try {
-    if (url.indexOf("://") === -1)
-      url = "wss://" + url;
-    let p = new URL(url);
-    if (p.protocol === "http:")
-      p.protocol = "ws:";
-    else if (p.protocol === "https:")
-      p.protocol = "wss:";
-    p.pathname = p.pathname.replace(/\/+/g, "/");
-    if (p.pathname.endsWith("/"))
-      p.pathname = p.pathname.slice(0, -1);
-    if (p.port === "80" && p.protocol === "ws:" || p.port === "443" && p.protocol === "wss:")
-      p.port = "";
-    p.searchParams.sort();
-    p.hash = "";
-    return p.toString();
-  } catch (e) {
-    throw new Error(`Invalid URL: ${url}`);
-  }
-}
-function isHex32(input) {
-  for (let i2 = 0; i2 < 64; i2++) {
-    let cc = input.charCodeAt(i2);
-    if (isNaN(cc) || cc < 48 || cc > 102 || cc > 57 && cc < 97) {
-      return false;
-    }
-  }
-  return true;
-}
+var import_utils2 = require("@noble/hashes/utils.js");
 
 // core.ts
 var verifiedSymbol = Symbol("verified");
@@ -85,7 +50,7 @@ function validateEvent(event) {
     return false;
   if (typeof event.pubkey !== "string")
     return false;
-  if (!isHex32(event.pubkey))
+  if (!event.pubkey.match(/^[a-f0-9]{64}$/))
     return false;
   if (!Array.isArray(event.tags))
     return false;
@@ -103,18 +68,46 @@ function validateEvent(event) {
 
 // pure.ts
 var import_sha2 = require("@noble/hashes/sha2.js");
+
+// utils.ts
+var import_utils = require("@noble/hashes/utils.js");
+var utf8Decoder = new TextDecoder("utf-8");
+var utf8Encoder = new TextEncoder();
+function normalizeURL(url) {
+  try {
+    if (url.indexOf("://") === -1)
+      url = "wss://" + url;
+    let p = new URL(url);
+    if (p.protocol === "http:")
+      p.protocol = "ws:";
+    else if (p.protocol === "https:")
+      p.protocol = "wss:";
+    p.pathname = p.pathname.replace(/\/+/g, "/");
+    if (p.pathname.endsWith("/"))
+      p.pathname = p.pathname.slice(0, -1);
+    if (p.port === "80" && p.protocol === "ws:" || p.port === "443" && p.protocol === "wss:")
+      p.port = "";
+    p.searchParams.sort();
+    p.hash = "";
+    return p.toString();
+  } catch (e) {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+
+// pure.ts
 var JS = class {
   generateSecretKey() {
     return import_secp256k1.schnorr.utils.randomSecretKey();
   }
   getPublicKey(secretKey) {
-    return (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
+    return (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event = t;
-    event.pubkey = (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
+    event.pubkey = (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.getPublicKey(secretKey));
     event.id = getEventHash(event);
-    event.sig = (0, import_utils3.bytesToHex)(import_secp256k1.schnorr.sign((0, import_utils3.hexToBytes)(getEventHash(event)), secretKey));
+    event.sig = (0, import_utils2.bytesToHex)(import_secp256k1.schnorr.sign((0, import_utils2.hexToBytes)(getEventHash(event)), secretKey));
     event[verifiedSymbol] = true;
     return event;
   }
@@ -127,7 +120,7 @@ var JS = class {
         event[verifiedSymbol] = false;
         return false;
       }
-      const valid = import_secp256k1.schnorr.verify((0, import_utils3.hexToBytes)(event.sig), (0, import_utils3.hexToBytes)(hash), (0, import_utils3.hexToBytes)(event.pubkey));
+      const valid = import_secp256k1.schnorr.verify((0, import_utils2.hexToBytes)(event.sig), (0, import_utils2.hexToBytes)(hash), (0, import_utils2.hexToBytes)(event.pubkey));
       event[verifiedSymbol] = valid;
       return valid;
     } catch (err) {
@@ -143,7 +136,7 @@ function serializeEvent(evt) {
 }
 function getEventHash(event) {
   let eventHash = (0, import_sha2.sha256)(utf8Encoder.encode(serializeEvent(event)));
-  return (0, import_utils3.bytesToHex)(eventHash);
+  return (0, import_utils2.bytesToHex)(eventHash);
 }
 var i = new JS();
 var generateSecretKey = i.generateSecretKey;
@@ -153,18 +146,18 @@ var verifyEvent = i.verifyEvent;
 
 // nip44.ts
 var import_chacha = require("@noble/ciphers/chacha.js");
-var import_utils5 = require("@noble/ciphers/utils.js");
+var import_utils4 = require("@noble/ciphers/utils.js");
 var import_secp256k12 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_hmac = require("@noble/hashes/hmac.js");
 var import_sha22 = require("@noble/hashes/sha2.js");
-var import_utils6 = require("@noble/hashes/utils.js");
+var import_utils5 = require("@noble/hashes/utils.js");
 var import_base = require("@scure/base");
 var minPlaintextSize = 1;
 var maxPlaintextSize = 4294967295;
 var extendedPrefixThreshold = 65536;
 function getConversationKey(privkeyA, pubkeyB) {
-  const sharedX = import_secp256k12.secp256k1.getSharedSecret(privkeyA, (0, import_utils6.hexToBytes)("02" + pubkeyB)).subarray(1, 33);
+  const sharedX = import_secp256k12.secp256k1.getSharedSecret(privkeyA, (0, import_utils5.hexToBytes)("02" + pubkeyB)).subarray(1, 33);
   return (0, import_hkdf.extract)(import_sha22.sha256, sharedX, utf8Encoder.encode("nip44-v2"));
 }
 function getMessageKeys(conversationKey, nonce) {
@@ -203,9 +196,9 @@ function pad(plaintext) {
   const unpaddedLen = unpadded.length;
   if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize)
     throw new Error("invalid plaintext size: must be between 1 and 4294967295 bytes");
-  const prefix = unpaddedLen >= extendedPrefixThreshold ? (0, import_utils6.concatBytes)(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
+  const prefix = unpaddedLen >= extendedPrefixThreshold ? (0, import_utils5.concatBytes)(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
   const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);
-  return (0, import_utils6.concatBytes)(prefix, unpadded, suffix);
+  return (0, import_utils5.concatBytes)(prefix, unpadded, suffix);
 }
 function unpad(padded) {
   const dv = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
@@ -229,7 +222,7 @@ function unpad(padded) {
 function hmacAad(key, message, aad) {
   if (aad.length !== 32)
     throw new Error("AAD associated data must be 32 bytes");
-  const combined = (0, import_utils6.concatBytes)(aad, message);
+  const combined = (0, import_utils5.concatBytes)(aad, message);
   return (0, import_hmac.hmac)(import_sha22.sha256, key, combined);
 }
 function decodePayload(payload) {
@@ -258,18 +251,18 @@ function decodePayload(payload) {
     mac: data.subarray(-32)
   };
 }
-function encrypt(plaintext, conversationKey, nonce = (0, import_utils6.randomBytes)(32)) {
+function encrypt(plaintext, conversationKey, nonce = (0, import_utils5.randomBytes)(32)) {
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);
   const padded = pad(plaintext);
   const ciphertext = (0, import_chacha.chacha20)(chacha_key, chacha_nonce, padded);
   const mac = hmacAad(hmac_key, ciphertext, nonce);
-  return import_base.base64.encode((0, import_utils6.concatBytes)(new Uint8Array([2]), nonce, ciphertext, mac));
+  return import_base.base64.encode((0, import_utils5.concatBytes)(new Uint8Array([2]), nonce, ciphertext, mac));
 }
 function decrypt(payload, conversationKey) {
   const { nonce, ciphertext, mac } = decodePayload(payload);
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);
   const calculatedMac = hmacAad(hmac_key, ciphertext, nonce);
-  if (!(0, import_utils5.equalBytes)(calculatedMac, mac))
+  if (!(0, import_utils4.equalBytes)(calculatedMac, mac))
     throw new Error("invalid MAC");
   const padded = (0, import_chacha.chacha20)(chacha_key, chacha_nonce, ciphertext);
   return unpad(padded);
@@ -379,14 +372,12 @@ 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();
@@ -402,8 +393,6 @@ 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);
@@ -427,22 +416,6 @@ 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++;
@@ -454,11 +427,6 @@ var AbstractRelay = class {
     }, backoff);
   }
   handleHardClose(reason) {
-    if (this.ws) {
-      this.ws.onopen = null;
-      this.ws.onerror = null;
-      this.ws.onclose = null;
-    }
     if (this.pingIntervalHandle) {
       clearInterval(this.pingIntervalHandle);
       this.pingIntervalHandle = void 0;
@@ -466,7 +434,6 @@ var AbstractRelay = class {
     this._connected = false;
     this.connectionPromise = void 0;
     this.idleSince = void 0;
-    this.clearIdleTimeout();
     if (this.enableReconnect && !this.skipReconnection) {
       this.reconnect();
     } else {
@@ -489,6 +456,7 @@ var AbstractRelay = class {
           if (this.reconnectAttempts === 0) {
             this.skipReconnection = true;
           }
+          this.onclose?.();
           this.handleHardClose("relay connection timed out");
         }, opts.timeout);
       }
@@ -534,6 +502,7 @@ var AbstractRelay = class {
         if (this.reconnectAttempts === 0) {
           this.skipReconnection = true;
         }
+        this.onclose?.();
         this.handleHardClose("relay connection failed");
       };
       this.ws.onclose = (ev) => {
@@ -622,7 +591,6 @@ var AbstractRelay = class {
   }
   async publish(event) {
     this.idleSince = void 0;
-    this.clearIdleTimeout();
     this.ongoingOperations++;
     const ret = new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -644,10 +612,8 @@ var AbstractRelay = class {
       }
     }
     this.ongoingOperations--;
-    if (this.ongoingOperations === 0) {
+    if (this.ongoingOperations === 0)
       this.idleSince = Date.now();
-      this.scheduleIdleClose();
-    }
     return ret;
   }
   async count(filters, params) {
@@ -673,7 +639,6 @@ var AbstractRelay = class {
   subscribe(filters, params) {
     if (params.label !== "<forced-ping>") {
       this.idleSince = void 0;
-      this.clearIdleTimeout();
       this.ongoingOperations++;
     }
     const sub = this.prepareSubscription(filters, params);
@@ -702,17 +667,10 @@ var AbstractRelay = class {
     }
     this.closeAllSubscriptions("relay connection closed by us");
     this._connected = false;
-    this.connectionPromise = void 0;
     this.idleSince = void 0;
-    this.clearIdleTimeout();
     this.onclose?.();
-    if (this.ws) {
-      this.ws.onopen = null;
-      this.ws.onerror = null;
-      this.ws.onclose = null;
-      if (this.ws.readyState !== this._WebSocket.CLOSING && this.ws.readyState !== this._WebSocket.CLOSED) {
-        this.ws.close();
-      }
+    if (this.ws?.readyState === this._WebSocket.OPEN) {
+      this.ws?.close();
     }
   }
   _onmessage(ev) {
@@ -739,7 +697,7 @@ var AbstractRelay = class {
         case "EVENT": {
           const so = this.openSubs.get(data[1]);
           const event = data[2];
-          if (matchFilters(so.filters, event) && this.verifyEvent(event, this.url)) {
+          if (this.verifyEvent(event) && matchFilters(so.filters, event)) {
             so.onevent(event);
           } else {
             so.oninvalidevent?.(event);
@@ -887,17 +845,21 @@ 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);
   }
 };
 
+// helpers.ts
+var alwaysTrue = (t) => {
+  t[verifiedSymbol] = true;
+  return true;
+};
+
 // nip45.ts
 var import_sha23 = require("@noble/hashes/sha2.js");
-var import_utils9 = require("@noble/hashes/utils.js");
+var import_utils8 = require("@noble/hashes/utils.js");
 var M = 256;
 var HLL_HEX_LENGTH = M * 2;
 var utf8Encoder2 = new TextEncoder();
@@ -921,7 +883,7 @@ function newHll() {
   return new Uint8Array(M);
 }
 function hllDecode(hex) {
-  if (hex.length !== HLL_HEX_LENGTH || !/^[0-9a-f]+$/.test(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++) {
@@ -960,8 +922,8 @@ var AbstractSimplePool = class {
   verifyEvent;
   enablePing;
   enableReconnect;
-  idleTimeout = 2e4;
   automaticallyAuth;
+  trustedRelayURLs = /* @__PURE__ */ new Set();
   onRelayConnectionFailure;
   onRelayConnectionSuccess;
   allowConnectingToRelay;
@@ -972,8 +934,6 @@ 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;
@@ -985,11 +945,10 @@ var AbstractSimplePool = class {
     let relay = this.relays.get(url);
     if (!relay) {
       relay = new AbstractRelay(url, {
-        verifyEvent: this.verifyEvent,
+        verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
         websocketImplementation: this._WebSocket,
         enablePing: this.enablePing,
-        enableReconnect: this.enableReconnect,
-        idleTimeout: this.idleTimeout
+        enableReconnect: this.enableReconnect
       });
       relay.onclose = () => {
         this.relays.delete(url);
@@ -1069,11 +1028,11 @@ var AbstractSimplePool = class {
       }
     };
     const closesReceived = [];
-    let handleClose = (i2, url, reason) => {
+    let handleClose = (i2, reason) => {
       if (closesReceived[i2])
         return;
       handleEose(i2);
-      closesReceived[i2] = { url, reason };
+      closesReceived[i2] = reason;
       if (closesReceived.filter((a) => a).length === groupedRequests.length) {
         params.onclose?.(closesReceived);
         handleClose = () => {
@@ -1091,7 +1050,7 @@ var AbstractSimplePool = class {
     const allOpened = Promise.all(
       groupedRequests.map(async ({ url, filters }, i2) => {
         if (this.allowConnectingToRelay?.(url, ["read", filters]) === false) {
-          handleClose(i2, url, "connection skipped by allowConnectingToRelay");
+          handleClose(i2, "connection skipped by allowConnectingToRelay");
           return;
         }
         let relay;
@@ -1102,7 +1061,7 @@ var AbstractSimplePool = class {
           });
         } catch (err) {
           this.onRelayConnectionFailure?.(url);
-          handleClose(i2, url, err?.message || String(err));
+          handleClose(i2, err?.message || String(err));
           return;
         }
         this.onRelayConnectionSuccess?.(url);
@@ -1116,17 +1075,17 @@ var AbstractSimplePool = class {
                   ...params,
                   oneose: () => handleEose(i2),
                   onclose: (reason2) => {
-                    handleClose(i2, url, reason2);
+                    handleClose(i2, reason2);
                   },
                   alreadyHaveEvent: localAlreadyHaveEventHandler,
                   eoseTimeout: params.maxWait,
                   abort: params.abort
                 });
               }).catch((err) => {
-                handleClose(i2, url, `auth was required and attempted, but failed with: ${err}`);
+                handleClose(i2, `auth was required and attempted, but failed with: ${err}`);
               });
             } else {
-              handleClose(i2, url, reason);
+              handleClose(i2, reason);
             }
           },
           alreadyHaveEvent: localAlreadyHaveEventHandler,
@@ -1154,7 +1113,7 @@ var AbstractSimplePool = class {
         if (subcloser)
           subcloser.close(reason);
         else
-          params.onclose?.(relays.map((url) => ({ url, reason })));
+          params.onclose?.(relays.map((_) => reason));
       }
     });
     return subcloser;