internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/keystore-crypto-B4yCVo9l.js

@@ -0,0 +1,182 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_constants = require('./constants-Ccp21E03.js');
+const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
+const require_utils = require('./utils-CNs3cyDj.js');
+const require_hash = require('./hash-BoqwNkcd.js');
+const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
+const require_derive_key = require('./derive-key-CBf2WxJd.js');
+const require_email_crypto = require('./email-crypto-BrT98taw.js');
+const require_types = require('./types-52g887Zi.js');
+
+//#region src/keystore-crypto/core.ts
+/**
+* Encrypts the keystore content using symmetric encryption
+*
+* @param secretKey - The symmetric key to encrypt the keystore content
+* @param content - The content of the keystore
+* @param userID - The ID of the user
+* @param tag - The keystore type-specific tag string
+* @returns The encrypted keystore content
+*/
+async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
+	try {
+		const aux = require_utils.UTF8ToUint8(userEmail + type);
+		const publicKeys = await require_utils.publicKeyToBase64(keys.publicKeys);
+		const kyberPrivateKeyEnc = await require_symmetric_crypto.encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);
+		const eccPrivateKeyEnc = await require_symmetric_crypto.encryptSymmetrically(secretKey, await require_asymmetric_crypto.exportPrivateKey(keys.privateKeys.eccPrivateKey), aux);
+		return {
+			userEmail,
+			type,
+			encryptedKeys: {
+				publicKeys,
+				privateKeys: {
+					kyberPrivateKeyBase64: require_utils.uint8ArrayToBase64(kyberPrivateKeyEnc),
+					eccPrivateKeyBase64: require_utils.uint8ArrayToBase64(eccPrivateKeyEnc)
+				}
+			}
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt keystore content", { cause: error });
+	}
+}
+/**
+* Decrypts the keystore content using symmetric encryption
+*
+* @param secretKey - The symmetric key to decrypt the keystore content
+* @param encryptedKeys - The encrypted keystore content
+* @param userEmail - The ID of the user
+* @param tag - The keystore type-specific tag string
+* @returns The decrypted keystore content
+*/
+async function decryptKeystoreContent(secretKey, encryptedKeystore) {
+	try {
+		const aux = require_utils.UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
+		const kyberPublicKey = require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);
+		const eccPublicKey = await require_asymmetric_crypto.importPublicKey(require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64));
+		const kyberPrivateKey = await require_symmetric_crypto.decryptSymmetrically(secretKey, require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64), aux);
+		const eccPrivateKey = await require_asymmetric_crypto.importPrivateKey(await require_symmetric_crypto.decryptSymmetrically(secretKey, require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64), aux));
+		return {
+			publicKeys: {
+				kyberPublicKey,
+				eccPublicKey
+			},
+			privateKeys: {
+				kyberPrivateKey,
+				eccPrivateKey
+			}
+		};
+	} catch (error) {
+		throw new Error("Failed to decrypt keystore content", { cause: error });
+	}
+}
+/**
+* Derives a secret key for protecting the recovery keystore
+*
+* @param recoveryCodes - The recovery codes
+* @returns The derived secret key for protecting the recovery keystore
+*/
+async function deriveRecoveryKey(recoveryCodes) {
+	const recoverCodesArray = require_utils.mnemonicToBytes(recoveryCodes);
+	return require_derive_key.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_RECOVERY, require_hash.getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, recoverCodesArray));
+}
+/**
+* Derives a secret key for protecting the encryption keystore
+*
+* @param baseKey - The base secret key from which a new key secret will be derived
+* @returns The derived secret key for protecting the encryption keystore
+*/
+async function deriveEncryptionKeystoreKey(baseKey) {
+	return require_derive_key.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, baseKey);
+}
+
+//#endregion
+//#region src/keystore-crypto/emailEncryptionKey.ts
+/**
+* Generates email keys and creates encrypted main and recovery keystores
+* The main keystore encryption key is derived from the base key (stored in session storage)
+* The recovery keystore encryption key is derived from the recovery codes
+*
+* @returns The encryption and recovery keystores, recovery codes and email keys
+*/
+async function createEncryptionAndRecoveryKeystores(userEmail, baseKey) {
+	try {
+		const keys = await require_email_crypto.generateEmailKeys();
+		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), keys, userEmail, require_types.KeystoreType.ENCRYPTION);
+		const recoveryCodes = require_utils.genMnemonic();
+		return {
+			encryptionKeystore,
+			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, require_types.KeystoreType.RECOVERY),
+			recoveryCodes,
+			keys
+		};
+	} catch (error) {
+		throw new Error("Failed to create encryption and recovery keystores", { cause: error });
+	}
+}
+/**
+* Opens the encryption keystore and returns the email encryption keys
+* The decryption key is derived from the base key (stored in session storage)
+*
+* @param encryptedKeystore - The encrypted keystore containing encryption keys
+* @param baseKey - The base key from which the decryption key will be derived
+* @returns The encryption keys
+*/
+async function openEncryptionKeystore(encryptedKeystore, baseKey) {
+	try {
+		if (encryptedKeystore.type != require_types.KeystoreType.ENCRYPTION) throw new Error("Input is invalid");
+		return await decryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), encryptedKeystore);
+	} catch (error) {
+		throw new Error("Failed to open encryption keystore", { cause: error });
+	}
+}
+/**
+* Opens the recovery keystore and returns the email encryption keys
+* The decryption key is derived from the base key (stored in session storage)
+*
+* @param recoveryCodes - The user's recovery codes
+* @param encryptedKeystore - The encrypted keystore containing encryption keys
+* @returns The encryption keys
+*/
+async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
+	try {
+		if (encryptedKeystore.type != require_types.KeystoreType.RECOVERY) throw new Error("Input is invalid");
+		return await decryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), encryptedKeystore);
+	} catch (error) {
+		throw new Error("Failed to open recovery keystore", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/keystore-crypto/index.ts
+var keystore_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	createEncryptionAndRecoveryKeystores: () => createEncryptionAndRecoveryKeystores,
+	openEncryptionKeystore: () => openEncryptionKeystore,
+	openRecoveryKeystore: () => openRecoveryKeystore
+});
+
+//#endregion
+Object.defineProperty(exports, 'createEncryptionAndRecoveryKeystores', {
+  enumerable: true,
+  get: function () {
+    return createEncryptionAndRecoveryKeystores;
+  }
+});
+Object.defineProperty(exports, 'keystore_crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return keystore_crypto_exports;
+  }
+});
+Object.defineProperty(exports, 'openEncryptionKeystore', {
+  enumerable: true,
+  get: function () {
+    return openEncryptionKeystore;
+  }
+});
+Object.defineProperty(exports, 'openRecoveryKeystore', {
+  enumerable: true,
+  get: function () {
+    return openRecoveryKeystore;
+  }
+});
+//# sourceMappingURL=keystore-crypto-B4yCVo9l.js.map

package/dist/keystore-crypto-B4yCVo9l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto-B4yCVo9l.js","names":["UTF8ToUint8","publicKeyToBase64","encryptSymmetrically","exportPrivateKey","uint8ArrayToBase64","base64ToUint8Array","importPublicKey","decryptSymmetrically","importPrivateKey","mnemonicToBytes","deriveSymmetricCryptoKeyFromContext","CONTEXT_RECOVERY","getBytesFromData","AES_KEY_BIT_LENGTH","CONTEXT_ENC_KEYSTORE","generateEmailKeys","KeystoreType","genMnemonic"],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts","../src/keystore-crypto/index.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes, publicKeyToBase64 } from '../utils';\nimport { deriveSymmetricCryptoKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, AES_KEY_BIT_LENGTH, CONTEXT_RECOVERY } from '../constants';\nimport { getBytesFromData } from '../hash';\nimport { EmailKeys, EncryptedKeystore, KeystoreType } from 'types';\nimport { exportPrivateKey, importPrivateKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Encrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param content - The content of the keystore\n * @param userID - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The encrypted keystore content\n */\nexport async function encryptKeystoreContent(\n  secretKey: CryptoKey,\n  keys: EmailKeys,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKeys = await publicKeyToBase64(keys.publicKeys);\n    const kyberPrivateKeyEnc = await encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);\n    const eccPrivateKey = await exportPrivateKey(keys.privateKeys.eccPrivateKey);\n    const eccPrivateKeyEnc = await encryptSymmetrically(secretKey, eccPrivateKey, aux);\n    const encryptedKeys = {\n      publicKeys,\n      privateKeys: {\n        kyberPrivateKeyBase64: uint8ArrayToBase64(kyberPrivateKeyEnc),\n        eccPrivateKeyBase64: uint8ArrayToBase64(eccPrivateKeyEnc),\n      },\n    };\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      encryptedKeys,\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @param userEmail - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The decrypted keystore content\n */\nexport async function decryptKeystoreContent(\n  secretKey: CryptoKey,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const kyberPublicKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);\n    const eccPublicArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicArray);\n    const encKyberPrivateKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64);\n    const kyberPrivateKey = await decryptSymmetrically(secretKey, encKyberPrivateKey, aux);\n    const eccEncArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64);\n    const eccKey = await decryptSymmetrically(secretKey, eccEncArray, aux);\n    const eccPrivateKey = await importPrivateKey(eccKey);\n    const keys = {\n      publicKeys: {\n        kyberPublicKey,\n        eccPublicKey,\n      },\n      privateKeys: {\n        kyberPrivateKey,\n        eccPrivateKey,\n      },\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<CryptoKey> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  const recoveryCodesBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, recoverCodesArray);\n  return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<CryptoKey> {\n  return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EmailKeys, EncryptedKeystore, KeystoreType } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { generateEmailKeys } from '../email-crypto';\n\n/**\n * Generates email keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and email keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: EmailKeys;\n}> {\n  try {\n    const keys = await generateEmailKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: Uint8Array,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n","export * from './emailEncryptionKey';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiBA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAMA,0BAAY,YAAY,KAAK;EACzC,MAAM,aAAa,MAAMC,gCAAkB,KAAK,WAAW;EAC3D,MAAM,qBAAqB,MAAMC,8CAAqB,WAAW,KAAK,YAAY,iBAAiB,IAAI;EAEvG,MAAM,mBAAmB,MAAMA,8CAAqB,WAD9B,MAAMC,2CAAiB,KAAK,YAAY,cAAc,EACE,IAAI;AAclF,SALoC;GAClC;GACA;GACA,eAXoB;IACpB;IACA,aAAa;KACX,uBAAuBC,iCAAmB,mBAAmB;KAC7D,qBAAqBA,iCAAmB,iBAAiB;KAC1D;IACF;GAMA;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;AAa3E,eAAsB,uBACpB,WACA,mBACoB;AACpB,KAAI;EACF,MAAM,MAAMJ,0BAAY,kBAAkB,YAAY,kBAAkB,KAAK;EAC7E,MAAM,iBAAiBK,iCAAmB,kBAAkB,cAAc,WAAW,qBAAqB;EAE1G,MAAM,eAAe,MAAMC,0CADJD,iCAAmB,kBAAkB,cAAc,WAAW,mBAAmB,CAC9C;EAE1D,MAAM,kBAAkB,MAAME,8CAAqB,WADxBF,iCAAmB,kBAAkB,cAAc,YAAY,sBAAsB,EAC9B,IAAI;EAGtF,MAAM,gBAAgB,MAAMG,2CADb,MAAMD,8CAAqB,WADtBF,iCAAmB,kBAAkB,cAAc,YAAY,oBAAoB,EACrC,IAAI,CAClB;AAWpD,SAVa;GACX,YAAY;IACV;IACA;IACD;GACD,aAAa;IACX;IACA;IACD;GACF;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA2C;CACjF,MAAM,oBAAoBI,8BAAgB,cAAc;AAExD,QAAOC,uDAAoCC,oCADfC,8BAAiBC,uCAAqB,GAAG,kBAAkB,CACN;;;;;;;;AASnF,eAAsB,4BAA4B,SAAyC;AACzF,QAAOH,uDAAoCI,wCAAsB,QAAQ;;;;;;;;;;;;AC9F3E,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,MAAMC,wCAAmB;EAGtC,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAWC,2BAAa,WAAW;EAE5G,MAAM,gBAAgBC,2BAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAWD,2BAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keystore-crypto-Bjgriq9h.mjs

@@ -0,0 +1,159 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+import { f as CONTEXT_RECOVERY, n as AES_KEY_BIT_LENGTH, u as CONTEXT_ENC_KEYSTORE } from "./constants-kTeX-2T0.mjs";
+import { a as importPrivateKey, n as exportPrivateKey, o as importPublicKey } from "./asymmetric-crypto-CyXsV4XT.mjs";
+import { d as base64ToUint8Array, l as publicKeyToBase64, o as genMnemonic, p as uint8ArrayToBase64, s as mnemonicToBytes, u as UTF8ToUint8 } from "./utils-DS04iUcX.mjs";
+import { r as getBytesFromData } from "./hash-CXeGAwai.mjs";
+import { n as decryptSymmetrically, r as encryptSymmetrically } from "./symmetric-crypto-CrdS1Che.mjs";
+import { s as deriveSymmetricCryptoKeyFromContext } from "./derive-key-Be7hS-cN.mjs";
+import { n as generateEmailKeys } from "./email-crypto-DJUEjTxA.mjs";
+import { t as KeystoreType } from "./types-BiEoleqw.mjs";
+
+//#region src/keystore-crypto/core.ts
+/**
+* Encrypts the keystore content using symmetric encryption
+*
+* @param secretKey - The symmetric key to encrypt the keystore content
+* @param content - The content of the keystore
+* @param userID - The ID of the user
+* @param tag - The keystore type-specific tag string
+* @returns The encrypted keystore content
+*/
+async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
+	try {
+		const aux = UTF8ToUint8(userEmail + type);
+		const publicKeys = await publicKeyToBase64(keys.publicKeys);
+		const kyberPrivateKeyEnc = await encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);
+		const eccPrivateKeyEnc = await encryptSymmetrically(secretKey, await exportPrivateKey(keys.privateKeys.eccPrivateKey), aux);
+		return {
+			userEmail,
+			type,
+			encryptedKeys: {
+				publicKeys,
+				privateKeys: {
+					kyberPrivateKeyBase64: uint8ArrayToBase64(kyberPrivateKeyEnc),
+					eccPrivateKeyBase64: uint8ArrayToBase64(eccPrivateKeyEnc)
+				}
+			}
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt keystore content", { cause: error });
+	}
+}
+/**
+* Decrypts the keystore content using symmetric encryption
+*
+* @param secretKey - The symmetric key to decrypt the keystore content
+* @param encryptedKeys - The encrypted keystore content
+* @param userEmail - The ID of the user
+* @param tag - The keystore type-specific tag string
+* @returns The decrypted keystore content
+*/
+async function decryptKeystoreContent(secretKey, encryptedKeystore) {
+	try {
+		const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
+		const kyberPublicKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);
+		const eccPublicKey = await importPublicKey(base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64));
+		const kyberPrivateKey = await decryptSymmetrically(secretKey, base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64), aux);
+		const eccPrivateKey = await importPrivateKey(await decryptSymmetrically(secretKey, base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64), aux));
+		return {
+			publicKeys: {
+				kyberPublicKey,
+				eccPublicKey
+			},
+			privateKeys: {
+				kyberPrivateKey,
+				eccPrivateKey
+			}
+		};
+	} catch (error) {
+		throw new Error("Failed to decrypt keystore content", { cause: error });
+	}
+}
+/**
+* Derives a secret key for protecting the recovery keystore
+*
+* @param recoveryCodes - The recovery codes
+* @returns The derived secret key for protecting the recovery keystore
+*/
+async function deriveRecoveryKey(recoveryCodes) {
+	const recoverCodesArray = mnemonicToBytes(recoveryCodes);
+	return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, getBytesFromData(AES_KEY_BIT_LENGTH / 8, recoverCodesArray));
+}
+/**
+* Derives a secret key for protecting the encryption keystore
+*
+* @param baseKey - The base secret key from which a new key secret will be derived
+* @returns The derived secret key for protecting the encryption keystore
+*/
+async function deriveEncryptionKeystoreKey(baseKey) {
+	return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
+}
+
+//#endregion
+//#region src/keystore-crypto/emailEncryptionKey.ts
+/**
+* Generates email keys and creates encrypted main and recovery keystores
+* The main keystore encryption key is derived from the base key (stored in session storage)
+* The recovery keystore encryption key is derived from the recovery codes
+*
+* @returns The encryption and recovery keystores, recovery codes and email keys
+*/
+async function createEncryptionAndRecoveryKeystores(userEmail, baseKey) {
+	try {
+		const keys = await generateEmailKeys();
+		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), keys, userEmail, KeystoreType.ENCRYPTION);
+		const recoveryCodes = genMnemonic();
+		return {
+			encryptionKeystore,
+			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, KeystoreType.RECOVERY),
+			recoveryCodes,
+			keys
+		};
+	} catch (error) {
+		throw new Error("Failed to create encryption and recovery keystores", { cause: error });
+	}
+}
+/**
+* Opens the encryption keystore and returns the email encryption keys
+* The decryption key is derived from the base key (stored in session storage)
+*
+* @param encryptedKeystore - The encrypted keystore containing encryption keys
+* @param baseKey - The base key from which the decryption key will be derived
+* @returns The encryption keys
+*/
+async function openEncryptionKeystore(encryptedKeystore, baseKey) {
+	try {
+		if (encryptedKeystore.type != KeystoreType.ENCRYPTION) throw new Error("Input is invalid");
+		return await decryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), encryptedKeystore);
+	} catch (error) {
+		throw new Error("Failed to open encryption keystore", { cause: error });
+	}
+}
+/**
+* Opens the recovery keystore and returns the email encryption keys
+* The decryption key is derived from the base key (stored in session storage)
+*
+* @param recoveryCodes - The user's recovery codes
+* @param encryptedKeystore - The encrypted keystore containing encryption keys
+* @returns The encryption keys
+*/
+async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
+	try {
+		if (encryptedKeystore.type != KeystoreType.RECOVERY) throw new Error("Input is invalid");
+		return await decryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), encryptedKeystore);
+	} catch (error) {
+		throw new Error("Failed to open recovery keystore", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/keystore-crypto/index.ts
+var keystore_crypto_exports = /* @__PURE__ */ __exportAll({
+	createEncryptionAndRecoveryKeystores: () => createEncryptionAndRecoveryKeystores,
+	openEncryptionKeystore: () => openEncryptionKeystore,
+	openRecoveryKeystore: () => openRecoveryKeystore
+});
+
+//#endregion
+export { openRecoveryKeystore as i, createEncryptionAndRecoveryKeystores as n, openEncryptionKeystore as r, keystore_crypto_exports as t };
+//# sourceMappingURL=keystore-crypto-Bjgriq9h.mjs.map

package/dist/keystore-crypto-Bjgriq9h.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto-Bjgriq9h.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts","../src/keystore-crypto/index.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes, publicKeyToBase64 } from '../utils';\nimport { deriveSymmetricCryptoKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, AES_KEY_BIT_LENGTH, CONTEXT_RECOVERY } from '../constants';\nimport { getBytesFromData } from '../hash';\nimport { EmailKeys, EncryptedKeystore, KeystoreType } from 'types';\nimport { exportPrivateKey, importPrivateKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Encrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param content - The content of the keystore\n * @param userID - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The encrypted keystore content\n */\nexport async function encryptKeystoreContent(\n  secretKey: CryptoKey,\n  keys: EmailKeys,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKeys = await publicKeyToBase64(keys.publicKeys);\n    const kyberPrivateKeyEnc = await encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);\n    const eccPrivateKey = await exportPrivateKey(keys.privateKeys.eccPrivateKey);\n    const eccPrivateKeyEnc = await encryptSymmetrically(secretKey, eccPrivateKey, aux);\n    const encryptedKeys = {\n      publicKeys,\n      privateKeys: {\n        kyberPrivateKeyBase64: uint8ArrayToBase64(kyberPrivateKeyEnc),\n        eccPrivateKeyBase64: uint8ArrayToBase64(eccPrivateKeyEnc),\n      },\n    };\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      encryptedKeys,\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @param userEmail - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The decrypted keystore content\n */\nexport async function decryptKeystoreContent(\n  secretKey: CryptoKey,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const kyberPublicKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);\n    const eccPublicArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicArray);\n    const encKyberPrivateKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64);\n    const kyberPrivateKey = await decryptSymmetrically(secretKey, encKyberPrivateKey, aux);\n    const eccEncArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64);\n    const eccKey = await decryptSymmetrically(secretKey, eccEncArray, aux);\n    const eccPrivateKey = await importPrivateKey(eccKey);\n    const keys = {\n      publicKeys: {\n        kyberPublicKey,\n        eccPublicKey,\n      },\n      privateKeys: {\n        kyberPrivateKey,\n        eccPrivateKey,\n      },\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<CryptoKey> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  const recoveryCodesBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, recoverCodesArray);\n  return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<CryptoKey> {\n  return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EmailKeys, EncryptedKeystore, KeystoreType } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { generateEmailKeys } from '../email-crypto';\n\n/**\n * Generates email keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and email keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: EmailKeys;\n}> {\n  try {\n    const keys = await generateEmailKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: Uint8Array,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n","export * from './emailEncryptionKey';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiBA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAM,YAAY,YAAY,KAAK;EACzC,MAAM,aAAa,MAAM,kBAAkB,KAAK,WAAW;EAC3D,MAAM,qBAAqB,MAAM,qBAAqB,WAAW,KAAK,YAAY,iBAAiB,IAAI;EAEvG,MAAM,mBAAmB,MAAM,qBAAqB,WAD9B,MAAM,iBAAiB,KAAK,YAAY,cAAc,EACE,IAAI;AAclF,SALoC;GAClC;GACA;GACA,eAXoB;IACpB;IACA,aAAa;KACX,uBAAuB,mBAAmB,mBAAmB;KAC7D,qBAAqB,mBAAmB,iBAAiB;KAC1D;IACF;GAMA;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;AAa3E,eAAsB,uBACpB,WACA,mBACoB;AACpB,KAAI;EACF,MAAM,MAAM,YAAY,kBAAkB,YAAY,kBAAkB,KAAK;EAC7E,MAAM,iBAAiB,mBAAmB,kBAAkB,cAAc,WAAW,qBAAqB;EAE1G,MAAM,eAAe,MAAM,gBADJ,mBAAmB,kBAAkB,cAAc,WAAW,mBAAmB,CAC9C;EAE1D,MAAM,kBAAkB,MAAM,qBAAqB,WADxB,mBAAmB,kBAAkB,cAAc,YAAY,sBAAsB,EAC9B,IAAI;EAGtF,MAAM,gBAAgB,MAAM,iBADb,MAAM,qBAAqB,WADtB,mBAAmB,kBAAkB,cAAc,YAAY,oBAAoB,EACrC,IAAI,CAClB;AAWpD,SAVa;GACX,YAAY;IACV;IACA;IACD;GACD,aAAa;IACX;IACA;IACD;GACF;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA2C;CACjF,MAAM,oBAAoB,gBAAgB,cAAc;AAExD,QAAO,oCAAoC,kBADf,iBAAiB,qBAAqB,GAAG,kBAAkB,CACN;;;;;;;;AASnF,eAAsB,4BAA4B,SAAyC;AACzF,QAAO,oCAAoC,sBAAsB,QAAQ;;;;;;;;;;;;AC9F3E,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,MAAM,mBAAmB;EAGtC,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAW,aAAa,WAAW;EAE5G,MAAM,gBAAgB,aAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAW,aAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQ,aAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keystore-crypto.d.mts

@@ -0,0 +1,40 @@
+import { c as EncryptedKeystore, i as EmailKeys } from "./types-DwQJtrTx.mjs";
+
+//#region src/keystore-crypto/emailEncryptionKey.d.ts
+/**
+ * Generates email keys and creates encrypted main and recovery keystores
+ * The main keystore encryption key is derived from the base key (stored in session storage)
+ * The recovery keystore encryption key is derived from the recovery codes
+ *
+ * @returns The encryption and recovery keystores, recovery codes and email keys
+ */
+declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey: Uint8Array): Promise<{
+  encryptionKeystore: EncryptedKeystore;
+  recoveryKeystore: EncryptedKeystore;
+  recoveryCodes: string;
+  keys: EmailKeys;
+}>;
+/**
+ * Opens the encryption keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @param baseKey - The base key from which the decryption key will be derived
+ * @returns The encryption keys
+ */
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<EmailKeys>;
+/**
+ * Opens the recovery keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param recoveryCodes - The user's recovery codes
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+declare namespace index_d_exports {
+  export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
+}
+//#endregion
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore, index_d_exports as t };
+//# sourceMappingURL=keystore-crypto.d.mts.map

package/dist/keystore-crypto.d.ts

@@ -0,0 +1,40 @@
+import { c as EncryptedKeystore, i as EmailKeys } from "./types-Ds3ivE9W.js";
+
+//#region src/keystore-crypto/emailEncryptionKey.d.ts
+/**
+ * Generates email keys and creates encrypted main and recovery keystores
+ * The main keystore encryption key is derived from the base key (stored in session storage)
+ * The recovery keystore encryption key is derived from the recovery codes
+ *
+ * @returns The encryption and recovery keystores, recovery codes and email keys
+ */
+declare function createEncryptionAndRecoveryKeystores(userEmail: string, baseKey: Uint8Array): Promise<{
+  encryptionKeystore: EncryptedKeystore;
+  recoveryKeystore: EncryptedKeystore;
+  recoveryCodes: string;
+  keys: EmailKeys;
+}>;
+/**
+ * Opens the encryption keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @param baseKey - The base key from which the decryption key will be derived
+ * @returns The encryption keys
+ */
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore, baseKey: Uint8Array): Promise<EmailKeys>;
+/**
+ * Opens the recovery keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param recoveryCodes - The user's recovery codes
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+declare namespace index_d_exports {
+  export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
+}
+//#endregion
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore, index_d_exports as t };
+//# sourceMappingURL=keystore-crypto.d.ts.map

package/dist/keystore-crypto.js

@@ -0,0 +1,11 @@
+require('./utils-CNs3cyDj.js');
+require('./hash-BoqwNkcd.js');
+require('./symmetric-crypto-D65zB396.js');
+require('./derive-key-CBf2WxJd.js');
+require('./post-quantum-crypto-CAi-cEkV.js');
+require('./email-crypto-BrT98taw.js');
+const require_keystore_crypto = require('./keystore-crypto-B4yCVo9l.js');
+
+exports.createEncryptionAndRecoveryKeystores = require_keystore_crypto.createEncryptionAndRecoveryKeystores;
+exports.openEncryptionKeystore = require_keystore_crypto.openEncryptionKeystore;
+exports.openRecoveryKeystore = require_keystore_crypto.openRecoveryKeystore;

package/dist/keystore-crypto.mjs

@@ -0,0 +1,9 @@
+import "./utils-DS04iUcX.mjs";
+import "./hash-CXeGAwai.mjs";
+import "./symmetric-crypto-CrdS1Che.mjs";
+import "./derive-key-Be7hS-cN.mjs";
+import "./post-quantum-crypto-Vv34t6gX.mjs";
+import "./email-crypto-DJUEjTxA.mjs";
+import { i as openRecoveryKeystore, n as createEncryptionAndRecoveryKeystores, r as openEncryptionKeystore } from "./keystore-crypto-Bjgriq9h.mjs";
+
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/keystore-service.d.mts

@@ -0,0 +1,48 @@
+import { c as EncryptedKeystore, d as KeystoreType, g as PublicKeysBase64, h as PublicKeys } from "./types-DwQJtrTx.mjs";
+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
+   */
+  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;
+declare namespace index_d_exports {
+  export { KeyServiceAPI, getKeyServiceAPI };
+}
+//#endregion
+export { KeyServiceAPI, getKeyServiceAPI, index_d_exports as t };
+//# sourceMappingURL=keystore-service.d.mts.map

package/dist/keystore-service.d.ts

@@ -0,0 +1,48 @@
+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
+   */
+  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;
+declare namespace index_d_exports {
+  export { KeyServiceAPI, getKeyServiceAPI };
+}
+//#endregion
+export { KeyServiceAPI, getKeyServiceAPI, index_d_exports as t };
+//# sourceMappingURL=keystore-service.d.ts.map