internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/keystore-service.d.ts

@@ -1,82 +1,48 @@
-import { AxiosResponse } from 'axios';
-import { KeystoreType, EncryptedKeystore, PublicKeys } from './types.js';
+import { c as EncryptedKeystore, d as KeystoreType, g as PublicKeysBase64, h as PublicKeys } from "./types-Ds3ivE9W.js";
+import { AxiosResponse } from "axios";
 
+//#region src/keystore-service/api.d.ts
 declare class KeyServiceAPI {
-    private readonly baseUrl;
-    constructor(baseUrl: string);
-    /**
-     * Converts the specific client error into a proprietary error for our apps
-     * @param error
-     * @private
-     */
-    private normalizeError;
-    /**
-     * Sends a user's encrypted keystore to the server
-     * @param keystore - The encrypted keystore
-     * @param url - The user specific part of the url
-     * @returns Server response
-     */
-    sendEncryptedKeystoreToServer(encryptedKeystore: string, url: string): Promise<AxiosResponse>;
-    /**
-     * Requests a user's encrypted keystore from the server
-     * @param url - The user-specific part of the url
-     * @returns The user's encrypted keystore as base64 string
-     */
-    requestEncryptedKeystore(userID: string, keystoreType: KeystoreType): Promise<string>;
-    /**
-     * Uploads encrypted keystore to the server
-     *
-     * @param encryptedKeystore - The encrypted keystore
-     * @param type - The keystore's type
-     * @returns Server response
-     */
-    uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse>;
-    /**
-     * Gets a user's encrypted keystore containing encryption keys from the server
-     *
-     * @returns Encrypted keystore containing encryption keys
-     */
-    getEncryptionKeystoreFromServer(): Promise<EncryptedKeystore>;
-    /**
-     * Gets a user's encrypted Identity Keystore from the server
-     *
-     * @returns Encrypted Identity Keystore
-     */
-    getIdentityKeystoreFromServer(): Promise<EncryptedKeystore>;
-    /**
-     * Gets a user's encrypted Recovery Keystore from the server
-     *
-     * @returns Encrypted Recovery Keystore
-     */
-    getRecoveryKeystoreFromServer(): Promise<EncryptedKeystore>;
-    /**
-     * Gets a user's encrypted Index Keystore from the server
-     *
-     * @returns Encrypted Index Keytore
-     */
-    getIndexKeystoreFromServer(): Promise<EncryptedKeystore>;
-    /**
-     * Gets a user's encrypted keystore from the server
-     *
-     * @param type - The requested keystore's type
-     * @returns Encrypted  Keytore
-     */
-    getKeystoreFromServer(type: KeystoreType): Promise<EncryptedKeystore>;
-    /**
-     * Obtains recipients public keys from the server
-     *
-     * @param emails - The recipients' emails
-     * @returns The list of recipients' public keys
-     */
-    getRecipientsPublicKeysFromServer(emails: string[]): Promise<string[]>;
-    /**
-     * Obtains the recipient public keys from the server
-     *
-     * @param email - The recipients' emails
-     * @returns The list of recipients' public keys
-     */
-    getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]>;
+  private readonly baseUrl;
+  constructor(baseUrl: string);
+  /**
+   * Converts the specific client error into a proprietary error for our apps
+   * @param error
+   * @private
+   */
+  private normalizeError;
+  /**
+   * Sends a user's encrypted keystore to the server
+   * @param keystore - The encrypted keystore
+   * @param url - The user specific part of the url
+   * @returns Server response
+   */
+  uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse>;
+  /**
+   * Requests a user's encrypted keystore from the server
+   * @param url - The user-specific part of the url
+   * @returns The user's encrypted keystore as base64 string
+   */
+  getKeystoreFromServer(userID: string, keystoreType: KeystoreType): Promise<EncryptedKeystore>;
+  /**
+   * Obtains recipients public keys from the server
+   *
+   * @param emails - The recipients' emails
+   * @returns The list of recipients' public keys
+   */
+  getRecipientsPublicKeysFromServer(emails: string[]): Promise<PublicKeysBase64[]>;
+  /**
+   * Obtains the recipient public keys from the server
+   *
+   * @param email - The recipients' emails
+   * @returns The list of recipients' public keys
+   */
+  getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]>;
 }
 declare function getKeyServiceAPI(baseUrl: string): KeyServiceAPI;
-
-export { KeyServiceAPI, getKeyServiceAPI };
+declare namespace index_d_exports {
+  export { KeyServiceAPI, getKeyServiceAPI };
+}
+//#endregion
+export { KeyServiceAPI, getKeyServiceAPI, index_d_exports as t };
+//# sourceMappingURL=keystore-service.d.ts.map

package/dist/keystore-service.js

@@ -1,349 +1,122 @@
-'use strict';
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_utils = require('./utils-CNs3cyDj.js');
+let axios = require("axios");
+axios = require_chunk.__toESM(axios);
 
-var axios = require('axios');
-require('@noble/hashes/utils.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var axios__default = /*#__PURE__*/_interopDefault(axios);
-
-// src/keystore-service/api.ts
-
-// src/constants.ts
-var ECC_ALGORITHM = "X25519";
-function uint8ArrayToBase64(buffer) {
-  const array = Uint16Array.from(buffer);
-  const binaryString = new TextDecoder("UTF-16").decode(array);
-  return btoa(binaryString);
-}
-function base64ToUint8Array(str) {
-  const binaryString = atob(str);
-  const len = binaryString.length;
-  const array = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    array[i] = binaryString.charCodeAt(i);
-  }
-  return new Uint8Array(array.buffer);
-}
-
-// src/asymmetric-crypto/keys.ts
-async function importPublicKey(spkiKeyData) {
-  try {
-    return await crypto.subtle.importKey(
-      "spki",
-      spkiKeyData,
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      []
-    );
-  } catch (error) {
-    throw new Error("Failed to import public key", { cause: error });
-  }
-}
-
-// src/utils/aesConverters.ts
-function ciphertextToBase64(encryptedMessage) {
-  try {
-    const ivBase64 = uint8ArrayToBase64(encryptedMessage.iv);
-    const ciphertextBase64 = uint8ArrayToBase64(encryptedMessage.ciphertext);
-    const json = JSON.stringify({ ciphertext: ciphertextBase64, iv: ivBase64 });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert ciphertext to base64", { cause: error });
-  }
-}
-function base64ToCiphertext(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const iv = base64ToUint8Array(obj.iv);
-    const ciphertext = base64ToUint8Array(obj.ciphertext);
-    const result = {
-      ciphertext,
-      iv
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to convert base64 to ciphertext", { cause: error });
-  }
-}
-
-// src/utils/keyConverters.ts
-function encryptedKeystoreToBase64(keystore) {
-  try {
-    const ciphertext = ciphertextToBase64(keystore.encryptedKeys);
-    const json = JSON.stringify({
-      userID: keystore.userID,
-      type: keystore.type.toString(),
-      encryptedKeys: ciphertext
-    });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert encrypted keystore to base64", { cause: error });
-  }
-}
-function base64ToEncryptedKeystore(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const ciphertext = base64ToCiphertext(obj.encryptedKeys);
-    const result = {
-      userID: obj.userID,
-      type: obj.type,
-      encryptedKeys: ciphertext
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to convert base64 to encrypted keystore", { cause: error });
-  }
-}
-async function base64ToPublicKey(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const eccPublicKeyBytes = base64ToUint8Array(obj.eccPublicKey);
-    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);
-    const kyberPublicKey = base64ToUint8Array(obj.kyberPublicKey);
-    return {
-      eccPublicKey,
-      kyberPublicKey
-    };
-  } catch (error) {
-    throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
-  }
-}
-
-// src/storage-service/sessionStorageService.ts
-function get(key) {
-  return sessionStorage.getItem(key);
-}
-function set(key, value) {
-  return sessionStorage.setItem(key, value);
-}
-function removeItem(key) {
-  sessionStorage.removeItem(key);
-}
-function exists(key) {
-  return !!sessionStorage.getItem(key);
-}
-function clear() {
-  sessionStorage.clear();
-}
-var sessionStorageService = {
-  set,
-  get,
-  removeItem,
-  exists,
-  clear
-};
-var sessionStorageService_default = sessionStorageService;
-
-// src/keystore-crypto/core.ts
-function getUserID() {
-  try {
-    const userID = sessionStorageService_default.get("userID");
-    if (!userID) {
-      throw new Error("No UserID");
-    }
-    return userID;
-  } catch (error) {
-    throw new Error("Failed to get UserID from session storage", { cause: error });
-  }
-}
-
-// src/keystore-service/api.ts
+//#region src/keystore-service/api.ts
 var KeyServiceAPI = class {
-  baseUrl;
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-  }
-  /**
-   * Converts the specific client error into a proprietary error for our apps
-   * @param error
-   * @private
-   */
-  normalizeError(error) {
-    let errorMessage;
-    if (error.response?.status === 401) {
-      errorMessage = "Unauthorized: Invalid or expired token";
-    } else if (error.response?.status === 403) {
-      errorMessage = "Forbidden: Insufficient permissions";
-    } else if (error.response?.status === 404) {
-      errorMessage = "Keystore not found for the specified user";
-    } else {
-      errorMessage = "AxiosError:" + (error.message ?? "Unknown error");
-    }
-    throw new Error(errorMessage);
-  }
-  /**
-   * Sends a user's encrypted keystore to the server
-   * @param keystore - The encrypted keystore
-   * @param url - The user specific part of the url
-   * @returns Server response
-   */
-  async sendEncryptedKeystoreToServer(encryptedKeystore, url) {
-    try {
-      const response = await axios__default.default.post(
-        this.baseUrl + `${url}`,
-        { encryptedKeystore },
-        {
-          withCredentials: true,
-          headers: {
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      return response;
-    } catch (error) {
-      if (axios__default.default.isAxiosError(error)) {
-        this.normalizeError(error);
-      }
-      throw new Error("Failed to send keystore", { cause: error });
-    }
-  }
-  /**
-   * Requests a user's encrypted keystore from the server
-   * @param url - The user-specific part of the url
-   * @returns The user's encrypted keystore as base64 string
-   */
-  async requestEncryptedKeystore(userID, keystoreType) {
-    try {
-      const url = `/downloadKeystore/${userID}/${keystoreType.toString()}`;
-      const response = await axios__default.default.get(this.baseUrl + `${url}`, {
-        withCredentials: true,
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      return response.data;
-    } catch (error) {
-      if (axios__default.default.isAxiosError(error)) {
-        this.normalizeError(error);
-      }
-      throw new Error("Failed to retrive keystore", { cause: error });
-    }
-  }
-  /**
-   * Uploads encrypted keystore to the server
-   *
-   * @param encryptedKeystore - The encrypted keystore
-   * @param type - The keystore's type
-   * @returns Server response
-   */
-  async uploadKeystoreToServer(encryptedKeystore) {
-    try {
-      const userID = getUserID();
-      const keystoreType = encryptedKeystore.type;
-      const url = `/uploadKeystore/${userID}/${keystoreType}`;
-      const ciphertextBase64 = encryptedKeystoreToBase64(encryptedKeystore);
-      const result = await this.sendEncryptedKeystoreToServer(ciphertextBase64, url);
-      return result;
-    } catch (error) {
-      throw new Error("Failed to upload keystore to the server", { cause: error });
-    }
-  }
-  /**
-   * Gets a user's encrypted keystore containing encryption keys from the server
-   *
-   * @returns Encrypted keystore containing encryption keys
-   */
-  async getEncryptionKeystoreFromServer() {
-    return this.getKeystoreFromServer("encryption" /* ENCRYPTION */);
-  }
-  /**
-   * Gets a user's encrypted Identity Keystore from the server
-   *
-   * @returns Encrypted Identity Keystore
-   */
-  async getIdentityKeystoreFromServer() {
-    return this.getKeystoreFromServer("identity" /* IDENTITY */);
-  }
-  /**
-   * Gets a user's encrypted Recovery Keystore from the server
-   *
-   * @returns Encrypted Recovery Keystore
-   */
-  async getRecoveryKeystoreFromServer() {
-    return this.getKeystoreFromServer("recovery" /* RECOVERY */);
-  }
-  /**
-   * Gets a user's encrypted Index Keystore from the server
-   *
-   * @returns Encrypted Index Keytore
-   */
-  async getIndexKeystoreFromServer() {
-    return this.getKeystoreFromServer("index" /* INDEX */);
-  }
-  /**
-   * Gets a user's encrypted keystore from the server
-   *
-   * @param type - The requested keystore's type
-   * @returns Encrypted  Keytore
-   */
-  async getKeystoreFromServer(type) {
-    try {
-      const userID = getUserID();
-      const response = await this.requestEncryptedKeystore(userID, type);
-      const result = base64ToEncryptedKeystore(response);
-      return result;
-    } catch (error) {
-      throw new Error("Failed to retrieve keystore from the server", { cause: error });
-    }
-  }
-  /**
-   * Obtains recipients public keys from the server
-   *
-   * @param emails - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  async getRecipientsPublicKeysFromServer(emails) {
-    try {
-      const response = await axios__default.default.get("/api/getPublicKeys", {
-        params: {
-          emails
-        },
-        withCredentials: true,
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      return response.data;
-    } catch (error) {
-      if (axios__default.default.isAxiosError(error)) {
-        this.normalizeError(error);
-      }
-      throw new Error("Failed to retrieve public keys", { cause: error });
-    }
-  }
-  /**
-   * Obtains the recipient public keys from the server
-   *
-   * @param email - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  async getRecipientsPublicKeys(emails) {
-    try {
-      const publicKeysBase64 = await this.getRecipientsPublicKeysFromServer(emails);
-      const result = [];
-      for (const keyBase64 of publicKeysBase64) {
-        const publicKeys = await base64ToPublicKey(keyBase64);
-        result.push(publicKeys);
-      }
-      return result;
-    } catch (error) {
-      throw new Error("Failed to get recipients public keys", { cause: error });
-    }
-  }
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	/**
+	* Converts the specific client error into a proprietary error for our apps
+	* @param error
+	* @private
+	*/
+	normalizeError(error) {
+		let errorMessage;
+		if (error.response?.status === 401) errorMessage = "Unauthorized: Invalid or expired token";
+		else if (error.response?.status === 403) errorMessage = "Forbidden: Insufficient permissions";
+		else if (error.response?.status === 404) errorMessage = "Keystore not found for the specified user";
+		else errorMessage = "AxiosError:" + (error.message ?? "Unknown error");
+		throw new Error(errorMessage);
+	}
+	/**
+	* Sends a user's encrypted keystore to the server
+	* @param keystore - The encrypted keystore
+	* @param url - The user specific part of the url
+	* @returns Server response
+	*/
+	async uploadKeystoreToServer(encryptedKeystore) {
+		try {
+			const url = `${this.baseUrl}/uploadKeystore`;
+			return await axios.default.post(url, { encryptedKeystore }, {
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			});
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to send keystore", { cause: error });
+		}
+	}
+	/**
+	* Requests a user's encrypted keystore from the server
+	* @param url - The user-specific part of the url
+	* @returns The user's encrypted keystore as base64 string
+	*/
+	async getKeystoreFromServer(userID, keystoreType) {
+		try {
+			const url = `${this.baseUrl}/downloadKeystore`;
+			return (await axios.default.get(url, {
+				params: {
+					userID,
+					keystoreType
+				},
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrive keystore", { cause: error });
+		}
+	}
+	/**
+	* Obtains recipients public keys from the server
+	*
+	* @param emails - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeysFromServer(emails) {
+		try {
+			const url = `${this.baseUrl}/getPublicKeys`;
+			return (await axios.default.get(url, {
+				params: { emails },
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrieve public keys", { cause: error });
+		}
+	}
+	/**
+	* Obtains the recipient public keys from the server
+	*
+	* @param email - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeys(emails) {
+		try {
+			const publicKeysBase64 = await this.getRecipientsPublicKeysFromServer(emails);
+			const result = [];
+			for (const keyBase64 of publicKeysBase64) {
+				const publicKeys = await require_utils.base64ToPublicKey(keyBase64);
+				result.push(publicKeys);
+			}
+			return result;
+		} catch (error) {
+			throw new Error("Failed to get recipients public keys", { cause: error });
+		}
+	}
 };
 function getKeyServiceAPI(baseUrl) {
-  return new KeyServiceAPI(baseUrl);
+	return new KeyServiceAPI(baseUrl);
 }
 
+//#endregion
+//#region src/keystore-service/index.ts
+var keystore_service_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	KeyServiceAPI: () => KeyServiceAPI,
+	getKeyServiceAPI: () => getKeyServiceAPI
+});
+
+//#endregion
 exports.KeyServiceAPI = KeyServiceAPI;
 exports.getKeyServiceAPI = getKeyServiceAPI;
-//# sourceMappingURL=keystore-service.js.map
+Object.defineProperty(exports, 'keystore_service_exports', {
+  enumerable: true,
+  get: function () {
+    return keystore_service_exports;
+  }
+});
 //# sourceMappingURL=keystore-service.js.map