create daemon

thrower_daemon/node_modules/nostr-tools/lib/cjs/nipb7.js

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// nipb7.ts
+var nipb7_exports = {};
+__export(nipb7_exports, {
+  BlossomClient: () => BlossomClient
+});
+module.exports = __toCommonJS(nipb7_exports);
+var import_sha256 = require("@noble/hashes/sha256");
+
+// utils.ts
+var import_utils = require("@noble/hashes/utils");
+var utf8Decoder = new TextDecoder("utf-8");
+var utf8Encoder = new TextEncoder();
+
+// nipb7.ts
+var BlossomClient = class {
+  mediaserver;
+  signer;
+  constructor(mediaserver, signer) {
+    if (!mediaserver.startsWith("http")) {
+      mediaserver = "https://" + mediaserver;
+    }
+    this.mediaserver = mediaserver.replace(/\/$/, "") + "/";
+    this.signer = signer;
+  }
+  async httpCall(method, url, contentType, addAuthorization, body, result) {
+    const headers = {};
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    if (addAuthorization) {
+      const auth = await addAuthorization();
+      if (auth) {
+        headers["Authorization"] = auth;
+      }
+    }
+    const response = await fetch(this.mediaserver + url, {
+      method,
+      headers,
+      body
+    });
+    if (response.status >= 300) {
+      const reason = response.headers.get("X-Reason") || response.statusText;
+      throw new Error(`${url} returned an error (${response.status}): ${reason}`);
+    }
+    if (result !== null && response.headers.get("content-type")?.includes("application/json")) {
+      return await response.json();
+    }
+    return response;
+  }
+  async authorizationHeader(modify) {
+    const now = Math.floor(Date.now() / 1e3);
+    const event = {
+      created_at: now,
+      kind: 24242,
+      content: "blossom stuff",
+      tags: [["expiration", String(now + 60)]]
+    };
+    if (modify) {
+      modify(event);
+    }
+    try {
+      const signedEvent = await this.signer.signEvent(event);
+      const eventJson = JSON.stringify(signedEvent);
+      return "Nostr " + btoa(eventJson);
+    } catch (error) {
+      return "";
+    }
+  }
+  isValid32ByteHex(hash) {
+    return /^[a-f0-9]{64}$/i.test(hash);
+  }
+  async check(hash) {
+    if (!this.isValid32ByteHex(hash)) {
+      throw new Error(`${hash} is not a valid 32-byte hex string`);
+    }
+    try {
+      await this.httpCall("HEAD", hash);
+    } catch (error) {
+      throw new Error(`failed to check for ${hash}: ${error}`);
+    }
+  }
+  async uploadBlob(file, contentType) {
+    const hash = (0, import_utils.bytesToHex)((0, import_sha256.sha256)(new Uint8Array(await file.arrayBuffer())));
+    const actualContentType = contentType || file.type || "application/octet-stream";
+    const bd = await this.httpCall(
+      "PUT",
+      "upload",
+      actualContentType,
+      () => this.authorizationHeader((evt) => {
+        evt.tags.push(["t", "upload"]);
+        evt.tags.push(["x", hash]);
+      }),
+      file,
+      {}
+    );
+    return bd;
+  }
+  async uploadFile(file) {
+    return this.uploadBlob(file, file.type);
+  }
+  async download(hash) {
+    if (!this.isValid32ByteHex(hash)) {
+      throw new Error(`${hash} is not a valid 32-byte hex string`);
+    }
+    const authHeader = await this.authorizationHeader((evt) => {
+      evt.tags.push(["t", "get"]);
+      evt.tags.push(["x", hash]);
+    });
+    const response = await fetch(this.mediaserver + hash, {
+      method: "GET",
+      headers: {
+        Authorization: authHeader
+      }
+    });
+    if (response.status >= 300) {
+      throw new Error(`${hash} is not present in ${this.mediaserver}: ${response.status}`);
+    }
+    return await response.arrayBuffer();
+  }
+  async downloadAsBlob(hash) {
+    const arrayBuffer = await this.download(hash);
+    return new Blob([arrayBuffer]);
+  }
+  async list() {
+    const pubkey = await this.signer.getPublicKey();
+    if (!this.isValid32ByteHex(pubkey)) {
+      throw new Error(`pubkey ${pubkey} is not valid`);
+    }
+    try {
+      const bds = await this.httpCall(
+        "GET",
+        `list/${pubkey}`,
+        void 0,
+        () => this.authorizationHeader((evt) => {
+          evt.tags.push(["t", "list"]);
+        }),
+        void 0,
+        []
+      );
+      return bds;
+    } catch (error) {
+      throw new Error(`failed to list blobs: ${error}`);
+    }
+  }
+  async delete(hash) {
+    if (!this.isValid32ByteHex(hash)) {
+      throw new Error(`${hash} is not a valid 32-byte hex string`);
+    }
+    try {
+      await this.httpCall(
+        "DELETE",
+        hash,
+        void 0,
+        () => this.authorizationHeader((evt) => {
+          evt.tags.push(["t", "delete"]);
+          evt.tags.push(["x", hash]);
+        }),
+        void 0,
+        null
+      );
+    } catch (error) {
+      throw new Error(`failed to delete ${hash}: ${error}`);
+    }
+  }
+};