@openclaw/nostr 2026.5.20 → 2026.5.22

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

@@ -0,0 +1,1432 @@
+// pure.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+
+// core.ts
+var verifiedSymbol = Symbol("verified");
+var isRecord = (obj) => obj instanceof Object;
+function validateEvent(event) {
+  if (!isRecord(event))
+    return false;
+  if (typeof event.kind !== "number")
+    return false;
+  if (typeof event.content !== "string")
+    return false;
+  if (typeof event.created_at !== "number")
+    return false;
+  if (typeof event.pubkey !== "string")
+    return false;
+  if (!event.pubkey.match(/^[a-f0-9]{64}$/))
+    return false;
+  if (!Array.isArray(event.tags))
+    return false;
+  for (let i2 = 0; i2 < event.tags.length; i2++) {
+    let tag = event.tags[i2];
+    if (!Array.isArray(tag))
+      return false;
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string")
+        return false;
+    }
+  }
+  return true;
+}
+
+// pure.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// utils.ts
+import { bytesToHex, hexToBytes } from "@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 schnorr.utils.randomSecretKey();
+  }
+  getPublicKey(secretKey) {
+    return bytesToHex2(schnorr.getPublicKey(secretKey));
+  }
+  finalizeEvent(t, secretKey) {
+    const event = t;
+    event.pubkey = bytesToHex2(schnorr.getPublicKey(secretKey));
+    event.id = getEventHash(event);
+    event.sig = bytesToHex2(schnorr.sign(hexToBytes2(getEventHash(event)), secretKey));
+    event[verifiedSymbol] = true;
+    return event;
+  }
+  verifyEvent(event) {
+    if (typeof event[verifiedSymbol] === "boolean")
+      return event[verifiedSymbol];
+    try {
+      const hash = getEventHash(event);
+      if (hash !== event.id) {
+        event[verifiedSymbol] = false;
+        return false;
+      }
+      const valid = schnorr.verify(hexToBytes2(event.sig), hexToBytes2(hash), hexToBytes2(event.pubkey));
+      event[verifiedSymbol] = valid;
+      return valid;
+    } catch (err) {
+      event[verifiedSymbol] = false;
+      return false;
+    }
+  }
+};
+function serializeEvent(evt) {
+  if (!validateEvent(evt))
+    throw new Error("can't serialize event with wrong or missing properties");
+  return JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]);
+}
+function getEventHash(event) {
+  let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)));
+  return bytesToHex2(eventHash);
+}
+var i = new JS();
+var generateSecretKey = i.generateSecretKey;
+var getPublicKey = i.getPublicKey;
+var finalizeEvent = i.finalizeEvent;
+var verifyEvent = i.verifyEvent;
+
+// nip44.ts
+import { chacha20 } from "@noble/ciphers/chacha.js";
+import { equalBytes } from "@noble/ciphers/utils.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { extract as hkdf_extract, expand as hkdf_expand } from "@noble/hashes/hkdf.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { concatBytes, hexToBytes as hexToBytes3, randomBytes } from "@noble/hashes/utils.js";
+import { base64 } from "@scure/base";
+var minPlaintextSize = 1;
+var maxPlaintextSize = 4294967295;
+var extendedPrefixThreshold = 65536;
+function getConversationKey(privkeyA, pubkeyB) {
+  const sharedX = secp256k1.getSharedSecret(privkeyA, hexToBytes3("02" + pubkeyB)).subarray(1, 33);
+  return hkdf_extract(sha2562, sharedX, utf8Encoder.encode("nip44-v2"));
+}
+function getMessageKeys(conversationKey, nonce) {
+  const keys = hkdf_expand(sha2562, conversationKey, nonce, 76);
+  return {
+    chacha_key: keys.subarray(0, 32),
+    chacha_nonce: keys.subarray(32, 44),
+    hmac_key: keys.subarray(44, 76)
+  };
+}
+function calcPaddedLen(len) {
+  if (!Number.isSafeInteger(len) || len < 1)
+    throw new Error("expected positive integer");
+  if (len <= 32)
+    return 32;
+  const nextPower = 2 ** (Math.floor(Math.log2(len - 1)) + 1);
+  const chunk = nextPower <= 256 ? 32 : nextPower / 8;
+  return chunk * (Math.floor((len - 1) / chunk) + 1);
+}
+function writeU16BE(num) {
+  if (!Number.isSafeInteger(num) || num < minPlaintextSize || num > 65535)
+    throw new Error("invalid plaintext size: must be between 1 and 65535 bytes");
+  const arr = new Uint8Array(2);
+  new DataView(arr.buffer).setUint16(0, num, false);
+  return arr;
+}
+function writeU32BE(num) {
+  if (!Number.isSafeInteger(num) || num < extendedPrefixThreshold || num > maxPlaintextSize)
+    throw new Error("invalid plaintext size: must be between 65536 and 4294967295 bytes");
+  const arr = new Uint8Array(4);
+  new DataView(arr.buffer).setUint32(0, num, false);
+  return arr;
+}
+function pad(plaintext) {
+  const unpadded = utf8Encoder.encode(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 ? concatBytes(new Uint8Array([0, 0]), writeU32BE(unpaddedLen)) : writeU16BE(unpaddedLen);
+  const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);
+  return concatBytes(prefix, unpadded, suffix);
+}
+function unpad(padded) {
+  const dv = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+  const firstTwo = dv.getUint16(0);
+  let unpaddedLen;
+  let prefixLen;
+  if (firstTwo === 0) {
+    unpaddedLen = dv.getUint32(2);
+    if (unpaddedLen < extendedPrefixThreshold)
+      throw new Error("invalid padding");
+    prefixLen = 6;
+  } else {
+    unpaddedLen = firstTwo;
+    prefixLen = 2;
+  }
+  const unpadded = padded.subarray(prefixLen, prefixLen + unpaddedLen);
+  if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize || unpadded.length !== unpaddedLen || padded.length !== prefixLen + calcPaddedLen(unpaddedLen))
+    throw new Error("invalid padding");
+  return utf8Decoder.decode(unpadded);
+}
+function hmacAad(key, message, aad) {
+  if (aad.length !== 32)
+    throw new Error("AAD associated data must be 32 bytes");
+  const combined = concatBytes(aad, message);
+  return hmac(sha2562, key, combined);
+}
+function decodePayload(payload) {
+  if (typeof payload !== "string")
+    throw new Error("payload must be a valid string");
+  const plen = payload.length;
+  if (plen < 132)
+    throw new Error("invalid payload length: " + plen);
+  if (payload[0] === "#")
+    throw new Error("unknown encryption version");
+  let data;
+  try {
+    data = base64.decode(payload);
+  } catch (error) {
+    throw new Error("invalid base64: " + error.message);
+  }
+  const dlen = data.length;
+  if (dlen < 99)
+    throw new Error("invalid data length: " + dlen);
+  const vers = data[0];
+  if (vers !== 2)
+    throw new Error("unknown encryption version " + vers);
+  return {
+    nonce: data.subarray(1, 33),
+    ciphertext: data.subarray(33, -32),
+    mac: data.subarray(-32)
+  };
+}
+function encrypt(plaintext, conversationKey, nonce = randomBytes(32)) {
+  const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);
+  const padded = pad(plaintext);
+  const ciphertext = chacha20(chacha_key, chacha_nonce, padded);
+  const mac = hmacAad(hmac_key, ciphertext, nonce);
+  return base64.encode(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 (!equalBytes(calculatedMac, mac))
+    throw new Error("invalid MAC");
+  const padded = chacha20(chacha_key, chacha_nonce, ciphertext);
+  return unpad(padded);
+}
+
+// nip05.ts
+var NIP05_REGEX = /^(?:([\w.+-]+)@)?([\w_-]+(\.[\w_-]+)+)$/;
+var _fetch;
+try {
+  _fetch = fetch;
+} catch (_) {
+  null;
+}
+
+// kinds.ts
+var ClientAuth = 22242;
+var NostrConnect = 24133;
+var Handlerinformation = 31990;
+
+// filter.ts
+function matchFilter(filter, event) {
+  if (filter.ids && filter.ids.indexOf(event.id) === -1) {
+    return false;
+  }
+  if (filter.kinds && filter.kinds.indexOf(event.kind) === -1) {
+    return false;
+  }
+  if (filter.authors && filter.authors.indexOf(event.pubkey) === -1) {
+    return false;
+  }
+  for (let f in filter) {
+    if (f[0] === "#") {
+      let tagName = f.slice(1);
+      let values = filter[`#${tagName}`];
+      if (values && !event.tags.find(([t, v]) => t === f.slice(1) && values.indexOf(v) !== -1))
+        return false;
+    }
+  }
+  if (filter.since && event.created_at < filter.since)
+    return false;
+  if (filter.until && event.created_at > filter.until)
+    return false;
+  return true;
+}
+function matchFilters(filters, event) {
+  for (let i2 = 0; i2 < filters.length; i2++) {
+    if (matchFilter(filters[i2], event)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// fakejson.ts
+function getHex64(json, field) {
+  let len = field.length + 3;
+  let idx = json.indexOf(`"${field}":`) + len;
+  let s = json.slice(idx).indexOf(`"`) + idx + 1;
+  return json.slice(s, s + 64);
+}
+function getSubscriptionId(json) {
+  let idx = json.slice(0, 22).indexOf(`"EVENT"`);
+  if (idx === -1)
+    return null;
+  let pstart = json.slice(idx + 7 + 1).indexOf(`"`);
+  if (pstart === -1)
+    return null;
+  let start = idx + 7 + 1 + pstart;
+  let pend = json.slice(start + 1, 80).indexOf(`"`);
+  if (pend === -1)
+    return null;
+  let end = start + 1 + pend;
+  return json.slice(start + 1, end);
+}
+
+// nip42.ts
+function makeAuthEvent(relayURL, challenge) {
+  return {
+    kind: ClientAuth,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [
+      ["relay", relayURL],
+      ["challenge", challenge]
+    ],
+    content: ""
+  };
+}
+
+// abstract-relay.ts
+var SendingOnClosedConnection = class extends Error {
+  constructor(message, relay) {
+    super(`Tried to send message '${message} on a closed connection to ${relay}.`);
+    this.name = "SendingOnClosedConnection";
+  }
+};
+var AbstractRelay = class {
+  url;
+  _connected = false;
+  onclose = null;
+  onnotice = (msg) => console.debug(`NOTICE from ${this.url}: ${msg}`);
+  onauth;
+  baseEoseTimeout = 4400;
+  publishTimeout = 4400;
+  pingFrequency = 29e3;
+  pingTimeout = 2e4;
+  resubscribeBackoff = [1e4, 1e4, 1e4, 2e4, 2e4, 3e4, 6e4];
+  openSubs = /* @__PURE__ */ new Map();
+  enablePing;
+  enableReconnect;
+  idleSince = Date.now();
+  ongoingOperations = 0;
+  reconnectTimeoutHandle;
+  pingIntervalHandle;
+  reconnectAttempts = 0;
+  skipReconnection = false;
+  connectionPromise;
+  openCountRequests = /* @__PURE__ */ new Map();
+  openEventPublishes = /* @__PURE__ */ new Map();
+  ws;
+  challenge;
+  authPromise;
+  serial = 0;
+  verifyEvent;
+  _WebSocket;
+  constructor(url, opts) {
+    this.url = normalizeURL(url);
+    this.verifyEvent = opts.verifyEvent;
+    this._WebSocket = opts.websocketImplementation || WebSocket;
+    this.enablePing = opts.enablePing;
+    this.enableReconnect = opts.enableReconnect || false;
+  }
+  static async connect(url, opts) {
+    const relay = new AbstractRelay(url, opts);
+    await relay.connect(opts);
+    return relay;
+  }
+  closeAllSubscriptions(reason) {
+    for (let [_, sub] of this.openSubs) {
+      sub.close(reason);
+    }
+    this.openSubs.clear();
+    for (let [_, ep] of this.openEventPublishes) {
+      ep.reject(new Error(reason));
+    }
+    this.openEventPublishes.clear();
+    for (let [_, cr] of this.openCountRequests) {
+      cr.reject(new Error(reason));
+    }
+    this.openCountRequests.clear();
+  }
+  get connected() {
+    return this._connected;
+  }
+  async reconnect() {
+    const backoff = this.resubscribeBackoff[Math.min(this.reconnectAttempts, this.resubscribeBackoff.length - 1)];
+    this.reconnectAttempts++;
+    this.reconnectTimeoutHandle = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch (err) {
+      }
+    }, backoff);
+  }
+  handleHardClose(reason) {
+    if (this.pingIntervalHandle) {
+      clearInterval(this.pingIntervalHandle);
+      this.pingIntervalHandle = void 0;
+    }
+    this._connected = false;
+    this.connectionPromise = void 0;
+    this.idleSince = void 0;
+    if (this.enableReconnect && !this.skipReconnection) {
+      this.reconnect();
+    } else {
+      this.onclose?.();
+      this.closeAllSubscriptions(reason);
+    }
+  }
+  async connect(opts) {
+    let connectionTimeoutHandle;
+    if (this.connectionPromise)
+      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.handleHardClose("relay connection timed out");
+        }, opts.timeout);
+      }
+      if (opts?.abort) {
+        opts.abort.onabort = reject;
+      }
+      try {
+        this.ws = new this._WebSocket(this.url);
+      } catch (err) {
+        clearTimeout(connectionTimeoutHandle);
+        reject(err);
+        return;
+      }
+      this.ws.onopen = () => {
+        if (this.reconnectTimeoutHandle) {
+          clearTimeout(this.reconnectTimeoutHandle);
+          this.reconnectTimeoutHandle = void 0;
+        }
+        clearTimeout(connectionTimeoutHandle);
+        this._connected = true;
+        const isReconnection = this.reconnectAttempts > 0;
+        this.reconnectAttempts = 0;
+        for (const sub of this.openSubs.values()) {
+          sub.eosed = false;
+          if (isReconnection) {
+            for (let f = 0; f < sub.filters.length; f++) {
+              if (sub.lastEmitted) {
+                sub.filters[f].since = sub.lastEmitted + 1;
+              }
+            }
+          }
+          sub.fire();
+        }
+        if (this.enablePing) {
+          this.pingIntervalHandle = setInterval(() => this.pingpong(), this.pingFrequency);
+        }
+        resolve();
+      };
+      this.ws.onerror = () => {
+        clearTimeout(connectionTimeoutHandle);
+        reject("connection failed");
+        this.connectionPromise = void 0;
+        this.skipReconnection = true;
+        this.onclose?.();
+        this.handleHardClose("relay connection failed");
+      };
+      this.ws.onclose = (ev) => {
+        clearTimeout(connectionTimeoutHandle);
+        reject(ev.message || "websocket closed");
+        this.handleHardClose("relay connection closed");
+      };
+      this.ws.onmessage = this._onmessage.bind(this);
+    });
+    return this.connectionPromise;
+  }
+  waitForPingPong() {
+    return new Promise((resolve) => {
+      ;
+      this.ws.once("pong", () => resolve(true));
+      this.ws.ping();
+    });
+  }
+  waitForDummyReq() {
+    return new Promise((resolve, reject) => {
+      if (!this.connectionPromise)
+        return reject(new Error(`no connection to ${this.url}, can't ping`));
+      try {
+        const sub = this.subscribe(
+          [{ ids: ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], limit: 0 }],
+          {
+            label: "<forced-ping>",
+            oneose: () => {
+              resolve(true);
+              sub.close();
+            },
+            onclose() {
+              resolve(true);
+            },
+            eoseTimeout: this.pingTimeout + 1e3
+          }
+        );
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  async pingpong() {
+    if (this.ws?.readyState === 1) {
+      const result = await Promise.any([
+        this.ws && this.ws.ping && this.ws.once ? this.waitForPingPong() : this.waitForDummyReq(),
+        new Promise((res) => setTimeout(() => res(false), this.pingTimeout))
+      ]);
+      if (!result) {
+        if (this.ws?.readyState === this._WebSocket.OPEN) {
+          this.ws?.close();
+        }
+      }
+    }
+  }
+  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) {
+    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>"));
+    }
+    return sub;
+  }
+  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;
+    }
+    const subid = getSubscriptionId(json);
+    if (subid) {
+      const so = this.openSubs.get(subid);
+      if (!so) {
+        return;
+      }
+      const id = getHex64(json, "id");
+      const alreadyHave = so.alreadyHaveEvent?.(id);
+      so.receivedEvent?.(this, id);
+      if (alreadyHave) {
+        return;
+      }
+    }
+    try {
+      let data = JSON.parse(json);
+      switch (data[0]) {
+        case "EVENT": {
+          const so = this.openSubs.get(data[1]);
+          const event = data[2];
+          if (this.verifyEvent(event) && matchFilters(so.filters, event)) {
+            so.onevent(event);
+          } else {
+            so.oninvalidevent?.(event);
+          }
+          if (!so.lastEmitted || so.lastEmitted < event.created_at)
+            so.lastEmitted = event.created_at;
+          return;
+        }
+        case "COUNT": {
+          const id = data[1];
+          const payload = data[2];
+          const cr = this.openCountRequests.get(id);
+          if (cr) {
+            cr.resolve(payload.count);
+            this.openCountRequests.delete(id);
+          }
+          return;
+        }
+        case "EOSE": {
+          const so = this.openSubs.get(data[1]);
+          if (!so)
+            return;
+          so.receivedEose();
+          return;
+        }
+        case "OK": {
+          const id = data[1];
+          const ok = data[2];
+          const reason = data[3];
+          const ep = this.openEventPublishes.get(id);
+          if (ep) {
+            clearTimeout(ep.timeout);
+            if (ok)
+              ep.resolve(reason);
+            else
+              ep.reject(new Error(reason));
+            this.openEventPublishes.delete(id);
+          }
+          return;
+        }
+        case "CLOSED": {
+          const id = data[1];
+          const so = this.openSubs.get(id);
+          if (!so)
+            return;
+          so.closed = true;
+          so.close(data[2]);
+          return;
+        }
+        case "NOTICE": {
+          this.onnotice(data[1]);
+          return;
+        }
+        case "AUTH": {
+          this.challenge = data[1];
+          if (this.onauth) {
+            this.auth(this.onauth).catch((err) => {
+              if (!(err instanceof SendingOnClosedConnection)) {
+                throw err;
+              }
+            });
+          }
+          return;
+        }
+        default: {
+          const so = this.openSubs.get(data[1]);
+          so?.oncustom?.(data);
+          return;
+        }
+      }
+    } catch (err) {
+      try {
+        const [_, __, event] = JSON.parse(json);
+        console.warn(`[nostr] relay ${this.url} error processing message:`, err, event);
+      } catch (_) {
+        console.warn(`[nostr] relay ${this.url} error processing message:`, err);
+      }
+      return;
+    }
+  }
+};
+var Subscription = class {
+  relay;
+  id;
+  lastEmitted;
+  closed = false;
+  eosed = false;
+  filters;
+  alreadyHaveEvent;
+  receivedEvent;
+  onevent;
+  oninvalidevent;
+  oneose;
+  onclose;
+  oncustom;
+  eoseTimeout;
+  eoseTimeoutHandle;
+  constructor(relay, id, filters, params) {
+    if (filters.length === 0)
+      throw new Error("subscription can't be created with zero filters");
+    this.relay = relay;
+    this.filters = filters;
+    this.id = id;
+    this.alreadyHaveEvent = params.alreadyHaveEvent;
+    this.receivedEvent = params.receivedEvent;
+    this.eoseTimeout = params.eoseTimeout || relay.baseEoseTimeout;
+    this.oneose = params.oneose;
+    this.onclose = params.onclose;
+    this.oninvalidevent = params.oninvalidevent;
+    this.onevent = params.onevent || ((event) => {
+      console.warn(
+        `onevent() callback not defined for subscription '${this.id}' in relay ${this.relay.url}. event received:`,
+        event
+      );
+    });
+  }
+  fire() {
+    this.relay.send('["REQ","' + this.id + '",' + JSON.stringify(this.filters).substring(1));
+    this.eoseTimeoutHandle = setTimeout(this.receivedEose.bind(this), this.eoseTimeout);
+  }
+  receivedEose() {
+    if (this.eosed)
+      return;
+    clearTimeout(this.eoseTimeoutHandle);
+    this.eosed = true;
+    this.oneose?.();
+  }
+  close(reason = "closed by caller") {
+    if (!this.closed && this.relay.connected) {
+      try {
+        this.relay.send('["CLOSE",' + JSON.stringify(this.id) + "]");
+      } catch (err) {
+        if (err instanceof SendingOnClosedConnection) {
+        } else {
+          throw err;
+        }
+      }
+      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();
+  seenOn = /* @__PURE__ */ new Map();
+  trackRelays = false;
+  verifyEvent;
+  enablePing;
+  enableReconnect;
+  automaticallyAuth;
+  trustedRelayURLs = /* @__PURE__ */ new Set();
+  onRelayConnectionFailure;
+  onRelayConnectionSuccess;
+  allowConnectingToRelay;
+  maxWaitForConnection;
+  _WebSocket;
+  constructor(opts) {
+    this.verifyEvent = opts.verifyEvent;
+    this._WebSocket = opts.websocketImplementation;
+    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);
+    let relay = this.relays.get(url);
+    if (!relay) {
+      relay = new AbstractRelay(url, {
+        verifyEvent: this.trustedRelayURLs.has(url) ? alwaysTrue : this.verifyEvent,
+        websocketImplementation: this._WebSocket,
+        enablePing: this.enablePing,
+        enableReconnect: this.enableReconnect
+      });
+      relay.onclose = () => {
+        this.relays.delete(url);
+      };
+      this.relays.set(url, relay);
+    }
+    if (this.automaticallyAuth) {
+      const authSignerFn = this.automaticallyAuth(url);
+      if (authSignerFn) {
+        relay.onauth = authSignerFn;
+      }
+    }
+    try {
+      await relay.connect({
+        timeout: params?.connectionTimeout,
+        abort: params?.abort
+      });
+    } catch (err) {
+      this.relays.delete(url);
+      throw err;
+    }
+    return relay;
+  }
+  close(relays) {
+    relays.map(normalizeURL).forEach((url) => {
+      this.relays.get(url)?.close();
+      this.relays.delete(url);
+    });
+  }
+  subscribe(relays, filter, params) {
+    const request = [];
+    const uniqUrls = [];
+    for (let i2 = 0; i2 < relays.length; i2++) {
+      const url = normalizeURL(relays[i2]);
+      if (!request.find((r) => r.url === url)) {
+        if (uniqUrls.indexOf(url) === -1) {
+          uniqUrls.push(url);
+          request.push({ url, filter });
+        }
+      }
+    }
+    return this.subscribeMap(request, params);
+  }
+  subscribeMany(relays, filter, params) {
+    return this.subscribe(relays, filter, params);
+  }
+  subscribeMap(requests, params) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const req of requests) {
+      const { url, filter } = req;
+      if (!grouped.has(url))
+        grouped.set(url, []);
+      grouped.get(url).push(filter);
+    }
+    const groupedRequests = Array.from(grouped.entries()).map(([url, filters]) => ({ url, filters }));
+    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 = (i2) => {
+      if (eosesReceived[i2])
+        return;
+      eosesReceived[i2] = true;
+      if (eosesReceived.filter((a) => a).length === groupedRequests.length) {
+        params.oneose?.();
+        handleEose = () => {
+        };
+      }
+    };
+    const closesReceived = [];
+    let handleClose = (i2, reason) => {
+      if (closesReceived[i2])
+        return;
+      handleEose(i2);
+      closesReceived[i2] = reason;
+      if (closesReceived.filter((a) => a).length === groupedRequests.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(
+      groupedRequests.map(async ({ url, filters }, i2) => {
+        if (this.allowConnectingToRelay?.(url, ["read", filters]) === false) {
+          handleClose(i2, "connection skipped by allowConnectingToRelay");
+          return;
+        }
+        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);
+          handleClose(i2, err?.message || String(err));
+          return;
+        }
+        this.onRelayConnectionSuccess?.(url);
+        let subscription = relay.subscribe(filters, {
+          ...params,
+          oneose: () => handleEose(i2),
+          onclose: (reason) => {
+            if (reason.startsWith("auth-required: ") && params.onauth) {
+              relay.auth(params.onauth).then(() => {
+                relay.subscribe(filters, {
+                  ...params,
+                  oneose: () => handleEose(i2),
+                  onclose: (reason2) => {
+                    handleClose(i2, reason2);
+                  },
+                  alreadyHaveEvent: localAlreadyHaveEventHandler,
+                  eoseTimeout: params.maxWait,
+                  abort: params.abort
+                });
+              }).catch((err) => {
+                handleClose(i2, `auth was required and attempted, but failed with: ${err}`);
+              });
+            } else {
+              handleClose(i2, reason);
+            }
+          },
+          alreadyHaveEvent: localAlreadyHaveEventHandler,
+          eoseTimeout: params.maxWait,
+          abort: params.abort
+        });
+        subs.push(subscription);
+      })
+    );
+    return {
+      async close(reason) {
+        await allOpened;
+        subs.forEach((sub) => {
+          sub.close(reason);
+        });
+      }
+    };
+  }
+  subscribeEose(relays, filter, params) {
+    let subcloser;
+    subcloser = this.subscribe(relays, filter, {
+      ...params,
+      oneose() {
+        const reason = "closed automatically on eose";
+        if (subcloser)
+          subcloser.close(reason);
+        else
+          params.onclose?.(relays.map((_) => reason));
+      }
+    });
+    return subcloser;
+  }
+  subscribeManyEose(relays, filter, params) {
+    return this.subscribeEose(relays, filter, params);
+  }
+  async querySync(relays, filter, params) {
+    return new Promise(async (resolve) => {
+      const events = [];
+      this.subscribeEose(relays, filter, {
+        ...params,
+        onevent(event) {
+          events.push(event);
+        },
+        onclose(_) {
+          resolve(events);
+        }
+      });
+    });
+  }
+  async get(relays, filter, params) {
+    filter.limit = 1;
+    const events = await this.querySync(relays, filter, params);
+    events.sort((a, b) => b.created_at - a.created_at);
+    return events[0] || null;
+  }
+  publish(relays, event, params) {
+    return relays.map(normalizeURL).map(async (url, i2, arr) => {
+      if (arr.indexOf(url) !== i2) {
+        return Promise.reject("duplicate 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: ") && params?.onauth) {
+          await r.auth(params.onauth);
+          return r.publish(event);
+        }
+        throw err;
+      }).then((reason) => {
+        if (this.trackRelays) {
+          let set = this.seenOn.get(event.id);
+          if (!set) {
+            set = /* @__PURE__ */ new Set();
+            this.seenOn.set(event.id, set);
+          }
+          set.add(r);
+        }
+        return reason;
+      });
+    });
+  }
+  listConnectionStatus() {
+    const map = /* @__PURE__ */ new Map();
+    this.relays.forEach((relay, url) => map.set(url, relay.connected));
+    return map;
+  }
+  destroy() {
+    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;
+  }
+};
+
+// pool.ts
+var _WebSocket;
+try {
+  _WebSocket = WebSocket;
+} catch {
+}
+var SimplePool = class extends AbstractSimplePool {
+  constructor(options) {
+    super({ verifyEvent, websocketImplementation: _WebSocket, maxWaitForConnection: 3e3, ...options });
+  }
+};
+
+// nip46.ts
+var _fetch2;
+try {
+  _fetch2 = fetch;
+} catch {
+}
+function useFetchImplementation(fetchImplementation) {
+  _fetch2 = fetchImplementation;
+}
+var BUNKER_REGEX = /^bunker:\/\/([0-9a-f]{64})\??([?\/\w:.=&%-]*)$/;
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function toBunkerURL(bunkerPointer) {
+  let bunkerURL = new URL(`bunker://${bunkerPointer.pubkey}`);
+  bunkerPointer.relays.forEach((relay) => {
+    bunkerURL.searchParams.append("relay", relay);
+  });
+  if (bunkerPointer.secret) {
+    bunkerURL.searchParams.set("secret", bunkerPointer.secret);
+  }
+  return bunkerURL.toString();
+}
+async function parseBunkerInput(input) {
+  let match = input.match(BUNKER_REGEX);
+  if (match) {
+    try {
+      const pubkey = match[1];
+      const qs = new URLSearchParams(match[2]);
+      return {
+        pubkey,
+        relays: qs.getAll("relay"),
+        secret: qs.get("secret")
+      };
+    } catch (_err) {
+    }
+  }
+  return queryBunkerProfile(input);
+}
+async function queryBunkerProfile(nip05) {
+  const match = nip05.match(NIP05_REGEX);
+  if (!match)
+    return null;
+  const [_, name = "_", domain] = match;
+  try {
+    const url = `https://${domain}/.well-known/nostr.json?name=${name}`;
+    const res = await (await _fetch2(url, { redirect: "error" })).json();
+    let pubkey = res.names[name];
+    let relays = res.nip46[pubkey] || [];
+    return { pubkey, relays, secret: null };
+  } catch (_err) {
+    return null;
+  }
+}
+function createNostrConnectURI(params) {
+  const queryParams = new URLSearchParams();
+  params.relays.forEach((relay) => {
+    queryParams.append("relay", relay);
+  });
+  queryParams.append("secret", params.secret);
+  if (params.perms && params.perms.length > 0) {
+    queryParams.append("perms", params.perms.join(","));
+  }
+  if (params.name) {
+    queryParams.append("name", params.name);
+  }
+  if (params.url) {
+    queryParams.append("url", params.url);
+  }
+  if (params.image) {
+    queryParams.append("image", params.image);
+  }
+  return `nostrconnect://${params.clientPubkey}?${queryParams.toString()}`;
+}
+var BunkerSigner = class {
+  params;
+  pool;
+  subCloser;
+  isOpen;
+  serial;
+  idPrefix;
+  listeners;
+  waitingForAuth;
+  secretKey;
+  conversationKey;
+  bp;
+  cachedPubKey;
+  constructor(clientSecretKey, params) {
+    this.params = params;
+    this.pool = params.pool || new SimplePool();
+    this.secretKey = clientSecretKey;
+    this.isOpen = false;
+    this.idPrefix = Math.random().toString(36).substring(7);
+    this.serial = 0;
+    this.listeners = {};
+    this.waitingForAuth = {};
+  }
+  static fromBunker(clientSecretKey, bp, params = {}) {
+    if (bp.relays.length === 0) {
+      throw new Error("no relays specified for this bunker");
+    }
+    const signer = new BunkerSigner(clientSecretKey, params);
+    signer.conversationKey = getConversationKey(clientSecretKey, bp.pubkey);
+    signer.bp = bp;
+    signer.setupSubscription();
+    return signer;
+  }
+  static async fromURI(clientSecretKey, connectionURI, bunkerParams = {}, maxWaitOrAbort = 3e5) {
+    const signer = new BunkerSigner(clientSecretKey, bunkerParams);
+    const uri = new URL(connectionURI);
+    const clientPubkey = getPublicKey(clientSecretKey);
+    return new Promise((resolve, reject) => {
+      let success = false;
+      const sub = signer.pool.subscribe(
+        uri.searchParams.getAll("relay"),
+        {
+          kinds: [NostrConnect],
+          "#p": [clientPubkey],
+          limit: 0
+        },
+        {
+          onevent: async (event) => {
+            try {
+              const tempConvKey = getConversationKey(clientSecretKey, event.pubkey);
+              const decryptedContent = decrypt(event.content, tempConvKey);
+              const response = JSON.parse(decryptedContent);
+              if (response.result === uri.searchParams.get("secret")) {
+                sub.close();
+                signer.bp = {
+                  pubkey: event.pubkey,
+                  relays: uri.searchParams.getAll("relay"),
+                  secret: uri.searchParams.get("secret")
+                };
+                signer.conversationKey = getConversationKey(clientSecretKey, event.pubkey);
+                signer.setupSubscription();
+                success = true;
+                if (!bunkerParams.skipSwitchRelays) {
+                  await Promise.race([new Promise((resolve2) => setTimeout(resolve2, 1e3)), signer.switchRelays()]);
+                }
+                resolve(signer);
+              }
+            } catch (e) {
+              console.warn("failed to process potential connection event", e);
+            }
+          },
+          onclose: () => {
+            if (!success)
+              reject(new Error("subscription closed before connection was established."));
+          },
+          maxWait: typeof maxWaitOrAbort === "number" ? maxWaitOrAbort : void 0,
+          abort: typeof maxWaitOrAbort !== "number" ? maxWaitOrAbort : void 0
+        }
+      );
+    });
+  }
+  setupSubscription() {
+    const listeners = this.listeners;
+    const waitingForAuth = this.waitingForAuth;
+    const convKey = this.conversationKey;
+    this.subCloser = this.pool.subscribe(
+      this.bp.relays,
+      {
+        kinds: [NostrConnect],
+        authors: [this.bp.pubkey],
+        "#p": [getPublicKey(this.secretKey)],
+        limit: 0
+      },
+      {
+        onevent: async (event) => {
+          const o = JSON.parse(decrypt(event.content, convKey));
+          const { id, result, error } = o;
+          if (result === "auth_url" && waitingForAuth[id]) {
+            delete waitingForAuth[id];
+            if (this.params.onauth) {
+              this.params.onauth(error);
+            } else {
+              console.warn(
+                `nostr-tools/nip46: remote signer ${this.bp.pubkey} tried to send an "auth_url"='${error}' but there was no onauth() callback configured.`
+              );
+            }
+            return;
+          }
+          let handler = listeners[id];
+          if (handler) {
+            if (error)
+              handler.reject(error);
+            else if (result)
+              handler.resolve(result);
+            delete listeners[id];
+          }
+        },
+        onclose: () => {
+          this.subCloser = void 0;
+        }
+      }
+    );
+    this.isOpen = true;
+  }
+  async switchRelays() {
+    try {
+      const switchResp = await this.sendRequest("switch_relays", []);
+      let relays = JSON.parse(switchResp);
+      if (!relays)
+        return false;
+      if (JSON.stringify(relays.sort()) === JSON.stringify(this.bp.relays))
+        return false;
+      this.bp.relays = relays;
+      let previousCloser = this.subCloser;
+      setTimeout(() => {
+        previousCloser.close();
+      }, 5e3);
+      this.subCloser = void 0;
+      this.setupSubscription();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    this.isOpen = false;
+    this.subCloser.close();
+  }
+  async sendRequest(method, params) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!this.isOpen)
+          throw new Error("this signer is not open anymore, create a new one");
+        if (!this.subCloser)
+          this.setupSubscription();
+        this.serial++;
+        const id = `${this.idPrefix}-${this.serial}`;
+        const encryptedContent = encrypt(JSON.stringify({ id, method, params }), this.conversationKey);
+        const verifiedEvent = finalizeEvent(
+          {
+            kind: NostrConnect,
+            tags: [["p", this.bp.pubkey]],
+            content: encryptedContent,
+            created_at: Math.floor(Date.now() / 1e3)
+          },
+          this.secretKey
+        );
+        this.listeners[id] = { resolve, reject };
+        this.waitingForAuth[id] = true;
+        await Promise.any(this.pool.publish(this.bp.relays, verifiedEvent));
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  async ping() {
+    let resp = await this.sendRequest("ping", []);
+    if (resp !== "pong")
+      throw new Error(`result is not pong: ${resp}`);
+  }
+  async connect() {
+    await this.sendRequest("connect", [this.bp.pubkey, this.bp.secret || ""]);
+  }
+  async getPublicKey() {
+    if (!this.cachedPubKey) {
+      this.cachedPubKey = await this.sendRequest("get_public_key", []);
+    }
+    return this.cachedPubKey;
+  }
+  async signEvent(event) {
+    let resp = await this.sendRequest("sign_event", [JSON.stringify(event)]);
+    let signed = JSON.parse(resp);
+    if (verifyEvent(signed)) {
+      return signed;
+    } else {
+      throw new Error(`event returned from bunker is improperly signed: ${JSON.stringify(signed)}`);
+    }
+  }
+  async nip04Encrypt(thirdPartyPubkey, plaintext) {
+    return await this.sendRequest("nip04_encrypt", [thirdPartyPubkey, plaintext]);
+  }
+  async nip04Decrypt(thirdPartyPubkey, ciphertext) {
+    return await this.sendRequest("nip04_decrypt", [thirdPartyPubkey, ciphertext]);
+  }
+  async nip44Encrypt(thirdPartyPubkey, plaintext) {
+    return await this.sendRequest("nip44_encrypt", [thirdPartyPubkey, plaintext]);
+  }
+  async nip44Decrypt(thirdPartyPubkey, ciphertext) {
+    return await this.sendRequest("nip44_decrypt", [thirdPartyPubkey, ciphertext]);
+  }
+};
+async function createAccount(bunker, params, username, domain, email, localSecretKey = generateSecretKey()) {
+  if (email && !EMAIL_REGEX.test(email))
+    throw new Error("invalid email");
+  let rpc = BunkerSigner.fromBunker(localSecretKey, bunker.bunkerPointer, params);
+  let pubkey = await rpc.sendRequest("create_account", [username, domain, email || ""]);
+  rpc.bp.pubkey = pubkey;
+  await rpc.connect();
+  return rpc;
+}
+async function fetchBunkerProviders(pool, relays) {
+  const events = await pool.querySync(relays, {
+    kinds: [Handlerinformation],
+    "#k": [NostrConnect.toString()]
+  });
+  events.sort((a, b) => b.created_at - a.created_at);
+  const validatedBunkers = await Promise.all(
+    events.map(async (event, i2) => {
+      try {
+        const content = JSON.parse(event.content);
+        try {
+          if (events.findIndex((ev) => JSON.parse(ev.content).nip05 === content.nip05) !== i2)
+            return void 0;
+        } catch (err) {
+        }
+        const bp = await queryBunkerProfile(content.nip05);
+        if (bp && bp.pubkey === event.pubkey && bp.relays.length) {
+          return {
+            bunkerPointer: bp,
+            nip05: content.nip05,
+            domain: content.nip05.split("@")[1],
+            name: content.name || content.display_name,
+            picture: content.picture,
+            about: content.about,
+            website: content.website,
+            local: false
+          };
+        }
+      } catch (err) {
+        return void 0;
+      }
+    })
+  );
+  return validatedBunkers.filter((b) => b !== void 0);
+}
+export {
+  BUNKER_REGEX,
+  BunkerSigner,
+  createAccount,
+  createNostrConnectURI,
+  fetchBunkerProviders,
+  parseBunkerInput,
+  queryBunkerProfile,
+  toBunkerURL,
+  useFetchImplementation
+};