internxt-crypto 0.0.13 → 1.0.0

package/dist/email-search.mjs

@@ -1,574 +1,3 @@
-import { CONTEXT_INDEX, DB_LABEL, DB_VERSION, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
-import { o as deriveSymmetricCryptoKeyFromContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
-import { c as encryptEmailContentSymmetricallyWithKey, l as getAux, s as decryptEmailSymmetrically, u as emailToBinary } from "./emailKeys-Fp9WR3wl.mjs";
-import { deleteDB, openDB } from "idb";
-import { Index } from "flexsearch";
+import { C as getEmailCount, S as getEmailBatch, _ as enforceMaxEmailNumber, a as addEmailToCache, b as getAndDecryptAllEmails, c as deleteEmailFromCache, d as deleteDatabase, f as deleteEmail, g as encryptAndStoreManyEmail, h as encryptAndStoreEmail, i as searchEmails, l as getEmailFromCache, m as deriveIndexKey, n as buildSearchIndexFromCache, o as addEmailsToCache, p as deleteOldestEmails, r as removeEmailFromSearchIndex, s as createCacheFromDB, t as addEmailToSearchIndex, u as closeDatabase, v as getAllEmailsSortedNewestFirst, w as openDatabase, x as getAndDecryptEmail, y as getAllEmailsSortedOldestFirst } from "./search-B9YM3XAA.mjs";
 
-//#region src/email-search/indexedDB.ts
-/**
-* Returns IndexedDB database name for the given user
-*
-* @param userID - The user ID
-* @returns The database name
-*/
-const getDatabaseName = (userID) => {
-	return `ES:${userID}:DB`;
-};
-/**
-* Opens IndexedDB database for the given user
-*
-* @param userID - The user ID
-* @returns The database
-*/
-const openDatabase = async (userID) => {
-	try {
-		return openDB(getDatabaseName(userID), DB_VERSION, { upgrade(db) {
-			if (!db.objectStoreNames.contains(DB_LABEL)) db.createObjectStore(DB_LABEL, { keyPath: "id" }).createIndex("byTime", "params.createdAt");
-		} });
-	} catch (error) {
-		throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
-	}
-};
-/**
-* Closes the IndexedDB database
-*
-* @param esDB - The database
-*/
-const closeDatabase = (esDB) => {
-	return esDB.close();
-};
-/**
-* Deletes IndexedDB database for the given user
-*
-* @param userID - The user ID
-* @returns The database
-*/
-const deleteDatabase = async (userID) => {
-	return deleteDB(getDatabaseName(userID));
-};
-/**
-* Derives database encryption key for the given user
-*
-* @param userID - The user ID
-* @returns The symmetric CryptoKey for protecting database
-*/
-const deriveIndexKey = async (baseKey) => {
-	return deriveSymmetricCryptoKeyFromContext(CONTEXT_INDEX, baseKey);
-};
-/**
-* Encrypts the given email and stores it in the IndexedDB database
-*
-* @param newEmailToStore - The email for storing
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param esDB - The database
-*/
-const encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
-	try {
-		const aux = getAux(newEmailToStore.params, false);
-		const encryptedEmail = {
-			enc: await encryptEmailContentSymmetricallyWithKey(newEmailToStore.body, indexKey, aux, newEmailToStore.id),
-			params: newEmailToStore.params,
-			id: newEmailToStore.id
-		};
-		await esDB.put(DB_LABEL, encryptedEmail);
-	} catch (error) {
-		throw new Error("Cannot encrypt and add the given email to the database", { cause: error });
-	}
-};
-/**
-* Encrypts the given set of emails and stores it in the IndexedDB database
-*
-* @param newEmailsToStore - The set of emails for storing
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param esDB - The database
-*/
-const encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
-	try {
-		const encryptedEmails = await Promise.all(newEmailsToStore.map(async (email) => {
-			const aux = getAux(email.params, false);
-			return {
-				enc: await encryptEmailContentSymmetricallyWithKey(email.body, indexKey, aux, email.id),
-				params: email.params,
-				id: email.id
-			};
-		}));
-		const tr = esDB.transaction(DB_LABEL, "readwrite");
-		await Promise.all([...encryptedEmails.map((encEmail) => tr.store.put(encEmail)), tr.done]);
-	} catch (error) {
-		throw new Error("Cannot encrypt and add emails to the database", { cause: error });
-	}
-};
-/**
-* Decrypts the given email
-*
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param encryptedEmail - The encrypted email
-* @returns The decrypted email
-*/
-const decryptEmail = async (indexKey, encryptedEmail) => {
-	try {
-		return {
-			body: await decryptEmailSymmetrically(indexKey, getAux(encryptedEmail.params, false), encryptedEmail.enc),
-			params: encryptedEmail.params,
-			id: encryptedEmail.id
-		};
-	} catch (error) {
-		throw new Error("Cannot decrypt the given email", { cause: error });
-	}
-};
-/**
-* Fetches the email from the database and decrypts it
-*
-* @param emailID - The email identifier
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param encryptedEmail - The encrypted email
-* @returns The decrypted email
-*/
-const getAndDecryptEmail = async (emailID, indexKey, esDB) => {
-	try {
-		const encryptedEmail = await esDB.get(DB_LABEL, emailID);
-		if (!encryptedEmail) throw new Error(`DB cannot find email with id ${emailID}`);
-		return decryptEmail(indexKey, encryptedEmail);
-	} catch (error) {
-		throw new Error(`Cannot fetch the email ${emailID} from the database`, { cause: error });
-	}
-};
-/**
-* Fetches all email from the database and decrypts them
-*
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param esDB - The database
-* @returns The decrypted emails
-*/
-const getAndDecryptAllEmails = async (indexKey, esDB) => {
-	try {
-		const encryptedEmails = await esDB.getAll(DB_LABEL);
-		return (await Promise.all(encryptedEmails.map(async (encEmail) => {
-			return {
-				body: await decryptEmailSymmetrically(indexKey, getAux(encEmail.params, false), encEmail.enc),
-				params: encEmail.params,
-				id: encEmail.id
-			};
-		}))).filter((email) => email !== null);
-	} catch (error) {
-		throw new Error("Cannot fetch and decrypt all emails from the database", { cause: error });
-	}
-};
-/**
-* Deletes the email from the database
-*
-* @param emailID - The email identifier
-* @param esDB - The database
-*/
-const deleteEmail = async (emailID, esDB) => {
-	await esDB.delete(DB_LABEL, emailID);
-};
-/**
-* Returns the number of stored email
-*
-* @param esDB - The database
-* @returns The number of stored emails
-*/
-const getEmailCount = async (esDB) => {
-	return await esDB.count(DB_LABEL);
-};
-/**
-* Removes the given number of oldests emails from the database
-*
-* @param emailsToDelete - The number of emails to delete
-* @param esDB - The database
-*/
-const deleteOldestEmails = async (emailsToDelete, esDB) => {
-	try {
-		const tx = esDB.transaction(DB_LABEL, "readwrite");
-		let cursor = await tx.store.index("byTime").openCursor();
-		let deletedCount = 0;
-		while (cursor && deletedCount < emailsToDelete) {
-			await cursor.delete();
-			deletedCount++;
-			cursor = await cursor.continue();
-		}
-		await tx.done;
-	} catch (error) {
-		throw new Error(`Cannot delete ${emailsToDelete} oldests emails from the database`, { cause: error });
-	}
-};
-/**
-* Enforces the maximum email number in the database
-*
-* @param esDB - The database
-* @param max - The maximum allowed number of emails
-*/
-const enforceMaxEmailNumber = async (esDB, max) => {
-	try {
-		const currentCount = await getEmailCount(esDB);
-		if (currentCount <= max) return;
-		await deleteOldestEmails(currentCount - max, esDB);
-	} catch (error) {
-		throw new Error(`Cannot enforce the maximum of ${max} emails on the database`, { cause: error });
-	}
-};
-/**
-* Fetches all emails from the database, decrypts them and sortes the results in the specified order
-*
-* @param esDB - The database
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param direction - The order of sorting. If 'next' - oldest first, if 'prev' - newest first
-* @returns Decryped emails in the specified order
-*/
-const fetchEmails = async (esDB, indexKey, direction) => {
-	try {
-		const index = esDB.transaction(DB_LABEL, "readonly").store.index("byTime");
-		const encryptedEmails = [];
-		let cursor = await index.openCursor(null, direction);
-		while (cursor) {
-			encryptedEmails.push(cursor.value);
-			cursor = await cursor.continue();
-		}
-		return await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
-	} catch (error) {
-		throw new Error("Cannot fetch emails from database", { cause: error });
-	}
-};
-/**
-* Fetches all emails from the database, decrypts them and sortes the results based on the creation time (newest first)
-*
-* @param esDB - The database
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @returns The number of stored emails
-*/
-const getAllEmailsSortedNewestFirst = async (esDB, indexKey) => {
-	return fetchEmails(esDB, indexKey, "prev");
-};
-/**
-* Fetches all emails from the database, decrypts them and sortes the results based on the creation time (oldest first)
-*
-* @param esDB - The database
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @returns The number of stored emails
-*/
-const getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
-	return fetchEmails(esDB, indexKey, "next");
-};
-/**
-* Fetches a batch of emails from the database, decrypts them and sortes the results based on the creation time (newest first)
-*
-* @param esDB - The database
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param batchSize - The size of the batch
-* @param startCursor - The starting point (optional). If not given, starts from the beginning
-* @returns The number of stored emails
-*/
-const getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
-	try {
-		const index = esDB.transaction(DB_LABEL, "readonly").store.index("byTime");
-		const encryptedEmails = [];
-		let cursor;
-		if (startCursor) {
-			const range = IDBKeyRange.upperBound(startCursor, true);
-			cursor = await index.openCursor(range, "prev");
-		} else cursor = await index.openCursor(null, "prev");
-		let count = 0;
-		let nextCursor;
-		while (cursor && count < batchSize) {
-			encryptedEmails.push(cursor.value);
-			nextCursor = cursor.key;
-			count++;
-			cursor = await cursor.continue();
-		}
-		return {
-			emails: await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail))),
-			nextCursor: count === batchSize ? nextCursor : void 0
-		};
-	} catch (error) {
-		throw new Error(`Cannot fetch email batch of ${batchSize} from the database`, { cause: error });
-	}
-};
-
-//#endregion
-//#region src/email-search/mailCache.ts
-/**
-* Estimates the email size in the memory
-*
-* @param email - The email
-* @returns The estimation of the email size
-*/
-function sizeOfEmail(email) {
-	return emailToBinary(email).byteLength;
-}
-/**
-* Creates an empty cache variable
-*
-* @returns The empty cache
-*/
-function createEmptyCache() {
-	return {
-		esCache: /* @__PURE__ */ new Map(),
-		cacheSize: 0,
-		isCacheLimited: false,
-		isCacheReady: true
-	};
-}
-/**
-* Fetches all emails from the database in batches and cahces them
-*
-* @param indexKey - The symmetric CryptoKey key for protecting database
-* @param esCache - The cache to add emails too
-* @param esDB - The database
-*/
-const createCacheFromDB = async (indexKey, esDB) => {
-	const esCache = createEmptyCache();
-	esCache.isCacheReady = false;
-	try {
-		const count = await getEmailCount(esDB);
-		if (!count) {
-			esCache.isCacheReady = true;
-			return esCache;
-		}
-		if (count <= MAX_EMAIL_PER_BATCH) addEmailsToCache(await getAllEmailsSortedNewestFirst(esDB, indexKey), esCache);
-		else {
-			let nextCursor = void 0;
-			let cacheFull = false;
-			while (!cacheFull) {
-				const { emails, nextCursor: newCursor } = await getEmailBatch(esDB, indexKey, MAX_EMAIL_PER_BATCH, nextCursor);
-				if (!newCursor || !emails.length) break;
-				nextCursor = newCursor;
-				if (!addEmailsToCache(emails, esCache)) cacheFull = true;
-			}
-		}
-		return esCache;
-	} catch (error) {
-		throw new Error(`Email caching failed: ${error}`, { cause: error });
-	}
-};
-/**
-* Gets an email from the cache
-*
-* @param emailID - The email identifier
-* @param esCache - The email cache
-* @returns The found email or throws an error
-*/
-const getEmailFromCache = async (emailID, esCache) => {
-	const email = esCache.esCache.get(emailID);
-	if (!email) throw new Error(`Email not found in cache for ID: ${emailID}`);
-	return email;
-};
-/**
-* Removes the email from cache
-*
-* @param emailID - The email identifier
-* @param esCache - The email cache
-*/
-const deleteEmailFromCache = async (emailID, esCache) => {
-	try {
-		const size = sizeOfEmail(await getEmailFromCache(emailID, esCache));
-		if (esCache.esCache.delete(emailID)) esCache.cacheSize -= size;
-	} catch (error) {
-		throw new Error(`Failed to delete email with ID ${emailID}`, { cause: error });
-	}
-};
-/**
-* Adds emails to the cache
-*
-* @param emails - The emails to add
-* @param esCache - The email cache
-* @returns TRUE if all emails were added sucessfully, or FALSE and error reason.
-*/
-function addEmailsToCache(emails, esCache) {
-	try {
-		for (const email of emails) {
-			const result = addEmailToCache(email, esCache);
-			if (!result.success) return result;
-		}
-		return { success: true };
-	} catch (error) {
-		throw new Error("Failed to add emails to the cache", { cause: error });
-	}
-}
-/**
-* Adds email to the cache
-*
-* @param email - The email to add
-* @param esCache - The email cache
-* @returns TRUE if the email was added sucessfully, or FALSE and error reason.
-*/
-const addEmailToCache = (email, esCache) => {
-	try {
-		if (esCache.esCache.has(email.id)) return {
-			success: false,
-			reason: "email already exists in cache"
-		};
-		const emailSize = sizeOfEmail(email);
-		if (esCache.cacheSize + emailSize > MAX_CACHE_SIZE) {
-			esCache.isCacheLimited = true;
-			return {
-				success: false,
-				reason: "hit cache limit"
-			};
-		}
-		esCache.esCache.set(email.id, email);
-		esCache.cacheSize += emailSize;
-		return { success: true };
-	} catch (error) {
-		throw new Error("Failed to add email to the cache", { cause: error });
-	}
-};
-
-//#endregion
-//#region src/email-search/search.ts
-const SUBJECT_OPTIONS = {
-	preset: "match",
-	tokenize: "forward",
-	resolution: 9,
-	minlength: 2,
-	optimize: true,
-	fastupdate: true,
-	cache: true
-};
-const BODY_OPTIONS = {
-	...SUBJECT_OPTIONS,
-	minlength: 3,
-	resolution: 6
-};
-const FROM_OPTIONS = {
-	...SUBJECT_OPTIONS,
-	tokenize: "strict",
-	minlength: 1
-};
-const TO_OPTIONS = {
-	...SUBJECT_OPTIONS,
-	tokenize: "strict",
-	minlength: 1
-};
-/**
-* Creates new email search index
-*
-* @returns The email search index
-*/
-const createSearchIndex = () => ({
-	subjectIndex: new Index(SUBJECT_OPTIONS),
-	bodyIndex: new Index(BODY_OPTIONS),
-	fromIndex: new Index(FROM_OPTIONS),
-	toIndex: new Index(TO_OPTIONS),
-	isReady: false
-});
-/**
-* Adds the given email to the email search index
-*
-* @param email - The email to add
-* @param searchIndex - The email search index
-*/
-const addEmailToSearchIndex = (email, searchIndex) => {
-	try {
-		const emailId = email.id;
-		if (email.params.subject) searchIndex.subjectIndex.add(emailId, email.params.subject);
-		if (email.body?.text) searchIndex.bodyIndex.add(emailId, email.body.text);
-		if (email.params.sender) {
-			const senderText = `${email.params.sender.name || ""} ${email.params.sender.email || ""}`.trim();
-			searchIndex.fromIndex.add(emailId, senderText);
-		}
-		const recipientsText = (email.params.recipients?.length ? email.params.recipients : [email.params.recipient]).map((recipient) => `${recipient.name || ""} ${recipient.email || ""}`.trim()).join(" ");
-		searchIndex.toIndex.add(emailId, recipientsText);
-	} catch (error) {
-		throw new Error("Failed to add email to the search index", { cause: error });
-	}
-};
-/**
-* Removes the email from the email search index
-*
-* @param emailID - The email identifier
-* @param searchIndex - The email search index
-*/
-const removeEmailFromSearchIndex = (emailID, searchIndex) => {
-	try {
-		searchIndex.subjectIndex.remove(emailID);
-		searchIndex.bodyIndex.remove(emailID);
-		searchIndex.fromIndex.remove(emailID);
-		searchIndex.toIndex.remove(emailID);
-	} catch (error) {
-		throw new Error(`Failed to remove email with ID ${emailID} from the search index`, { cause: error });
-	}
-};
-/**
-* Buils the email search index from the email cache
-*
-* @param esCache - The email cache
-* @returns  The email search index
-*/
-const buildSearchIndexFromCache = async (esCache) => {
-	try {
-		const searchIndex = createSearchIndex();
-		searchIndex.isReady = false;
-		for (const email of esCache.esCache.values()) addEmailToSearchIndex(email, searchIndex);
-		searchIndex.isReady = true;
-		return searchIndex;
-	} catch (error) {
-		throw new Error("Failed build an email search index from the cache", { cause: error });
-	}
-};
-/**
-* Searches in teh
-*
-* @param query - The string to search for
-* @param esCache - The email cache
-* @param searchIndex - The email search index
-* @param opetions - The optional search limitations
-* @returns The result of the email search (emails ans their corresponding result weights)
-*/
-const searchEmails = async (query, esCache, searchIndex, options = {}) => {
-	try {
-		if (!searchIndex.isReady || !query.trim()) return [];
-		const { fields = [
-			"subject",
-			"body",
-			"from",
-			"to"
-		], limit = 50, boost = {
-			subject: 3,
-			body: 1,
-			from: 2,
-			to: 2
-		} } = options;
-		const results = /* @__PURE__ */ new Map();
-		const searchPromises = fields.map(async (field) => {
-			let fieldResults;
-			switch (field) {
-				case "subject":
-					fieldResults = await searchIndex.subjectIndex.searchAsync(query);
-					break;
-				case "body":
-					fieldResults = await searchIndex.bodyIndex.searchAsync(query);
-					break;
-				case "from":
-					fieldResults = await searchIndex.fromIndex.searchAsync(query);
-					break;
-				case "to":
-					fieldResults = await searchIndex.toIndex.searchAsync(query);
-					break;
-				default: return;
-			}
-			const fieldBoost = boost[field] || 1;
-			fieldResults.forEach((emailId) => {
-				const currentScore = results.get(String(emailId)) || 0;
-				results.set(String(emailId), currentScore + fieldBoost);
-			});
-		});
-		await Promise.all(searchPromises);
-		const emailResults = [];
-		for (const [emailId, score] of results) {
-			const email = esCache.esCache.get(emailId);
-			if (email) emailResults.push({
-				email,
-				score
-			});
-		}
-		emailResults.sort((a, b) => (b.score || 0) - (a.score || 0));
-		return emailResults.slice(0, limit);
-	} catch (error) {
-		throw new Error("Email search failed", { cause: error });
-	}
-};
-
-//#endregion
-export { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteDatabase, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails };
-//# sourceMappingURL=email-search.mjs.map
+export { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteDatabase, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails };

package/dist/{emailEncryptionKey-27mIHh18.mjs → emailEncryptionKey-BtSPYd9M.mjs}

@@ -1,38 +1,28 @@
-import { AES_KEY_BIT_LENGTH, CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from "./constants.mjs";
-import { a as importPublicKey, i as importPrivateKey, t as exportPrivateKey } from "./keys-BfcaiAOv.mjs";
-import { a as genMnemonic, c as publicKeyToBase64, f as uint8ArrayToBase64, l as UTF8ToUint8, o as mnemonicToBytes, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
-import { n as getBytesFromData } from "./mac-ZpRlx8Fs.mjs";
-import { n as encryptSymmetrically, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
-import { o as deriveSymmetricCryptoKeyFromContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
-import { t as generateEmailKeys } from "./emailKeys-Fp9WR3wl.mjs";
+import { CONTEXT_ENC_KEYSTORE, CONTEXT_RECOVERY } from "./constants.mjs";
+import { a as genMnemonic, c as base64ToUint8Array, o as mnemonicToBytes, s as UTF8ToUint8, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
+import { t as deriveSymmetricKeyFromContext } from "./deriveKeysFromKey-DPU_h7wr.mjs";
+import { n as encryptSymmetrically, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
+import { r as genHybridKeys } from "./xwing-CQmQX6hn.mjs";
 import { KeystoreType } from "./types.mjs";
 
 //#region src/keystore-crypto/core.ts
 /**
-* Encrypts the keystore content using symmetric encryption
+* Encrypts the user's hybrid key using symmetric encryption to get a keystore
 *
 * @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
+* @param key - The hybrid key pair
+* @param userEmail - The email of the user
+* @param type - The keystore type
+* @returns The encrypted keystore
 */
 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)
-				}
-			}
+			publicKey: uint8ArrayToBase64(keys.publicKey),
+			privateKeyEncrypted: uint8ArrayToBase64(await encryptSymmetrically(secretKey, keys.secretKey, aux))
 		};
 	} catch (error) {
 		throw new Error("Failed to encrypt keystore content", { cause: error });
@@ -41,28 +31,16 @@ async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
 /**
 * Decrypts the keystore content using symmetric encryption
 *
-* @param secretKey - The symmetric key to decrypt the keystore content
+* @param kesytoreOpeningKey - 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
+* @returns The decrypted hybrid key pair contained in the keystore
 */
-async function decryptKeystoreContent(secretKey, encryptedKeystore) {
+async function decryptKeystoreContent(kesytoreOpeningKey, 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
-			}
+			publicKey: base64ToUint8Array(encryptedKeystore.publicKey),
+			secretKey: await decryptSymmetrically(kesytoreOpeningKey, base64ToUint8Array(encryptedKeystore.privateKeyEncrypted), aux)
 		};
 	} catch (error) {
 		throw new Error("Failed to decrypt keystore content", { cause: error });
@@ -75,8 +53,7 @@ async function decryptKeystoreContent(secretKey, encryptedKeystore) {
 * @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));
+	return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, mnemonicToBytes(recoveryCodes));
 }
 /**
 * Derives a secret key for protecting the encryption keystore
@@ -85,21 +62,21 @@ async function deriveRecoveryKey(recoveryCodes) {
 * @returns The derived secret key for protecting the encryption keystore
 */
 async function deriveEncryptionKeystoreKey(baseKey) {
-	return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
+	return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
 }
 
 //#endregion
 //#region src/keystore-crypto/emailEncryptionKey.ts
 /**
-* Generates email keys and creates encrypted main and recovery keystores
+* Generates hybrid 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
+* @returns The encryption and recovery keystores, recovery codes and hybrid keys
 */
 async function createEncryptionAndRecoveryKeystores(userEmail, baseKey) {
 	try {
-		const keys = await generateEmailKeys();
+		const keys = genHybridKeys();
 		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), keys, userEmail, KeystoreType.ENCRYPTION);
 		const recoveryCodes = genMnemonic();
 		return {
@@ -147,4 +124,4 @@ async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
 
 //#endregion
 export { openEncryptionKeystore as n, openRecoveryKeystore as r, createEncryptionAndRecoveryKeystores as t };
-//# sourceMappingURL=emailEncryptionKey-27mIHh18.mjs.map
+//# sourceMappingURL=emailEncryptionKey-BtSPYd9M.mjs.map