glow.ts 1.0.3 → 1.1.0

package/dist/glow.es.js

@@ -0,0 +1,993 @@
+import { secretbox as k, box as f, randomBytes as K, hash as C } from "tweetnacl";
+import { Mutex as R } from "async-mutex";
+class o {
+  static toBase64(e) {
+    return typeof btoa < "u" ? btoa(this.decode_latin1(e)) : Buffer.from(this.decode_latin1(e), "latin1").toString("base64");
+  }
+  static fromBase64(e) {
+    return typeof btoa < "u" ? this.encode_latin1(atob(e)) : this.encode_latin1(Buffer.from(e, "base64").toString("latin1"));
+  }
+  static encode_latin1(e) {
+    const t = new Uint8Array(e.length);
+    for (let s = 0; s < e.length; s++) {
+      const n = e.charCodeAt(s);
+      if ((n & 255) !== n) throw { message: "Cannot encode string in Latin1", str: e };
+      t[s] = n & 255;
+    }
+    return t;
+  }
+  static decode_latin1(e) {
+    const t = [];
+    for (let s = 0; s < e.length; s++)
+      t.push(String.fromCharCode(e[s]));
+    return t.join("");
+  }
+  static toObject(e) {
+    return Array.from(e).reduce(
+      (t, [s, n]) => Object.assign(t, { [s]: n }),
+      {}
+    );
+  }
+}
+class B {
+  constructor() {
+    this.crypto_secretbox_KEYBYTES = k.keyLength, this.crypto_box_NONCEBYTES = f.nonceLength;
+  }
+  async crypto_secretbox_random_nonce() {
+    return K(k.nonceLength);
+  }
+  async crypto_secretbox(e, t, s) {
+    return k(e, t, s);
+  }
+  async crypto_secretbox_open(e, t, s) {
+    return k.open(e, t, s);
+  }
+  async crypto_box(e, t, s, n) {
+    return f(e, t, s, n);
+  }
+  async crypto_box_open(e, t, s, n) {
+    return f.open(e, t, s, n);
+  }
+  async crypto_box_random_nonce() {
+    return K(f.nonceLength);
+  }
+  async crypto_box_keypair() {
+    const e = f.keyPair();
+    return {
+      boxPk: e.publicKey,
+      boxSk: e.secretKey
+    };
+  }
+  async crypto_box_keypair_from_raw_sk(e) {
+    const t = f.keyPair.fromSecretKey(e);
+    return {
+      boxPk: t.publicKey,
+      boxSk: t.secretKey
+    };
+  }
+  async crypto_box_keypair_from_seed(e) {
+    return this.crypto_box_keypair_from_raw_sk(C(e).subarray(0, f.secretKeyLength));
+  }
+  async crypto_hash_sha256(e) {
+    const t = globalThis.crypto;
+    if (!t || !t.subtle)
+      throw new Error("Web Crypto API is not available. Please use a modern browser or Node.js 16+.");
+    const s = await t.subtle.digest("SHA-256", e);
+    return new Uint8Array(s);
+  }
+  async random_bytes(e) {
+    return K(e);
+  }
+  // Helper methods are based on `js-nacl` implementations
+  // https://github.com/tonyg/js-nacl/blob/cc70775cfc9d68a04905ca65c7f179b33a18066e/nacl_cooked.js
+  async encode_latin1(e) {
+    return o.encode_latin1(e);
+  }
+  async decode_latin1(e) {
+    return o.decode_latin1(e);
+  }
+  async encode_utf8(e) {
+    return this.encode_latin1(unescape(encodeURIComponent(e)));
+  }
+  async decode_utf8(e) {
+    return decodeURIComponent(escape(await this.decode_latin1(e)));
+  }
+  async to_hex(e) {
+    const t = [];
+    for (let s = 0; s < e.length; s++) {
+      const n = "0123456789abcdef";
+      t.push(n[e[s] >> 4 & 15]), t.push(n[e[s] & 15]);
+    }
+    return t.join("");
+  }
+  async from_hex(e) {
+    const t = new Uint8Array(e.length / 2);
+    for (let s = 0; s < e.length / 2; s++)
+      t[s] = parseInt(e.substr(2 * s, 2), 16);
+    return t;
+  }
+  /**
+   * h2(m) = sha256(sha256(64x0 + m))
+   * Zero out initial sha256 block, and double hash 0-padded message
+   * http://cs.nyu.edu/~dodis/ps/h-of-h.pdf
+   */
+  async h2(e) {
+    e instanceof Uint8Array || (e = await this.encode_latin1(e));
+    const t = 64, s = new Uint8Array(t + e.length);
+    return s.fill(0), s.set(e, t), this.crypto_hash_sha256(await this.crypto_hash_sha256(s));
+  }
+}
+class h {
+  constructor() {
+  }
+  static setDefaultInstance() {
+    return this.setInstance(new B());
+  }
+  static setInstance(e) {
+    if (this.driverInstance)
+      throw new Error("[NaCl] NaCl driver has been already set, it is supposed to be set only once");
+    return this.driverInstance = e, !0;
+  }
+  static getInstance() {
+    if (!this.driverInstance)
+      throw new Error("[NaCl] NaCl instance is not yet set");
+    return this.driverInstance;
+  }
+}
+class w {
+  constructor(e) {
+    if (this.keys = e, typeof e == "string") {
+      const { boxPk: t, boxSk: s } = JSON.parse(e);
+      this.keyPair = {
+        boxPk: o.fromBase64(t),
+        boxSk: o.fromBase64(s)
+      };
+    } else
+      this.keyPair = e;
+  }
+  static isEqual(e, t) {
+    return e.toString() === t.toString();
+  }
+  toString() {
+    return JSON.stringify({
+      boxPk: this.publicKey,
+      boxSk: this.privateKey
+    });
+  }
+  get publicKey() {
+    return o.toBase64(this.keyPair.boxPk);
+  }
+  get privateKey() {
+    return o.toBase64(this.keyPair.boxSk);
+  }
+}
+const v = 30 * 1e3, u = {
+  NONCE_TAG: "__nc",
+  SKEY_TAG: "storage_key",
+  STORAGE_ROOT: ".v1.stor.vlt12",
+  // Relay tokens, keys and hashes are 32 bytes
+  RELAY_TOKEN_LEN: 32,
+  // 5 min - Token expiration on the server side, matched with config.x.relay.token_timeout on Zax server
+  RELAY_TOKEN_TIMEOUT: 5 * 60 * 1e3 - v,
+  // 20 min - Session expiration on the server side, matched with config.x.relay.session_timeout on Zax server
+  RELAY_SESSION_TIMEOUT: 20 * 60 * 1e3 - v,
+  // 5 sec - Ajax request timeout
+  RELAY_AJAX_TIMEOUT: 5 * 1e3
+};
+class M {
+  constructor(e = "storage.") {
+    this.rootTag = `__glow.${e}`;
+  }
+  async get(e) {
+    return (await this.getMultiple([e]))[0];
+  }
+  async getMultiple(e) {
+    return e.map((t) => localStorage.getItem(this.tag(t)) || null);
+  }
+  async set(e, t) {
+    return this.setMultiple({ [e]: t });
+  }
+  async setMultiple(e) {
+    for (const t in e) {
+      const s = e[t];
+      s !== null && localStorage.setItem(this.tag(t), s);
+    }
+  }
+  async remove(e) {
+    this.removeMultiple([e]);
+  }
+  async removeMultiple(e) {
+    e.forEach((t) => localStorage.removeItem(this.tag(t)));
+  }
+  tag(e) {
+    return `${this.rootTag}.${e}`;
+  }
+}
+class E {
+  constructor(e, t) {
+    const s = h.getInstance();
+    this.nacl = s, this.driver = e, this.id = t ? `.${t}${u.STORAGE_ROOT}` : u.STORAGE_ROOT;
+  }
+  static async new(e) {
+    const t = this.getStorageDriver(), s = new E(t, e), n = s.addPrefix(u.SKEY_TAG), r = await t.get(n);
+    if (r) {
+      const { key: a } = JSON.parse(r);
+      s.storageKey = o.fromBase64(a);
+    } else
+      s.storageKey = await s.nacl.random_bytes(s.nacl.crypto_secretbox_KEYBYTES), await t.set(n, JSON.stringify({ key: o.toBase64(s.storageKey) }));
+    return s;
+  }
+  static getStorageDriver() {
+    if (this.storageDriver)
+      return this.storageDriver;
+    throw new Error("[CryptoStorage] StorageDriver instance is not yet set");
+  }
+  static setDefaultStorageDriver() {
+    return this.setStorageDriver(new M());
+  }
+  static setStorageDriver(e) {
+    if (this.storageDriver)
+      throw new Error("[CryptoStorage] StorageDriver has been already set, it is supposed to be set only once");
+    return this.storageDriver = e, !0;
+  }
+  async save(e, t) {
+    if (!this.driver)
+      throw new Error("[CryptoStorage] Storage driver is not set");
+    if (!this.storageKey)
+      throw new Error("[CryptoStorage] Storage key is not set");
+    const s = JSON.stringify(t), n = await this.nacl.encode_utf8(s), r = await this.nacl.crypto_secretbox_random_nonce(), a = await this.nacl.crypto_secretbox(n, r, this.storageKey);
+    return await this.driver.setMultiple({
+      [this.addPrefix(e)]: o.toBase64(a),
+      [this.addNonceTag(e)]: o.toBase64(r)
+    }), !0;
+  }
+  async get(e) {
+    if (!this.driver)
+      throw new Error("[CryptoStorage] Storage driver is not set");
+    if (!this.storageKey)
+      throw new Error("[CryptoStorage] Storage key is not set");
+    const [t, s] = await this.driver.getMultiple([this.addPrefix(e), this.addNonceTag(e)]);
+    if (!t || !s)
+      return null;
+    const n = o.fromBase64(t), r = o.fromBase64(s), a = await this.nacl.crypto_secretbox_open(n, r, this.storageKey);
+    if (a) {
+      const c = await this.nacl.decode_utf8(a);
+      return JSON.parse(c);
+    } else
+      throw new Error("[CryptoStorage] crypto_secretbox_open: decryption error");
+  }
+  async remove(e) {
+    if (!this.driver)
+      throw new Error("[CryptoStorage] Storage driver is not set");
+    return await this.driver.removeMultiple([this.addPrefix(e), this.addNonceTag(e)]), !0;
+  }
+  async selfDestruct() {
+    if (!this.driver)
+      throw new Error("[CryptoStorage] Storage driver is not set");
+    await this.driver.remove(this.addPrefix(u.SKEY_TAG));
+  }
+  // Keys are tagged in the storage with a versioned prefix
+  addPrefix(e) {
+    return this.id ? e + this.id : e;
+  }
+  addNonceTag(e) {
+    return this.addPrefix(`${u.NONCE_TAG}.${e}`);
+  }
+}
+const T = "__::commKey::__", y = class y {
+  constructor(e, t, s) {
+    this.guestKeys = /* @__PURE__ */ new Map(), this.nacl = e, this.storage = t, this.commKey = s;
+  }
+  static async new(e) {
+    const t = h.getInstance(), s = await E.new(e), n = await y.getCommKeyOrCreate(t, s), r = new y(t, s, n);
+    return await r.loadGuestKeys(), r;
+  }
+  static async fromBackup(e, t) {
+    const s = JSON.parse(t), n = o.fromBase64(s[T]), r = await y.new(e);
+    await r.setCommFromSecKey(n);
+    for (const [a, c] of Object.entries(s))
+      a !== T && await r.addGuest(a, c);
+    return r;
+  }
+  getNumberOfGuests() {
+    return this.guestKeys.size;
+  }
+  get guests() {
+    return this.guestKeys;
+  }
+  /**
+   * Returns public identity, which is the default communication key.
+   * Correspondents can know it, whereas Relays do not need it (other than
+   * temporarily for internal use during the ownership proof)
+   */
+  getPubCommKey() {
+    return this.commKey.publicKey;
+  }
+  getPrivateCommKey() {
+    return this.commKey.privateKey;
+  }
+  /**
+   * Returns HPK (hash of the public key) of the mailbox. This is what Zax relays
+   * uses as the universal address of the mailbox
+   */
+  async getHpk() {
+    const e = await this.nacl.h2(o.fromBase64(this.commKey.publicKey));
+    return o.toBase64(e);
+  }
+  getTagByHpk(e) {
+    for (const [t, s] of this.guestKeys)
+      if (s.hpk === e)
+        return t;
+    return null;
+  }
+  getGuestKey(e) {
+    const t = this.guestKeys.get(e);
+    return t ? t.pk : null;
+  }
+  // Backups
+  async backup() {
+    const e = {
+      [T]: this.commKey.privateKey
+    };
+    if (this.getNumberOfGuests() > 0)
+      for (const [t, s] of this.guestKeys)
+        t && s && (e[t] = s.pk);
+    return JSON.stringify(e);
+  }
+  async setCommFromSeed(e) {
+    this.commKey = new w(await this.nacl.crypto_box_keypair_from_seed(e)), await this.storage.save(y.commKeyTag, this.commKey.toString());
+  }
+  async setCommFromSecKey(e) {
+    this.commKey = new w(await this.nacl.crypto_box_keypair_from_raw_sk(e)), await this.storage.save(y.commKeyTag, this.commKey.toString());
+  }
+  async addGuest(e, t) {
+    const s = o.toBase64(await this.nacl.h2(o.fromBase64(t)));
+    return this.guestKeys.set(e, {
+      pk: t,
+      hpk: s
+    }), await this.saveGuests(), s;
+  }
+  async removeGuest(e) {
+    return this.guestKeys.has(e) && (this.guestKeys.delete(e), await this.saveGuests()), !0;
+  }
+  async loadGuestKeys() {
+    const e = await this.storage.get(y.guestRegistryTag);
+    if (e)
+      if (typeof e == "object")
+        this.guestKeys = new Map(Object.entries(e));
+      else
+        throw new Error("[Keyring] Guest keys is not an object");
+    else return;
+  }
+  async saveGuests() {
+    await this.storage.save(y.guestRegistryTag, o.toObject(this.guestKeys.entries()));
+  }
+  static async getCommKeyOrCreate(e, t) {
+    const s = await t.get(y.commKeyTag);
+    if (s && typeof s == "string")
+      return new w(s);
+    {
+      const n = await e.crypto_box_keypair(), r = new w(n);
+      return await t.save(y.commKeyTag, r.toString()), r;
+    }
+  }
+  async selfDestruct() {
+    await this.storage.remove(y.guestRegistryTag), await this.storage.remove(y.commKeyTag), await this.storage.selfDestruct();
+  }
+};
+y.commKeyTag = "comm_key", y.guestRegistryTag = "guest_registry";
+let S = y;
+class p {
+  constructor() {
+  }
+  /**
+   * Encodes a binary message with `cryptobox`
+   */
+  static async encodeMessage(e, t, s, n) {
+    const r = h.getInstance(), a = await this.makeNonce(n), c = await r.crypto_box(e, a, t, s);
+    return {
+      nonce: o.toBase64(a),
+      ctext: o.toBase64(c)
+    };
+  }
+  /**
+   * Decodes a binary message with `cryptobox_open`
+   * @returns null if failed to decode
+   */
+  static async decodeMessage(e, t, s, n) {
+    const r = h.getInstance(), a = await r.crypto_box_open(t, e, s, n);
+    return a && await r.decode_utf8(a);
+  }
+  /**
+   * Encodes a binary message with `secretbox` (used for file chunk encryption)
+   */
+  static async encodeMessageSymmetric(e, t) {
+    const s = h.getInstance(), n = await p.makeNonce(), r = await s.crypto_secretbox(e, n, t);
+    return {
+      nonce: o.toBase64(n),
+      ctext: o.toBase64(r)
+    };
+  }
+  /**
+   * Decodes a binary message with `secretbox_open` (used for file chunk decryption)
+   */
+  static async decodeMessageSymmetric(e, t, s) {
+    return await h.getInstance().crypto_secretbox_open(o.fromBase64(t), o.fromBase64(e), s);
+  }
+  // ---------- Nonce helper ----------
+  /**
+   * Makes a timestamp nonce that a relay expects for any crypto operations.
+   * Timestamp is the first 8 bytes, the rest is random, unless custom `data`
+   * is specified. `data` will be packed as next 4 bytes after timestamp.
+   */
+  static async makeNonce(e) {
+    const t = h.getInstance(), s = await t.crypto_box_random_nonce();
+    let n;
+    if (s.length !== t.crypto_box_NONCEBYTES)
+      throw new Error("[Mailbox] Wrong crypto_box nonce length");
+    n = 8;
+    const r = this.itoa(Math.floor(Date.now() / 1e3));
+    if (e && (n += 4), s.fill(0, 0, n), s.set(r, 8 - r.length), e) {
+      const a = this.itoa(e);
+      s.set(a, 12 - a.length);
+    }
+    return s;
+  }
+  /**
+   * Splits an integer into an array of bytes
+   */
+  static itoa(e) {
+    let t = e.toString(16);
+    t = t.length & 1 ? `0${t}` : t;
+    const s = t.length / 2, n = new Uint8Array(s);
+    for (let r = 0, a = 0; a < t.length; a += 2, r++)
+      n[r] = parseInt(t[a] + t[a + 1], 16);
+    return n;
+  }
+}
+var l = /* @__PURE__ */ ((i) => (i.count = "count", i.upload = "upload", i.download = "download", i.messageStatus = "messageStatus", i.delete = "delete", i.startFileUpload = "startFileUpload", i.uploadFileChunk = "uploadFileChunk", i.downloadFileChunk = "downloadFileChunk", i.fileStatus = "fileStatus", i.deleteFile = "deleteFile", i))(l || {}), b = /* @__PURE__ */ ((i) => (i.message = "message", i.file = "file", i.plain = "plain", i))(b || {});
+class _ extends Error {
+  constructor(e) {
+    super(`GlowNetworkError status: ${e}`), this.status = e, this.name = "GlowNetworkError";
+  }
+}
+class N {
+  constructor(e) {
+    this.url = e, this.difficulty = 0, this.nacl = h.getInstance();
+  }
+  get isConnected() {
+    return !!(this.sessionKeys && this.publicKey);
+  }
+  // ---------- Connection initialization ----------
+  /**
+   * Exchanges tokens with a relay and gets a temp session key for this relay.
+   * Returns h₂(signature) and a relay public key
+   */
+  async openConnection() {
+    this.sessionKeys = new w(await this.nacl.crypto_box_keypair()), this.clientToken = await this.nacl.random_bytes(u.RELAY_TOKEN_LEN);
+    const e = await this.fetchRelayToken();
+    return this.publicKey = await this.fetchRelayPublicKey(e), {
+      h2Signature: await this.getSignature(e, this.sessionKeys),
+      relayPublicKey: this.publicKey
+    };
+  }
+  /**
+   * Sends a client token to a relay and saves a relay token
+   */
+  async fetchRelayToken() {
+    if (!this.clientToken)
+      throw new Error("[Relay] clientToken is required please openConnection first");
+    const e = await this.httpCall("start_session", o.toBase64(this.clientToken));
+    this.scheduleTokenExpiration();
+    const [t, s] = this.parseResponse("start_session", e);
+    return this.difficulty = parseInt(s, 10), this.difficulty > 10 && console.log(`[Relay] ${this.url} requested difficulty ${this.difficulty}. Session handshake may take longer.`), o.fromBase64(t);
+  }
+  /**
+   * Completes the handshake and saves a relay pubic key
+   */
+  async fetchRelayPublicKey(e) {
+    if (!this.clientToken)
+      throw new Error("[Relay] clientToken is required please openConnection first");
+    const t = o.toBase64(await this.nacl.h2(this.clientToken)), s = new Uint8Array([...this.clientToken, ...e]);
+    let n;
+    this.difficulty === 0 ? n = await this.nacl.h2(s) : n = await this.ensureNonceDifficulty(s);
+    const r = await this.httpCall("verify_session", t, o.toBase64(n));
+    return o.fromBase64(r);
+  }
+  /**
+   * Attaches a mailbox and fetches number of messages
+   */
+  async prove(e) {
+    if (!this.clientToken)
+      throw new Error("[Relay] clientToken is required please openConnection first");
+    if (!this.sessionKeys)
+      throw new Error("[Relay] No session key found, open the connection first");
+    const t = o.toBase64(await this.nacl.h2(this.clientToken)), s = await this.httpCall(
+      "prove",
+      t,
+      this.sessionKeys.publicKey,
+      e.nonce,
+      e.ctext
+    );
+    return this.scheduleSessionExpiration(), s;
+  }
+  async encodeMessage(e) {
+    if (!this.publicKey)
+      throw new Error("[Relay] No relay public key found, open the connection first");
+    if (!this.sessionKeys)
+      throw new Error("[Relay] No session key found, open the connection first");
+    return await p.encodeMessage(
+      await this.nacl.encode_utf8(e),
+      this.publicKey,
+      o.fromBase64(this.sessionKeys?.privateKey)
+    );
+  }
+  async decodeMessage(e, t) {
+    const s = this.publicKey;
+    if (!s)
+      throw new Error("[Relay] No relay public key found, open the connection first");
+    if (!this.sessionKeys)
+      throw new Error("[Relay] No session key found, open the connection first");
+    const n = await p.decodeMessage(
+      o.fromBase64(e),
+      o.fromBase64(t),
+      s,
+      o.fromBase64(this.sessionKeys.privateKey)
+    );
+    if (n === null)
+      throw new Error("[Relay] failed to decode message");
+    return JSON.parse(n);
+  }
+  // ---------- Low-level server request handling ----------
+  /**
+   * Executes a message/file command on a relay, parses and validates the response
+   */
+  async runCmd(e, t, s, n) {
+    if (!Object.keys(l).includes(e))
+      throw new Error(`[Relay] ${this.url} doesn't support command ${e}`);
+    const r = [t, s.nonce, s.ctext];
+    n && r.push(n);
+    const a = await this.httpCall("command", ...r);
+    return this.parseResponse(e, a);
+  }
+  async getSignature(e, t) {
+    if (!this.clientToken)
+      throw new Error("[Relay] clientToken is required please openConnection first");
+    const s = o.fromBase64(t.publicKey), n = new Uint8Array([...s, ...e, ...this.clientToken]);
+    return await this.nacl.h2(n);
+  }
+  /**
+   * Executes a call to a relay and return raw string response
+   */
+  // TODO: extract fetching into separate function
+  async httpCall(e, ...t) {
+    const s = new AbortController(), n = setTimeout(() => s.abort(), u.RELAY_AJAX_TIMEOUT), r = {
+      method: "POST",
+      headers: {
+        Accept: "text/plain",
+        "Content-Type": "text/plain"
+      },
+      body: t.join(`\r
+`),
+      signal: s.signal
+    };
+    try {
+      const a = await fetch(`${this.url}/${e}`, r);
+      if (!a.ok)
+        throw a.status === 401 && (this.clearSession(), this.clearToken()), new _(a.status);
+      return await a.text();
+    } catch (a) {
+      throw a instanceof Error && a.name === "AbortError" ? new _(408) : a instanceof _ ? a : a instanceof TypeError ? new _(0) : a;
+    } finally {
+      clearTimeout(n);
+    }
+  }
+  /**
+   * Parses relay response and throws an error if its format is unexpected
+   */
+  parseResponse(e, t) {
+    const s = t.split(`\r
+`);
+    if (!t || !this.validateResponse(e, s.length))
+      throw console.log(s), new Error(`[Relay] ${this.url} - ${e}: Bad response`);
+    return s;
+  }
+  /**
+   * Compares the expected number of lines in response with what was actually received from a relay
+   */
+  validateResponse(e, t) {
+    switch (e) {
+      case l.upload:
+      case l.messageStatus:
+      case l.delete:
+        return t === 1;
+      case l.downloadFileChunk:
+        return t === 3;
+      default:
+        return t === 2;
+    }
+  }
+  /**
+   * delete token locally before it was removed on server so will reconnect without getting unauthorized error
+   */
+  scheduleTokenExpiration() {
+    this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.tokenExpirationTimeoutHandle = setTimeout(() => this.clearToken(), u.RELAY_TOKEN_TIMEOUT);
+  }
+  clearToken() {
+    this.tokenExpirationTimeoutHandle && clearTimeout(this.tokenExpirationTimeoutHandle), this.clientToken && delete this.clientToken;
+  }
+  /**
+   * established session is valid only for some period need to remove it after it's ttl
+   * so relay will reconnect without receiving error from server
+   */
+  scheduleSessionExpiration() {
+    this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionExpirationTimeoutHandle = setTimeout(() => {
+      this.clearSession();
+    }, u.RELAY_SESSION_TIMEOUT);
+  }
+  clearSession() {
+    this.sessionExpirationTimeoutHandle && clearTimeout(this.sessionExpirationTimeoutHandle), this.sessionKeys && delete this.sessionKeys;
+  }
+  // ---------- Difficulty adjustment ----------
+  /**
+   * Continuously calculates the nonce until one requested by a relay is found
+   */
+  async ensureNonceDifficulty(e) {
+    let t, s;
+    do
+      t = await this.nacl.random_bytes(32), s = await this.nacl.h2(new Uint8Array([...e, ...t]));
+    while (!this.arrayZeroBits(s));
+    return t;
+  }
+  /**
+   * Returns `true` if the rightmost n bits of a byte are 0.
+   * Check whether the rightmost difficulty bits of an Uint8Array are 0, where
+   * the lowest indexes of the array represent those rightmost bits. Thus if
+   * the difficulty is 17, then array[0] and array[1] should be 0, as should the
+   * rightmost bit of array[2]. This is used for our difficulty settings in Zax to
+   * reduce burden on a busy server by ensuring clients have to do some
+   * additional work during the session handshake
+   */
+  arrayZeroBits(e) {
+    let t, s = this.difficulty;
+    for (let n = 0; n <= 1 + this.difficulty / 8; n++) {
+      if (t = e[n], s <= 0)
+        return !0;
+      if (s > 8) {
+        if (s -= 8, t > 0)
+          return !1;
+      } else
+        return this.firstZeroBits(t, s);
+    }
+    return !1;
+  }
+  /**
+   * Returns `true` if the rightmost n bits of a byte are 0
+   */
+  firstZeroBits(e, t) {
+    return e === e >> t << t;
+  }
+}
+class O {
+  constructor() {
+    this.relays = {};
+  }
+  /**
+   * Relay factory, that returns a Relay instance for a given URL,
+   * or creates a new one if it hasn't yet been initialized.
+   */
+  getInstance(e) {
+    let t = this.relays[e];
+    return t || (t = this.relays[e] = new N(e)), t;
+  }
+}
+class x {
+  constructor(e, t, s) {
+    this.relayFactory = new O(), this.relayConnectionMutexes = /* @__PURE__ */ new Map(), this.nacl = e, this.keyRing = t, this.identity = s;
+  }
+  static async new(e) {
+    return new x(h.getInstance(), await S.new(e), e);
+  }
+  // ---------- Alternative initializers ----------
+  /**
+   * Create a Mailbox where the secret identity key is derived from a well-known seed
+   */
+  static async fromSeed(e, t) {
+    const s = await this.new(e);
+    return t instanceof Uint8Array || (t = o.encode_latin1(t)), await s.keyRing.setCommFromSeed(t), s;
+  }
+  /**
+   * Create a Mailbox from the known secret identity key
+   */
+  static async fromSecKey(e, t) {
+    const s = await this.new(e);
+    return t instanceof Uint8Array || (t = o.fromBase64(t)), await s.keyRing.setCommFromSecKey(t), s;
+  }
+  /**
+   * Create a Mailbox from the backup string
+   */
+  static async fromBackup(e, t) {
+    return new x(h.getInstance(), await S.fromBackup(e, t), e);
+  }
+  // ---------- Relay message commands (public API) ----------
+  /**
+   * Sends a free-form object to a guest we already have in our keyring. Set `encrypt` to `false` to
+   * send a plaintext message. Returns a token that can be used with `messageStatus` command to check
+   * the status of the message
+   */
+  async upload(e, t, s, n = !0) {
+    const r = await this.prepareRelay(e), a = this.getGuestKey(t), c = n ? await this.encodeMessage(t, s) : s, d = o.toBase64(await this.nacl.h2(o.fromBase64(a))), [g] = await this.runRelayCommand(r, l.upload, { to: d, payload: c });
+    return g;
+  }
+  /**
+   * Downloads all messages from a relay, decrypts them with a relay key,
+   * and then parses each message to find out if it's a text message, file message,
+   * or if it can't be decrypted because HPK is missing in the keyring.
+   * Returns an array of mixed messages
+   */
+  async download(e) {
+    const t = await this.prepareRelay(e), s = await this.runRelayCommand(t, l.download), n = await this.decryptResponse(t, s), r = [];
+    for (const a of n) {
+      const c = this.keyRing.getTagByHpk(a.from);
+      if (!c)
+        r.push(await this.parsePlainMessage(a));
+      else if (a.kind === "message")
+        r.push(await this.parseTextMessage(a, c));
+      else if (a.kind === "file")
+        r.push(await this.parseFileMessage(a, c));
+      else
+        throw new Error("[Mailbox] download - Unknown message type");
+    }
+    return r;
+  }
+  /**
+   * Marks a raw Zax message as one that can't be decrypted,
+   * because sender's HPK is not found in the keyring
+   */
+  async parsePlainMessage({ data: e, time: t, from: s, nonce: n }) {
+    return { data: e, time: t, from: s, nonce: n, kind: b.plain };
+  }
+  /**
+   * Decrypts a message that represents uploaded file metadata
+   */
+  async parseFileMessage(e, t) {
+    const { nonce: s, ctext: n, uploadID: r } = JSON.parse(e.data), a = await this.decodeMessage(t, s, n);
+    if (a === null)
+      throw new Error("[Mailbox] Failed to decode file message");
+    return { data: JSON.parse(a), time: e.time, senderTag: t, uploadID: r, nonce: s, kind: b.file };
+  }
+  /**
+   * Attempts to decrypt a regular encrypted Zax message. Returns plain message if it was sent encrypted
+   */
+  async parseTextMessage(e, t) {
+    let s = await this.decodeMessage(t, e.nonce, e.data);
+    return s || (s = e.data), { data: s, time: e.time, senderTag: t, nonce: e.nonce, kind: b.message };
+  }
+  /**
+   * Returns the number of messages in the mailbox on a given relay
+   */
+  async count(e) {
+    const t = await this.prepareRelay(e), s = await this.runRelayCommand(t, l.count);
+    return await this.decryptResponse(t, s);
+  }
+  /**
+  * Deletes messages from a relay given a list of base64 message nonces,
+  * and returns the number of remaining messages
+  */
+  async delete(e, t) {
+    const s = await this.prepareRelay(e), [n] = await this.runRelayCommand(s, l.delete, { payload: t });
+    return parseInt(n, 10);
+  }
+  /**
+  * Gets the status of a previously sent Zax message by a storage token.
+  * Returns "time to live" in seconds or a negative value if it's not applicable.
+  * See `MessageStatusResponse` values for reference
+  */
+  async messageStatus(e, t) {
+    const s = await this.prepareRelay(e), [n] = await this.runRelayCommand(s, l.messageStatus, { token: t });
+    return parseInt(n, 10);
+  }
+  // ---------- Relay file commands (public API) ----------
+  /**
+   * Asks Zax to start a new upload session, and returns a unique file identifier
+   * required to upload file chunks.
+   */
+  async startFileUpload(e, t, s) {
+    const n = await this.prepareRelay(e), r = this.getGuestKey(t), a = o.toBase64(await this.nacl.h2(o.fromBase64(r))), c = await this.nacl.random_bytes(this.nacl.crypto_secretbox_KEYBYTES);
+    s.skey = o.toBase64(c);
+    const d = await this.encodeMessage(t, JSON.stringify(s)), g = await this.runRelayCommand(n, l.startFileUpload, {
+      to: a,
+      file_size: s.orig_size,
+      metadata: d
+    }), m = await this.decryptResponse(n, g);
+    return m.skey = c, m;
+  }
+  /**
+   * Encrypts the file chunk symmetrically and transfers it to a relay
+   */
+  async uploadFileChunk(e, t, s, n, r, a) {
+    const c = await this.prepareRelay(e), d = await p.encodeMessageSymmetric(s, a), g = await this.runRelayCommand(c, l.uploadFileChunk, {
+      uploadID: t,
+      part: n,
+      last_chunk: r - 1 === n,
+      // marker of the last chunk, sent only once
+      nonce: d.nonce
+    }, d.ctext);
+    return await this.decryptResponse(c, g);
+  }
+  /**
+   * Returns the status of a file upload by its relay-specific uploadID. Uploader can call it
+   * to verify the correct transfer, and downloader can check if the file exists and retrieve
+   * the number of chunks
+   */
+  async getFileStatus(e, t) {
+    const s = await this.prepareRelay(e), n = await this.runRelayCommand(s, l.fileStatus, { uploadID: t });
+    return await this.decryptResponse(s, n);
+  }
+  /**
+   * Fetches the file metadata by uploadID, which was declared by the uploader
+   */
+  async getFileMetadata(e, t) {
+    return (await this.download(e)).filter((r) => r.kind === "file").find((r) => r.uploadID === t)?.data;
+  }
+  /**
+   * Downloads a binary chunk of a file from a relay by a given uploadID. The total number of chunks
+   * can be retrieved via a `getFileStatus` request
+   */
+  async downloadFileChunk(e, t, s, n) {
+    n instanceof Uint8Array || (n = o.fromBase64(n));
+    const r = await this.prepareRelay(e), a = await this.runRelayCommand(r, l.downloadFileChunk, { uploadID: t, part: s }), [c, d, g] = a, m = await r.decodeMessage(c, d);
+    return await p.decodeMessageSymmetric(m.nonce, g, n);
+  }
+  /**
+   * Deletes a file from the relay (or all chunks uploaded so far, if the upload was not completed).
+   * Can be called by either the sender or recipient
+   */
+  async deleteFile(e, t) {
+    const s = await this.prepareRelay(e), n = await this.runRelayCommand(s, l.deleteFile, { uploadID: t });
+    return await this.decryptResponse(s, n);
+  }
+  // ---------- Dealing with Relay ----------
+  /**
+   * Establishes a session, exchanges temp keys and proves our ownership of this
+   * Mailbox to this specific relay. This is the first function to start
+   * communications with any relay. Returns the number of messages in the mailbox
+   */
+  async connectToRelay(e) {
+    const t = this.relayFactory.getInstance(e), s = await t.openConnection(), n = await this.encryptSignature(s), r = await t.prove(await t.encodeMessage(JSON.stringify({
+      pub_key: this.keyRing.getPubCommKey(),
+      nonce: n.nonce,
+      ctext: n.ctext
+    })));
+    return parseInt(r, 10);
+  }
+  clearSession(e) {
+    const t = this.relayFactory.getInstance(e);
+    t.clearToken(), t.clearSession();
+  }
+  async encryptSignature(e) {
+    const t = o.fromBase64(this.keyRing.getPrivateCommKey());
+    return await p.encodeMessage(e.h2Signature, e.relayPublicKey, t);
+  }
+  /**
+   * Gets a singleton Relay instance, and reconnects to a relay if a previous token has expired
+   */
+  async prepareRelay(e) {
+    const t = this.relayFactory.getInstance(e);
+    return await this.getRelayConnectionMutex(e).runExclusive(async () => {
+      t.isConnected || await this.connectToRelay(e);
+    }), t;
+  }
+  /**
+   * Encrypts the payload of the command and sends it to a relay
+   */
+  async runRelayCommand(e, t, s, n) {
+    s = { cmd: t, ...s };
+    const r = await this.keyRing.getHpk(), a = await e.encodeMessage(JSON.stringify(s));
+    return await e.runCmd(t, r, a, n);
+  }
+  /**
+   * Parses relay's response to a command, for those commands that expect an encrypted message in return.
+   * Two lines of POST response will be nonce and ctext
+   */
+  async decryptResponse(e, t) {
+    const [s, n] = t;
+    return await e.decodeMessage(s, n);
+  }
+  // ---------- Message encoding / decoding ----------
+  /**
+   * Encodes `message` to the guest key of a guest already
+   * added to the keyring
+   */
+  async encodeMessage(e, t) {
+    const s = this.getGuestKey(e), n = this.keyRing.getPrivateCommKey();
+    return await p.encodeMessage(
+      await this.nacl.encode_utf8(t),
+      o.fromBase64(s),
+      o.fromBase64(n)
+    );
+  }
+  /**
+   * Decodes a ciphertext from a guest key already in our keyring with this nonce
+   * @returns null if failed to decode
+   */
+  async decodeMessage(e, t, s) {
+    const n = this.getGuestKey(e), r = this.keyRing.getPrivateCommKey();
+    let a;
+    try {
+      a = o.fromBase64(s);
+    } catch {
+      return null;
+    }
+    return await p.decodeMessage(
+      o.fromBase64(t),
+      a,
+      o.fromBase64(n),
+      o.fromBase64(r)
+    );
+  }
+  /**
+   * Wrapper around `keyring.getGuestKey` that handles unknown guests
+   */
+  getGuestKey(e) {
+    const t = this.keyRing.getGuestKey(e);
+    if (!t)
+      throw new Error(`[Mailbox] Unknown guest ${e}`);
+    return t;
+  }
+  // ---------- Destroying Mailbox ----------
+  /**
+   * Deletes a Mailbox and all its data from local CryptoStorage. This is a very
+   * destructive operation, use with caution - it will delete the Mailbox
+   * keyring along with all stored public keys. To restore that information, you
+   * will need to do another key exchange with all the guests on your keyring.
+   */
+  async selfDestruct() {
+    await this.keyRing.selfDestruct();
+  }
+  getRelayConnectionMutex(e) {
+    return this.relayConnectionMutexes.has(e) || this.relayConnectionMutexes.set(e, new R()), this.relayConnectionMutexes.get(e);
+  }
+}
+class A {
+  constructor() {
+    this.storage = {};
+  }
+  async get(e) {
+    return (await this.getMultiple([e]))[0];
+  }
+  async getMultiple(e) {
+    return e.map((t) => this.storage[t]);
+  }
+  set(e, t) {
+    return this.setMultiple({ [e]: t });
+  }
+  async setMultiple(e) {
+    for (const t in e)
+      this.storage[t] = e[t];
+  }
+  remove(e) {
+    return this.removeMultiple([e]);
+  }
+  async removeMultiple(e) {
+    e.forEach((t) => delete this.storage[t]);
+  }
+  reset() {
+    this.storage = {};
+  }
+}
+export {
+  E as CryptoStorage,
+  _ as GlowNetworkError,
+  A as InMemoryStorage,
+  B as JsNaClDriver,
+  S as KeyRing,
+  w as Keys,
+  M as LocalStorageDriver,
+  x as Mailbox,
+  h as NaCl,
+  N as Relay,
+  o as Utils,
+  b as ZaxMessageKind
+};
+//# sourceMappingURL=glow.es.js.map