include node_modules so release .zip is deployable

node_modules/nostr-tools/lib/esm/nip47.js

@@ -0,0 +1,123 @@
+// event.ts
+import { schnorr as schnorr2 } from "@noble/curves/secp256k1";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
+
+// keys.ts
+import { schnorr } from "@noble/curves/secp256k1";
+import { bytesToHex } from "@noble/hashes/utils";
+function getPublicKey(privateKey) {
+  return bytesToHex(schnorr.getPublicKey(privateKey));
+}
+
+// utils.ts
+var utf8Decoder = new TextDecoder("utf-8");
+var utf8Encoder = new TextEncoder();
+
+// event.ts
+var verifiedSymbol = Symbol("verified");
+function finishEvent(t, privateKey) {
+  const event = t;
+  event.pubkey = getPublicKey(privateKey);
+  event.id = getEventHash(event);
+  event.sig = getSignature(event, privateKey);
+  event[verifiedSymbol] = true;
+  return event;
+}
+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 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 i = 0; i < event.tags.length; i++) {
+    let tag = event.tags[i];
+    if (!Array.isArray(tag))
+      return false;
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] === "object")
+        return false;
+    }
+  }
+  return true;
+}
+function getSignature(event, key) {
+  return bytesToHex2(schnorr2.sign(getEventHash(event), key));
+}
+
+// nip04.ts
+import { randomBytes } from "@noble/hashes/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { base64 } from "@scure/base";
+if (typeof crypto !== "undefined" && !crypto.subtle && crypto.webcrypto) {
+  crypto.subtle = crypto.webcrypto.subtle;
+}
+async function encrypt(privkey, pubkey, text) {
+  const key = secp256k1.getSharedSecret(privkey, "02" + pubkey);
+  const normalizedKey = getNormalizedX(key);
+  let iv = Uint8Array.from(randomBytes(16));
+  let plaintext = utf8Encoder.encode(text);
+  let cryptoKey = await crypto.subtle.importKey("raw", normalizedKey, { name: "AES-CBC" }, false, ["encrypt"]);
+  let ciphertext = await crypto.subtle.encrypt({ name: "AES-CBC", iv }, cryptoKey, plaintext);
+  let ctb64 = base64.encode(new Uint8Array(ciphertext));
+  let ivb64 = base64.encode(new Uint8Array(iv.buffer));
+  return `${ctb64}?iv=${ivb64}`;
+}
+function getNormalizedX(key) {
+  return key.slice(1, 33);
+}
+
+// nip47.ts
+function parseConnectionString(connectionString) {
+  const { pathname, searchParams } = new URL(connectionString);
+  const pubkey = pathname;
+  const relay = searchParams.get("relay");
+  const secret = searchParams.get("secret");
+  if (!pubkey || !relay || !secret) {
+    throw new Error("invalid connection string");
+  }
+  return { pubkey, relay, secret };
+}
+async function makeNwcRequestEvent({
+  pubkey,
+  secret,
+  invoice
+}) {
+  const content = {
+    method: "pay_invoice",
+    params: {
+      invoice
+    }
+  };
+  const encryptedContent = await encrypt(secret, pubkey, JSON.stringify(content));
+  const eventTemplate = {
+    kind: 23194 /* NwcRequest */,
+    created_at: Math.round(Date.now() / 1e3),
+    content: encryptedContent,
+    tags: [["p", pubkey]]
+  };
+  return finishEvent(eventTemplate, secret);
+}
+export {
+  makeNwcRequestEvent,
+  parseConnectionString
+};