internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/keys-BfcaiAOv.mjs

@@ -0,0 +1,90 @@
+import { AES_KEY_BIT_LENGTH, ECC_ALGORITHM } from "./constants.mjs";
+
+//#region src/asymmetric-crypto/ellipticCurve.ts
+/**
+* Derives secret key from the other user's public key and own private key
+*
+* @param otherUserPublicKey - The public key of the other user
+* @param ownPrivateKey - The private key
+* @returns The derived secret key bits
+*/
+async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
+	try {
+		const result = await crypto.subtle.deriveBits({
+			name: ECC_ALGORITHM,
+			public: otherUserPublicKey
+		}, ownPrivateKey, AES_KEY_BIT_LENGTH);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/keys.ts
+/**
+* Generates elliptic curve key pair
+*
+* @returns The generated key pair
+*/
+async function generateEccKeys() {
+	try {
+		return await crypto.subtle.generateKey({ name: ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
+	}
+}
+/**
+* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+*
+* @returns The Uint8Array representation of the public key
+*/
+async function exportPublicKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("spki", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export public key", { cause: error });
+	}
+}
+/**
+* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+*
+* @returns The CryptoKey representation of the public key
+*/
+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 });
+	}
+}
+/**
+* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+*
+* @returns The Uint8Array representation of the private key
+*/
+async function exportPrivateKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("pkcs8", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export private key", { cause: error });
+	}
+}
+/**
+* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+*
+* @returns The CryptoKey representation of the private key
+*/
+async function importPrivateKey(pkcs8KeyData) {
+	try {
+		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to import private key", { cause: error });
+	}
+}
+
+//#endregion
+export { importPublicKey as a, importPrivateKey as i, exportPublicKey as n, deriveSecretKey as o, generateEccKeys as r, exportPrivateKey as t };
+//# sourceMappingURL=keys-BfcaiAOv.mjs.map

package/dist/keys-BfcaiAOv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-BfcaiAOv.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAM;GACN,QAAQ;GACT,EACD,eACA,mBACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAM,eACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keys-CinT7kEY.js

@@ -0,0 +1,125 @@
+const require_constants = require('./constants.js');
+
+//#region src/asymmetric-crypto/ellipticCurve.ts
+/**
+* Derives secret key from the other user's public key and own private key
+*
+* @param otherUserPublicKey - The public key of the other user
+* @param ownPrivateKey - The private key
+* @returns The derived secret key bits
+*/
+async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
+	try {
+		const result = await crypto.subtle.deriveBits({
+			name: require_constants.ECC_ALGORITHM,
+			public: otherUserPublicKey
+		}, ownPrivateKey, require_constants.AES_KEY_BIT_LENGTH);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/keys.ts
+/**
+* Generates elliptic curve key pair
+*
+* @returns The generated key pair
+*/
+async function generateEccKeys() {
+	try {
+		return await crypto.subtle.generateKey({ name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
+	}
+}
+/**
+* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+*
+* @returns The Uint8Array representation of the public key
+*/
+async function exportPublicKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("spki", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export public key", { cause: error });
+	}
+}
+/**
+* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+*
+* @returns The CryptoKey representation of the public key
+*/
+async function importPublicKey(spkiKeyData) {
+	try {
+		return await crypto.subtle.importKey("spki", spkiKeyData, { name: require_constants.ECC_ALGORITHM }, true, []);
+	} catch (error) {
+		throw new Error("Failed to import public key", { cause: error });
+	}
+}
+/**
+* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+*
+* @returns The Uint8Array representation of the private key
+*/
+async function exportPrivateKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("pkcs8", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export private key", { cause: error });
+	}
+}
+/**
+* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+*
+* @returns The CryptoKey representation of the private key
+*/
+async function importPrivateKey(pkcs8KeyData) {
+	try {
+		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to import private key", { cause: error });
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'deriveSecretKey', {
+  enumerable: true,
+  get: function () {
+    return deriveSecretKey;
+  }
+});
+Object.defineProperty(exports, 'exportPrivateKey', {
+  enumerable: true,
+  get: function () {
+    return exportPrivateKey;
+  }
+});
+Object.defineProperty(exports, 'exportPublicKey', {
+  enumerable: true,
+  get: function () {
+    return exportPublicKey;
+  }
+});
+Object.defineProperty(exports, 'generateEccKeys', {
+  enumerable: true,
+  get: function () {
+    return generateEccKeys;
+  }
+});
+Object.defineProperty(exports, 'importPrivateKey', {
+  enumerable: true,
+  get: function () {
+    return importPrivateKey;
+  }
+});
+Object.defineProperty(exports, 'importPublicKey', {
+  enumerable: true,
+  get: function () {
+    return importPublicKey;
+  }
+});
+//# sourceMappingURL=keys-CinT7kEY.js.map

package/dist/keys-CinT7kEY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys-CinT7kEY.js","names":["ECC_ALGORITHM","AES_KEY_BIT_LENGTH","ECC_ALGORITHM"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAMA;GACN,QAAQ;GACT,EACD,eACAC,qCACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAMC,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAMA,iCACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAMA,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keystore-crypto.d.mts

@@ -1,36 +1,28 @@
-import { EncryptionKeys, EncryptedKeystore, IdentityKeys } from './types.mjs';
+import { EmailKeys, EncryptedKeystore } from "./types.mjs";
 
+//#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
- * Generates recovery codes
+ * 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 generated recovery codes
+ * @returns The encryption and recovery keystores, recovery codes and email keys
  */
-declare function generateRecoveryCodes(): string;
-/**
- * Generates encryption keys
- *
- * @returns The generated encryption keys
- */
-declare function generateEncryptionKeys(): Promise<EncryptionKeys>;
-/**
- * Generates email encryption keys and creates encrypted encryption and recovery keystores
- * The encryption key is derived from the base key (stored in session storage)
- *
- * @returns The encryption and recovery keystores
- */
-declare function createEncryptionAndRecoveryKeystores(): Promise<{
-    encryptionKeystore: EncryptedKeystore;
-    recoveryKeystore: EncryptedKeystore;
-    recoveryCodes: string;
+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): Promise<EncryptionKeys>;
+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)
@@ -39,28 +31,7 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore): P
  * @param encryptedKeystore - The encrypted keystore containing encryption keys
  * @returns The encryption keys
  */
-declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
-
-/**
- * Generates user idenity keys
- *
- * @returns The user identity keys
- */
-declare function generateIdentityKeys(): Promise<IdentityKeys>;
-/**
- * Generates user identity keys and creates an encrypted identity keystore
- * The encryption key is derived from the base key (stored in session storage)
- *
- * @returns The encrypted idenity keystore
- */
-declare function createIdentityKeystore(): Promise<EncryptedKeystore>;
-/**
- * Opens the encrypted identity keystore
- * The decryption key is derived from the base key (stored in session storage)
- *
- * @param encryptedKeystore - The encrypted identity keystore
- * @returns The identity keys
- */
-declare function openIdentityKeystore(encryptedKeystore: EncryptedKeystore): Promise<IdentityKeys>;
-
-export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+//#endregion
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
+//# sourceMappingURL=keystore-crypto.d.mts.map

package/dist/keystore-crypto.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto.d.mts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}

package/dist/keystore-crypto.d.ts

@@ -1,36 +1,28 @@
-import { EncryptionKeys, EncryptedKeystore, IdentityKeys } from './types.js';
+import { EmailKeys, EncryptedKeystore } from "./types.js";
 
+//#region src/keystore-crypto/emailEncryptionKey.d.ts
 /**
- * Generates recovery codes
+ * 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 generated recovery codes
+ * @returns The encryption and recovery keystores, recovery codes and email keys
  */
-declare function generateRecoveryCodes(): string;
-/**
- * Generates encryption keys
- *
- * @returns The generated encryption keys
- */
-declare function generateEncryptionKeys(): Promise<EncryptionKeys>;
-/**
- * Generates email encryption keys and creates encrypted encryption and recovery keystores
- * The encryption key is derived from the base key (stored in session storage)
- *
- * @returns The encryption and recovery keystores
- */
-declare function createEncryptionAndRecoveryKeystores(): Promise<{
-    encryptionKeystore: EncryptedKeystore;
-    recoveryKeystore: EncryptedKeystore;
-    recoveryCodes: string;
+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): Promise<EncryptionKeys>;
+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)
@@ -39,28 +31,7 @@ declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore): P
  * @param encryptedKeystore - The encrypted keystore containing encryption keys
  * @returns The encryption keys
  */
-declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
-
-/**
- * Generates user idenity keys
- *
- * @returns The user identity keys
- */
-declare function generateIdentityKeys(): Promise<IdentityKeys>;
-/**
- * Generates user identity keys and creates an encrypted identity keystore
- * The encryption key is derived from the base key (stored in session storage)
- *
- * @returns The encrypted idenity keystore
- */
-declare function createIdentityKeystore(): Promise<EncryptedKeystore>;
-/**
- * Opens the encrypted identity keystore
- * The decryption key is derived from the base key (stored in session storage)
- *
- * @param encryptedKeystore - The encrypted identity keystore
- * @returns The identity keys
- */
-declare function openIdentityKeystore(encryptedKeystore: EncryptedKeystore): Promise<IdentityKeys>;
-
-export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EmailKeys>;
+//#endregion
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };
+//# sourceMappingURL=keystore-crypto.d.ts.map

package/dist/keystore-crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-crypto.d.ts","names":[],"sources":["../src/keystore-crypto/emailEncryptionKey.ts"],"mappings":";;;;;AAYA;;;;;iBAAsB,oCAAA,CACpB,SAAA,UACA,OAAA,EAAS,UAAA,GACR,OAAA;EACD,kBAAA,EAAoB,iBAAA;EACpB,gBAAA,EAAkB,iBAAA;EAClB,aAAA;EACA,IAAA,EAAM,SAAA;AAAA;;;;;;;;;iBA0Bc,sBAAA,CACpB,iBAAA,EAAmB,iBAAA,EACnB,OAAA,EAAS,UAAA,GACR,OAAA,CAAQ,SAAA;;;;AAHX;;;;;iBAwBsB,oBAAA,CACpB,aAAA,UACA,iBAAA,EAAmB,iBAAA,GAClB,OAAA,CAAQ,SAAA"}