internxt-crypto 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -19,31 +19,31 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@internxt/eslint-config-internxt": "2.0.1",
-    "@internxt/prettier-config": "https://github.com/internxt/prettier-config.git#v1.0.2",
-    "@playwright/test": "^1.54.2",
-    "@types/node": "^25.2.3",
-    "@vitest/browser-playwright": "^4.0.10",
-    "@vitest/coverage-istanbul": "^4.0.10",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^10.0.2",
-    "knip": "^5.84.0",
-    "lint-staged": "^16.1.4",
-    "playwright": "^1.54.1",
-    "prettier": "^3.6.2",
-    "tsdown": "^0.20.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.0"
+    "@internxt/eslint-config-internxt": "^2.1.0",
+    "@internxt/prettier-config": "^2.0.1",
+    "@playwright/test": "^1.59.1",
+    "@types/node": "^25.6.0",
+    "@vitest/browser-playwright": "^4.1.5",
+    "@vitest/coverage-istanbul": "^4.1.5",
+    "@vitest/coverage-v8": "^4.1.5",
+    "eslint": "^10.3.0",
+    "knip": "^6.11.0",
+    "lint-staged": "^17.0.2",
+    "playwright": "^1.59.1",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.21.10",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "dependencies": {
-    "@noble/ciphers": "^2.1.1",
-    "@noble/curves": "^2.0.1",
-    "@noble/hashes": "^2.0.1",
-    "@noble/post-quantum": "^0.5.2",
-    "@scure/bip39": "^2.0.1",
+    "@noble/ciphers": "^2.2.0",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
+    "@noble/post-quantum": "^0.6.1",
+    "@scure/bip39": "^2.2.0",
     "hash-wasm": "^4.12.0",
     "husky": "^9.1.7",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0"
   },
   "exports": {
     ".": {

package/dist/aes-B8TA-JKq.mjs

@@ -1,49 +0,0 @@
-import { AES_KEY_BYTE_LENGTH, IV_LEN_BYTES } from "./constants.mjs";
-import { concatBytes, randomBytes } from "@noble/hashes/utils.js";
-import { gcm } from "@noble/ciphers/webcrypto.js";
-
-//#region src/symmetric-crypto/aes.ts
-/**
-* Symmetrically encrypts the message
-*
-* @param encryptionKey - The symmetric key used for message encryption
-* @param message - The message to encrypt
-* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
-* @returns The resulting ciphertext.
-*/
-async function encryptSymmetrically(encryptionKey, message, aux) {
-	try {
-		const iv = randomBytes(IV_LEN_BYTES);
-		return concatBytes(await gcm(encryptionKey, iv, aux).encrypt(message), iv);
-	} catch (error) {
-		throw new Error("Failed to encrypt symmetrically", { cause: error });
-	}
-}
-/**
-* Decryps symmetrically encrypted message
-*
-* @param encryptionKey - The symmetric key used for message encryption
-* @param encryptedMessage - The ciphertext
-* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
-* @returns The resulting ciphertext.
-*/
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-	try {
-		const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);
-		return await gcm(encryptionKey, encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES), aux).decrypt(ciphertext);
-	} catch (error) {
-		throw new Error("Failed to decrypt symmetrically", { cause: error });
-	}
-}
-/**
-* Generates symmetric key as Uint8Array
-*
-* @returns The generated Uint8Array.
-*/
-function genSymmetricKey() {
-	return randomBytes(AES_KEY_BYTE_LENGTH);
-}
-
-//#endregion
-export { encryptSymmetrically as n, genSymmetricKey as r, decryptSymmetrically as t };
-//# sourceMappingURL=aes-B8TA-JKq.mjs.map

package/dist/aes-B8TA-JKq.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-B8TA-JKq.mjs","names":["aeadCipher"],"sources":["../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { concatBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES, AES_KEY_BYTE_LENGTH } from '../constants';\nimport { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param message - The message to encrypt\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: Uint8Array,\n  message: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = randomBytes(IV_LEN_BYTES);\n    const ciphertext = await aeadCipher(encryptionKey, iv, aux).encrypt(message);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: Uint8Array,\n  encryptedMessage: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await aeadCipher(encryptionKey, iv, aux).decrypt(ciphertext);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  return randomBytes(AES_KEY_BYTE_LENGTH);\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,eAAsB,qBACpB,eACA,SACA,KACqB;AACrB,KAAI;EACF,MAAM,KAAK,YAAY,aAAa;AAEpC,SAAO,YADY,MAAMA,IAAW,eAAe,IAAI,IAAI,CAAC,QAAQ,QAAQ,EAC7C,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,aAAa,iBAAiB,MAAM,GAAG,iBAAiB,SAAS,aAAa;AAGpF,SADe,MAAMA,IAAW,eADrB,iBAAiB,MAAM,iBAAiB,SAAS,aAAa,EACtB,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,QAAO,YAAY,oBAAoB"}

package/dist/aes-CuW_SPl-.js

@@ -1,67 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
-let _noble_ciphers_webcrypto_js = require("@noble/ciphers/webcrypto.js");
-
-//#region src/symmetric-crypto/aes.ts
-/**
-* Symmetrically encrypts the message
-*
-* @param encryptionKey - The symmetric key used for message encryption
-* @param message - The message to encrypt
-* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
-* @returns The resulting ciphertext.
-*/
-async function encryptSymmetrically(encryptionKey, message, aux) {
-	try {
-		const iv = (0, _noble_hashes_utils_js.randomBytes)(require_constants.IV_LEN_BYTES);
-		return (0, _noble_hashes_utils_js.concatBytes)(await (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, iv, aux).encrypt(message), iv);
-	} catch (error) {
-		throw new Error("Failed to encrypt symmetrically", { cause: error });
-	}
-}
-/**
-* Decryps symmetrically encrypted message
-*
-* @param encryptionKey - The symmetric key used for message encryption
-* @param encryptedMessage - The ciphertext
-* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
-* @returns The resulting ciphertext.
-*/
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-	try {
-		const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - require_constants.IV_LEN_BYTES);
-		return await (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, encryptedMessage.slice(encryptedMessage.length - require_constants.IV_LEN_BYTES), aux).decrypt(ciphertext);
-	} catch (error) {
-		throw new Error("Failed to decrypt symmetrically", { cause: error });
-	}
-}
-/**
-* Generates symmetric key as Uint8Array
-*
-* @returns The generated Uint8Array.
-*/
-function genSymmetricKey() {
-	return (0, _noble_hashes_utils_js.randomBytes)(require_constants.AES_KEY_BYTE_LENGTH);
-}
-
-//#endregion
-Object.defineProperty(exports, 'decryptSymmetrically', {
-  enumerable: true,
-  get: function () {
-    return decryptSymmetrically;
-  }
-});
-Object.defineProperty(exports, 'encryptSymmetrically', {
-  enumerable: true,
-  get: function () {
-    return encryptSymmetrically;
-  }
-});
-Object.defineProperty(exports, 'genSymmetricKey', {
-  enumerable: true,
-  get: function () {
-    return genSymmetricKey;
-  }
-});
-//# sourceMappingURL=aes-CuW_SPl-.js.map

package/dist/aes-CuW_SPl-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-CuW_SPl-.js","names":["IV_LEN_BYTES","AES_KEY_BYTE_LENGTH"],"sources":["../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { concatBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES, AES_KEY_BYTE_LENGTH } from '../constants';\nimport { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param message - The message to encrypt\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: Uint8Array,\n  message: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = randomBytes(IV_LEN_BYTES);\n    const ciphertext = await aeadCipher(encryptionKey, iv, aux).encrypt(message);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: Uint8Array,\n  encryptedMessage: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await aeadCipher(encryptionKey, iv, aux).decrypt(ciphertext);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  return randomBytes(AES_KEY_BYTE_LENGTH);\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,eAAsB,qBACpB,eACA,SACA,KACqB;AACrB,KAAI;EACF,MAAM,6CAAiBA,+BAAa;AAEpC,iDADmB,2CAAiB,eAAe,IAAI,IAAI,CAAC,QAAQ,QAAQ,EAC7C,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,aAAa,iBAAiB,MAAM,GAAG,iBAAiB,SAASA,+BAAa;AAGpF,SADe,2CAAiB,eADrB,iBAAiB,MAAM,iBAAiB,SAASA,+BAAa,EACtB,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,gDAAmBC,sCAAoB"}

package/dist/chunk-DQk6qfdC.mjs

@@ -1,18 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-export { __exportAll as t };

package/dist/chunk-EbLFQX5m.js

@@ -1,60 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__commonJSMin', {
-  enumerable: true,
-  get: function () {
-    return __commonJSMin;
-  }
-});
-Object.defineProperty(exports, '__exportAll', {
-  enumerable: true,
-  get: function () {
-    return __exportAll;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});

package/dist/deriveKeysFromMnemonic-DB0UHE-y.mjs

@@ -1,49 +0,0 @@
-import { AES_KEY_BYTE_LENGTH, CONTEXT_TWO_KEYS } from "./constants.mjs";
-import { o as mnemonicToBytes, s as UTF8ToUint8 } from "./genID-D08K7JPr.mjs";
-import { blake3 } from "@noble/hashes/blake3.js";
-
-//#region src/derive-key/deriveKeysFromKey.ts
-/**
-* Derives a symmetric key from the base key and context string
-*
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @param baseKey - The base key (NOT PASSWORD!)
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromContext(context, baseKey) {
-	return blake3(baseKey, { context: UTF8ToUint8(context) });
-}
-/**
-* Derives a symmetric key from two keys
-*
-* @param key1 - The 32-bytes key
-* @param key2 - The 32-bytes key
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromTwoKeys(key1, key2) {
-	try {
-		if (key2.length !== AES_KEY_BYTE_LENGTH || key1.length !== AES_KEY_BYTE_LENGTH) throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);
-		return deriveSymmetricKeyFromContext(CONTEXT_TWO_KEYS, blake3(key1, { key: key2 }));
-	} catch (error) {
-		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/derive-key/deriveKeysFromMnemonic.ts
-/**
-* Derives encryption key from the user's mnemonic and context string
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @returns The symmetric key for protecting database
-*/
-const deriveKeyFromMnemonic = async (mnemonic, context) => {
-	return deriveSymmetricKeyFromContext(context, mnemonicToBytes(mnemonic));
-};
-
-//#endregion
-export { deriveSymmetricKeyFromContext as n, deriveSymmetricKeyFromTwoKeys as r, deriveKeyFromMnemonic as t };
-//# sourceMappingURL=deriveKeysFromMnemonic-DB0UHE-y.mjs.map

package/dist/deriveKeysFromMnemonic-DB0UHE-y.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"deriveKeysFromMnemonic-DB0UHE-y.mjs","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts","../src/derive-key/deriveKeysFromMnemonic.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_TWO_KEYS } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length !== AES_KEY_BYTE_LENGTH || key1.length !== AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_TWO_KEYS, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n","import { mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from './deriveKeysFromKey';\n\n/**\n * Derives encryption key from the user's mnemonic and context string\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @returns The symmetric key for protecting database\n */\nexport const deriveKeyFromMnemonic = async (mnemonic: string, context: string): Promise<Uint8Array> => {\n  // mnemonic is always machine-generated with secure PRNG, so it is safe to convert it to bytes without additional processing\n  const entropy = mnemonicToBytes(mnemonic);\n  return deriveSymmetricKeyFromContext(context, entropy);\n};\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,QAAO,OAAO,SAAS,EAAE,SAAS,YAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,WAAW,uBAAuB,KAAK,WAAW,oBACzD,OAAM,IAAI,MAAM,oCAAoC,oBAAoB,QAAQ;AAGlF,SAAO,8BAA8B,kBADzB,OAAO,MAAM,EAAE,KAAK,MAAM,CAAC,CACoB;UACpD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;ACpBjG,MAAa,wBAAwB,OAAO,UAAkB,YAAyC;AAGrG,QAAO,8BAA8B,SADrB,gBAAgB,SAAS,CACa"}

package/dist/deriveKeysFromMnemonic-Dbx7VSBQ.js

@@ -1,67 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-const require_genID = require('./genID-cWOPmspk.js');
-let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
-
-//#region src/derive-key/deriveKeysFromKey.ts
-/**
-* Derives a symmetric key from the base key and context string
-*
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @param baseKey - The base key (NOT PASSWORD!)
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromContext(context, baseKey) {
-	return (0, _noble_hashes_blake3_js.blake3)(baseKey, { context: require_genID.UTF8ToUint8(context) });
-}
-/**
-* Derives a symmetric key from two keys
-*
-* @param key1 - The 32-bytes key
-* @param key2 - The 32-bytes key
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromTwoKeys(key1, key2) {
-	try {
-		if (key2.length !== require_constants.AES_KEY_BYTE_LENGTH || key1.length !== require_constants.AES_KEY_BYTE_LENGTH) throw new Error(`Input key length must be exactly ${require_constants.AES_KEY_BYTE_LENGTH} bytes`);
-		return deriveSymmetricKeyFromContext(require_constants.CONTEXT_TWO_KEYS, (0, _noble_hashes_blake3_js.blake3)(key1, { key: key2 }));
-	} catch (error) {
-		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/derive-key/deriveKeysFromMnemonic.ts
-/**
-* Derives encryption key from the user's mnemonic and context string
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @returns The symmetric key for protecting database
-*/
-const deriveKeyFromMnemonic = async (mnemonic, context) => {
-	return deriveSymmetricKeyFromContext(context, require_genID.mnemonicToBytes(mnemonic));
-};
-
-//#endregion
-Object.defineProperty(exports, 'deriveKeyFromMnemonic', {
-  enumerable: true,
-  get: function () {
-    return deriveKeyFromMnemonic;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricKeyFromContext', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricKeyFromContext;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricKeyFromTwoKeys', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricKeyFromTwoKeys;
-  }
-});
-//# sourceMappingURL=deriveKeysFromMnemonic-Dbx7VSBQ.js.map

package/dist/deriveKeysFromMnemonic-Dbx7VSBQ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deriveKeysFromMnemonic-Dbx7VSBQ.js","names":["UTF8ToUint8","AES_KEY_BYTE_LENGTH","CONTEXT_TWO_KEYS","mnemonicToBytes"],"sources":["../src/derive-key/deriveKeysFromKey.ts","../src/derive-key/deriveKeysFromMnemonic.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_TWO_KEYS } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length !== AES_KEY_BYTE_LENGTH || key1.length !== AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_TWO_KEYS, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n","import { mnemonicToBytes } from '../utils';\nimport { deriveSymmetricKeyFromContext } from './deriveKeysFromKey';\n\n/**\n * Derives encryption key from the user's mnemonic and context string\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @returns The symmetric key for protecting database\n */\nexport const deriveKeyFromMnemonic = async (mnemonic: string, context: string): Promise<Uint8Array> => {\n  // mnemonic is always machine-generated with secure PRNG, so it is safe to convert it to bytes without additional processing\n  const entropy = mnemonicToBytes(mnemonic);\n  return deriveSymmetricKeyFromContext(context, entropy);\n};\n"],"mappings":";;;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,4CAAc,SAAS,EAAE,SAASA,0BAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,WAAWC,yCAAuB,KAAK,WAAWA,sCACzD,OAAM,IAAI,MAAM,oCAAoCA,sCAAoB,QAAQ;AAGlF,SAAO,8BAA8BC,wEADlB,MAAM,EAAE,KAAK,MAAM,CAAC,CACoB;UACpD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;ACpBjG,MAAa,wBAAwB,OAAO,UAAkB,YAAyC;AAGrG,QAAO,8BAA8B,SADrBC,8BAAgB,SAAS,CACa"}