internxt-crypto 0.0.9-alpha → 0.0.10-alpha

package/dist/utils.js

@@ -0,0 +1,313 @@
+'use strict';
+
+var utils_js = require('@noble/hashes/utils.js');
+var bip39 = require('@scure/bip39');
+var english = require('@scure/bip39/wordlists/english');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var bip39__namespace = /*#__PURE__*/_interopNamespace(bip39);
+
+// src/utils/converters.ts
+function uint8ArrayToHex(array) {
+  return utils_js.bytesToHex(array);
+}
+function UTF8ToUint8(str) {
+  return new TextEncoder().encode(str);
+}
+function uint8ToUTF8(array) {
+  return new TextDecoder().decode(array);
+}
+function hexToUint8Array(hex) {
+  return utils_js.hexToBytes(hex);
+}
+function uint8ArrayToBase64(buffer) {
+  const array = Uint16Array.from(buffer);
+  const binaryString = new TextDecoder("UTF-16").decode(array);
+  return btoa(binaryString);
+}
+function base64ToUint8Array(str) {
+  const binaryString = atob(str);
+  const len = binaryString.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binaryString.charCodeAt(i);
+  }
+  return new Uint8Array(array.buffer);
+}
+
+// src/constants.ts
+var ECC_ALGORITHM = "X25519";
+
+// src/asymmetric-crypto/keys.ts
+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 });
+  }
+}
+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 });
+  }
+}
+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 });
+  }
+}
+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 });
+  }
+}
+
+// src/utils/aesConverters.ts
+function ciphertextToBase64(encryptedMessage) {
+  try {
+    const ivBase64 = uint8ArrayToBase64(encryptedMessage.iv);
+    const ciphertextBase64 = uint8ArrayToBase64(encryptedMessage.ciphertext);
+    const json = JSON.stringify({ ciphertext: ciphertextBase64, iv: ivBase64 });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert ciphertext to base64", { cause: error });
+  }
+}
+function base64ToCiphertext(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const iv = base64ToUint8Array(obj.iv);
+    const ciphertext = base64ToUint8Array(obj.ciphertext);
+    const result = {
+      ciphertext,
+      iv
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to ciphertext", { cause: error });
+  }
+}
+
+// src/utils/keyConverters.ts
+async function identityKeysToBase64(keys) {
+  try {
+    const pkArray = await exportPublicKey(keys.userPublicKey);
+    const skArray = await exportPrivateKey(keys.userPrivateKey);
+    const json = JSON.stringify({
+      userPublicKey: uint8ArrayToBase64(pkArray),
+      userPrivateKey: uint8ArrayToBase64(skArray)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert identity keys to base64", { cause: error });
+  }
+}
+async function encryptionKeysToBase64(keys) {
+  try {
+    const pkArray = await exportPublicKey(keys.userPublicKey);
+    const skArray = await exportPrivateKey(keys.userPrivateKey);
+    const json = JSON.stringify({
+      userPublicKey: uint8ArrayToBase64(pkArray),
+      userPrivateKey: uint8ArrayToBase64(skArray),
+      userPublicKyberKey: uint8ArrayToBase64(keys.userPublicKyberKey),
+      userPrivateKyberKey: uint8ArrayToBase64(keys.userPrivateKyberKey)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert identity keys to base64", { cause: error });
+  }
+}
+function encryptedKeystoreToBase64(keystore) {
+  try {
+    const ciphertext = ciphertextToBase64(keystore.encryptedKeys);
+    const json = JSON.stringify({
+      userID: keystore.userID,
+      type: keystore.type.toString(),
+      encryptedKeys: ciphertext
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert encrypted keystore to base64", { cause: error });
+  }
+}
+async function base64ToIdentityKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const pkArray = base64ToUint8Array(obj.userPublicKey);
+    const skArray = base64ToUint8Array(obj.userPrivateKey);
+    const pkCryptoKey = await importPublicKey(pkArray);
+    const skCryptoKey = await importPrivateKey(skArray);
+    const result = {
+      userPublicKey: pkCryptoKey,
+      userPrivateKey: skCryptoKey
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed convert base64 to idenity key", { cause: error });
+  }
+}
+async function base64ToEncryptionKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const pkArray = base64ToUint8Array(obj.userPublicKey);
+    const skArray = base64ToUint8Array(obj.userPrivateKey);
+    const pkCryptoKey = await importPublicKey(pkArray);
+    const skCryptoKey = await importPrivateKey(skArray);
+    const pkKyber = base64ToUint8Array(obj.userPublicKyberKey);
+    const skKyber = base64ToUint8Array(obj.userPrivateKyberKey);
+    const result = {
+      userPublicKey: pkCryptoKey,
+      userPrivateKey: skCryptoKey,
+      userPublicKyberKey: pkKyber,
+      userPrivateKyberKey: skKyber
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to encryption key", { cause: error });
+  }
+}
+function base64ToEncryptedKeystore(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const ciphertext = base64ToCiphertext(obj.encryptedKeys);
+    const result = {
+      userID: obj.userID,
+      type: obj.type,
+      encryptedKeys: ciphertext
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to encrypted keystore", { cause: error });
+  }
+}
+function mediaKeysToBase64(keys) {
+  try {
+    const json = JSON.stringify({
+      olmKey: uint8ArrayToBase64(keys.olmKey),
+      pqKey: uint8ArrayToBase64(keys.pqKey),
+      index: keys.index.toString(),
+      userID: keys.userID
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert media keys to base64", { cause: error });
+  }
+}
+async function base64ToMediaKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const result = {
+      olmKey: base64ToUint8Array(obj.olmKey),
+      pqKey: base64ToUint8Array(obj.pqKey),
+      index: Number(obj.index),
+      userID: obj.userID
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed convert base64 to media keys", { cause: error });
+  }
+}
+async function base64ToPublicKey(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const eccPublicKeyBytes = base64ToUint8Array(obj.eccPublicKey);
+    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);
+    const kyberPublicKey = base64ToUint8Array(obj.kyberPublicKey);
+    return {
+      eccPublicKey,
+      kyberPublicKey
+    };
+  } catch (error) {
+    throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
+  }
+}
+async function publicKeyToBase64(key) {
+  try {
+    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);
+    const json = JSON.stringify({
+      eccPublicKey: uint8ArrayToBase64(eccPublicKeyArray),
+      kyberPublicKey: uint8ArrayToBase64(key.kyberPublicKey)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert key of the type PublicKeys to base64", { cause: error });
+  }
+}
+function genMnemonic(bits) {
+  return bip39__namespace.generateMnemonic(english.wordlist, bits);
+}
+
+exports.UTF8ToUint8 = UTF8ToUint8;
+exports.base64ToCiphertext = base64ToCiphertext;
+exports.base64ToEncryptedKeystore = base64ToEncryptedKeystore;
+exports.base64ToEncryptionKeys = base64ToEncryptionKeys;
+exports.base64ToIdentityKeys = base64ToIdentityKeys;
+exports.base64ToMediaKeys = base64ToMediaKeys;
+exports.base64ToPublicKey = base64ToPublicKey;
+exports.base64ToUint8Array = base64ToUint8Array;
+exports.ciphertextToBase64 = ciphertextToBase64;
+exports.encryptedKeystoreToBase64 = encryptedKeystoreToBase64;
+exports.encryptionKeysToBase64 = encryptionKeysToBase64;
+exports.genMnemonic = genMnemonic;
+exports.hexToUint8Array = hexToUint8Array;
+exports.identityKeysToBase64 = identityKeysToBase64;
+exports.mediaKeysToBase64 = mediaKeysToBase64;
+exports.publicKeyToBase64 = publicKeyToBase64;
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+exports.uint8ArrayToHex = uint8ArrayToHex;
+exports.uint8ToUTF8 = uint8ToUTF8;
+//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/converters.ts","../src/constants.ts","../src/asymmetric-crypto/keys.ts","../src/utils/aesConverters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts"],"names":["bytesToHex","hexToBytes","bip39","wordlist"],"mappings":"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","file":"utils.js","sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.charCodeAt(i);\n  }\n  return new Uint8Array(array.buffer);\n}\n","export const AES_ALGORITHM = 'AES-GCM';\nexport const AES_KEY_BIT_LENGTH = 256;\nexport const AUX_LEN = 128;\nexport const IV_LEN_BYTES = 16;\n\nexport const KEY_WRAPPING_ALGORITHM = 'AES-KW';\nexport const KEY_FORMAT = 'raw';\nexport const CONTEXT_WRAPPING = 'CRYPTO library 2025-08-22 18:10:00 key derived from ecc and kyber secrets';\n\nexport const ECC_ALGORITHM = 'X25519';\n\nexport const CONTEXT_LOGIN = 'CRYPTO library 2025-07-26 16:18:03 key for opening identity keystore';\nexport const CONTEXT_ENC_KEYSTORE = 'CRYPTO library 2025-07-30 16:18:03 key for opening encryption keys keystore';\nexport const CONTEXT_RECOVERY = 'CRYPTO library 2025-07-30 16:20:00 key for account recovery';\nexport const CONTEXT_INDEX = 'CRYPTO library 2025-07-30 17:20:00 key for protecting current search indices';\nexport const CONTEXT_DERIVE = 'CRYPTO library 2025-08-27 17:08:00 derive one key from two keys';\n\nexport const PREFIX_MEDIA_KEY_COMMITMENT = 'CRYPTO library 2025-08-26 18:29:00 prefix for commitment to media keys';\nexport const PREFIX_PUBLIC_KEY_COMMITMENT = 'CRYPTO library 2025-08-26 18:30:00 prefix for commitment to public keys';\nexport const PREFIX_IDENTITY_KEY_COMMITMENT =\n  'CRYPTO library 2025-08-26 18:45:00 prefix for commitment to identity keys';\n\n// Second recommended parameter set from RFC 9106\nexport const ARGON2ID_PARALLELISM = 3;\nexport const ARGON2ID_ITERATIONS = 4;\nexport const ARGON2ID_MEMORY_SIZE = 65536;\nexport const ARGON2ID_SALT_BYTE_LENGTH = 16;\nexport const ARGON2ID_OUTPUT_BYTE_LENGTH = 32;\n\nexport const IDENTITY_KEYSTORE_TAG = 'Identity keystore';\nexport const ENCRYPTION_KEYSTORE_TAG = 'Encryption keystore';\nexport const RECOVERY_KEYSTORE_TAG = 'Key recovery keystroe';\nexport const INDEX_KEYSTORE_TAG = 'Current encrypted indices';\n\nexport const KYBER512_PUBLIC_KEY_LENGTH = 800;\nexport const KYBER512_SECRET_KEY_LENGTH = 1632;\n\nexport const KYBER768_PUBLIC_KEY_LENGTH = 1184;\nexport const KYBER768_SECRET_KEY_LENGTH = 2400;\n\nexport const KYBER1024_PUBLIC_KEY_LENGTH = 1568;\nexport const KYBER1024_SECRET_KEY_LENGTH = 3168;\n\nexport const KYBER_SEED_LENGTH = 64;\n\nexport const HASH_BIT_LEN = 256;\n\nexport const MAX_CACHE_SIZE = 600000000; // 600 MB\nexport const MAX_EMAIL_PER_BATCH = 100;\nexport const DB_LABEL = 'email';\nexport const DB_VERSION = 1;\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","import { uint8ArrayToBase64, base64ToUint8Array } from './converters';\nimport { SymmetricCiphertext } from '../types';\n\n/**\n * Converts encrypted message to base64 string\n *\n * @param encryptedMessage - The encrypted message\n * @returns The resulting base64 string.\n */\nexport function ciphertextToBase64(encryptedMessage: SymmetricCiphertext): string {\n  try {\n    const ivBase64 = uint8ArrayToBase64(encryptedMessage.iv);\n    const ciphertextBase64 = uint8ArrayToBase64(encryptedMessage.ciphertext);\n    const json = JSON.stringify({ ciphertext: ciphertextBase64, iv: ivBase64 });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert ciphertext to base64', { cause: error });\n  }\n}\n\n/**\n * Converts base64 string to encrypted message\n *\n * @param base64 - The base64 representation of the encrypted message\n * @returns The resulting encrypted message.\n */\nexport function base64ToCiphertext(base64: string): SymmetricCiphertext {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n    const iv = base64ToUint8Array(obj.iv);\n    const ciphertext = base64ToUint8Array(obj.ciphertext);\n    const result: SymmetricCiphertext = {\n      ciphertext,\n      iv,\n    };\n    return result;\n  } catch (error) {\n    throw new Error('Failed to convert base64 to ciphertext', { cause: error });\n  }\n}\n","import { uint8ArrayToBase64, base64ToUint8Array } from '.';\nimport { IdentityKeys, EncryptionKeys, EncryptedKeystore, MediaKeys, PublicKeys } from '../types';\nimport { exportPublicKey, exportPrivateKey, importPublicKey, importPrivateKey } from '../asymmetric-crypto';\nimport { base64ToCiphertext, ciphertextToBase64 } from './aesConverters';\n\n/**\n * Converts identity keys to base64\n *\n * @param keys - The identity keys\n * @returns The resulting base64 string\n */\nexport async function identityKeysToBase64(keys: IdentityKeys): Promise<string> {\n  try {\n    const pkArray = await exportPublicKey(keys.userPublicKey);\n    const skArray = await exportPrivateKey(keys.userPrivateKey);\n    const json = JSON.stringify({\n      userPublicKey: uint8ArrayToBase64(pkArray),\n      userPrivateKey: uint8ArrayToBase64(skArray),\n    });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert identity keys to base64', { cause: error });\n  }\n}\n\n/**\n * Converts encryption keys to base64\n *\n * @param keys - The encryption keys\n * @returns The resulting base64 string\n */\nexport async function encryptionKeysToBase64(keys: EncryptionKeys): Promise<string> {\n  try {\n    const pkArray = await exportPublicKey(keys.userPublicKey);\n    const skArray = await exportPrivateKey(keys.userPrivateKey);\n    const json = JSON.stringify({\n      userPublicKey: uint8ArrayToBase64(pkArray),\n      userPrivateKey: uint8ArrayToBase64(skArray),\n      userPublicKyberKey: uint8ArrayToBase64(keys.userPublicKyberKey),\n      userPrivateKyberKey: uint8ArrayToBase64(keys.userPrivateKyberKey),\n    });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert identity keys to base64', { cause: error });\n  }\n}\n\n/**\n * Converts encrypted keystore to base64\n *\n * @param keystore - The encrypted keystore\n * @returns The resulting base64 string\n */\nexport function encryptedKeystoreToBase64(keystore: EncryptedKeystore): string {\n  try {\n    const ciphertext = ciphertextToBase64(keystore.encryptedKeys);\n    const json = JSON.stringify({\n      userID: keystore.userID,\n      type: keystore.type.toString(),\n      encryptedKeys: ciphertext,\n    });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert encrypted keystore to base64', { cause: error });\n  }\n}\n\n/**\n * Converts base64 to identity keys\n *\n * @param base64 - The base64 input\n * @returns The resulting idenity keys\n */\nexport async function base64ToIdentityKeys(base64: string): Promise<IdentityKeys> {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n    const pkArray = base64ToUint8Array(obj.userPublicKey);\n    const skArray = base64ToUint8Array(obj.userPrivateKey);\n    const pkCryptoKey = await importPublicKey(pkArray);\n    const skCryptoKey = await importPrivateKey(skArray);\n    const result: IdentityKeys = {\n      userPublicKey: pkCryptoKey,\n      userPrivateKey: skCryptoKey,\n    };\n    return result;\n  } catch (error) {\n    throw new Error('Failed convert base64 to idenity key', { cause: error });\n  }\n}\n\n/**\n * Converts base64 to encryption keys\n *\n * @param base64 - The base64 input\n * @returns The resulting encryption keys\n */\nexport async function base64ToEncryptionKeys(base64: string): Promise<EncryptionKeys> {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n    const pkArray = base64ToUint8Array(obj.userPublicKey);\n    const skArray = base64ToUint8Array(obj.userPrivateKey);\n    const pkCryptoKey = await importPublicKey(pkArray);\n    const skCryptoKey = await importPrivateKey(skArray);\n    const pkKyber = base64ToUint8Array(obj.userPublicKyberKey);\n    const skKyber = base64ToUint8Array(obj.userPrivateKyberKey);\n    const result: EncryptionKeys = {\n      userPublicKey: pkCryptoKey,\n      userPrivateKey: skCryptoKey,\n      userPublicKyberKey: pkKyber,\n      userPrivateKyberKey: skKyber,\n    };\n    return result;\n  } catch (error) {\n    throw new Error('Failed to convert base64 to encryption key', { cause: error });\n  }\n}\n\n/**\n * Converts base64 to encrypted keystore\n *\n * @param base64 - The base64 input\n * @returns The resulting encrypted keystore\n */\nexport function base64ToEncryptedKeystore(base64: string): EncryptedKeystore {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n    const ciphertext = base64ToCiphertext(obj.encryptedKeys);\n    const result: EncryptedKeystore = {\n      userID: obj.userID,\n      type: obj.type,\n      encryptedKeys: ciphertext,\n    };\n    return result;\n  } catch (error) {\n    throw new Error('Failed to convert base64 to encrypted keystore', { cause: error });\n  }\n}\n\n/**\n * Converts media keys to base64\n *\n * @param keys - The media keys\n * @returns The resulting base64 string\n */\nexport function mediaKeysToBase64(keys: MediaKeys): string {\n  try {\n    const json = JSON.stringify({\n      olmKey: uint8ArrayToBase64(keys.olmKey),\n      pqKey: uint8ArrayToBase64(keys.pqKey),\n      index: keys.index.toString(),\n      userID: keys.userID,\n    });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert media keys to base64', { cause: error });\n  }\n}\n\n/**\n * Converts base64 to media keys\n *\n * @param base64 - The base64 input\n * @returns The resulting media keys\n */\nexport async function base64ToMediaKeys(base64: string): Promise<MediaKeys> {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n\n    const result: MediaKeys = {\n      olmKey: base64ToUint8Array(obj.olmKey),\n      pqKey: base64ToUint8Array(obj.pqKey),\n      index: Number(obj.index),\n      userID: obj.userID,\n    };\n    return result;\n  } catch (error) {\n    throw new Error('Failed convert base64 to media keys', { cause: error });\n  }\n}\n\n/**\n * Converts a base64 string into PublicKeys type.\n *\n * @param base64 - The base64 representation of the public key.\n * @returns The resulting PublicKeys.\n */\nexport async function base64ToPublicKey(base64: string): Promise<PublicKeys> {\n  try {\n    const json = atob(base64);\n    const obj = JSON.parse(json);\n    const eccPublicKeyBytes = base64ToUint8Array(obj.eccPublicKey);\n    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);\n    const kyberPublicKey = base64ToUint8Array(obj.kyberPublicKey);\n    return {\n      eccPublicKey: eccPublicKey,\n      kyberPublicKey: kyberPublicKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to convert base64 to PublicKeys', { cause: error });\n  }\n}\n\n/**\n * Converts a PublicKeys type into base64 string.\n *\n * @param key - The PublicKeys key.\n * @returns The resulting base64 string.\n */\nexport async function publicKeyToBase64(key: PublicKeys): Promise<string> {\n  try {\n    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);\n    const json = JSON.stringify({\n      eccPublicKey: uint8ArrayToBase64(eccPublicKeyArray),\n      kyberPublicKey: uint8ArrayToBase64(key.kyberPublicKey),\n    });\n    const base64 = btoa(json);\n    return base64;\n  } catch (error) {\n    throw new Error('Failed to convert key of the type PublicKeys to base64', { cause: error });\n  }\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english';\n\n/**\n * Generates a mnemonic of required bit strength\n *\n * @param bits - The bit strength.\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(bits: number): string {\n  return bip39.generateMnemonic(wordlist, bits);\n}\n"]}

package/dist/utils.mjs

@@ -0,0 +1,273 @@
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
+import * as bip39 from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+
+// src/utils/converters.ts
+function uint8ArrayToHex(array) {
+  return bytesToHex(array);
+}
+function UTF8ToUint8(str) {
+  return new TextEncoder().encode(str);
+}
+function uint8ToUTF8(array) {
+  return new TextDecoder().decode(array);
+}
+function hexToUint8Array(hex) {
+  return hexToBytes(hex);
+}
+function uint8ArrayToBase64(buffer) {
+  const array = Uint16Array.from(buffer);
+  const binaryString = new TextDecoder("UTF-16").decode(array);
+  return btoa(binaryString);
+}
+function base64ToUint8Array(str) {
+  const binaryString = atob(str);
+  const len = binaryString.length;
+  const array = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = binaryString.charCodeAt(i);
+  }
+  return new Uint8Array(array.buffer);
+}
+
+// src/constants.ts
+var ECC_ALGORITHM = "X25519";
+
+// src/asymmetric-crypto/keys.ts
+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 });
+  }
+}
+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 });
+  }
+}
+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 });
+  }
+}
+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 });
+  }
+}
+
+// src/utils/aesConverters.ts
+function ciphertextToBase64(encryptedMessage) {
+  try {
+    const ivBase64 = uint8ArrayToBase64(encryptedMessage.iv);
+    const ciphertextBase64 = uint8ArrayToBase64(encryptedMessage.ciphertext);
+    const json = JSON.stringify({ ciphertext: ciphertextBase64, iv: ivBase64 });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert ciphertext to base64", { cause: error });
+  }
+}
+function base64ToCiphertext(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const iv = base64ToUint8Array(obj.iv);
+    const ciphertext = base64ToUint8Array(obj.ciphertext);
+    const result = {
+      ciphertext,
+      iv
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to ciphertext", { cause: error });
+  }
+}
+
+// src/utils/keyConverters.ts
+async function identityKeysToBase64(keys) {
+  try {
+    const pkArray = await exportPublicKey(keys.userPublicKey);
+    const skArray = await exportPrivateKey(keys.userPrivateKey);
+    const json = JSON.stringify({
+      userPublicKey: uint8ArrayToBase64(pkArray),
+      userPrivateKey: uint8ArrayToBase64(skArray)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert identity keys to base64", { cause: error });
+  }
+}
+async function encryptionKeysToBase64(keys) {
+  try {
+    const pkArray = await exportPublicKey(keys.userPublicKey);
+    const skArray = await exportPrivateKey(keys.userPrivateKey);
+    const json = JSON.stringify({
+      userPublicKey: uint8ArrayToBase64(pkArray),
+      userPrivateKey: uint8ArrayToBase64(skArray),
+      userPublicKyberKey: uint8ArrayToBase64(keys.userPublicKyberKey),
+      userPrivateKyberKey: uint8ArrayToBase64(keys.userPrivateKyberKey)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert identity keys to base64", { cause: error });
+  }
+}
+function encryptedKeystoreToBase64(keystore) {
+  try {
+    const ciphertext = ciphertextToBase64(keystore.encryptedKeys);
+    const json = JSON.stringify({
+      userID: keystore.userID,
+      type: keystore.type.toString(),
+      encryptedKeys: ciphertext
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert encrypted keystore to base64", { cause: error });
+  }
+}
+async function base64ToIdentityKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const pkArray = base64ToUint8Array(obj.userPublicKey);
+    const skArray = base64ToUint8Array(obj.userPrivateKey);
+    const pkCryptoKey = await importPublicKey(pkArray);
+    const skCryptoKey = await importPrivateKey(skArray);
+    const result = {
+      userPublicKey: pkCryptoKey,
+      userPrivateKey: skCryptoKey
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed convert base64 to idenity key", { cause: error });
+  }
+}
+async function base64ToEncryptionKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const pkArray = base64ToUint8Array(obj.userPublicKey);
+    const skArray = base64ToUint8Array(obj.userPrivateKey);
+    const pkCryptoKey = await importPublicKey(pkArray);
+    const skCryptoKey = await importPrivateKey(skArray);
+    const pkKyber = base64ToUint8Array(obj.userPublicKyberKey);
+    const skKyber = base64ToUint8Array(obj.userPrivateKyberKey);
+    const result = {
+      userPublicKey: pkCryptoKey,
+      userPrivateKey: skCryptoKey,
+      userPublicKyberKey: pkKyber,
+      userPrivateKyberKey: skKyber
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to encryption key", { cause: error });
+  }
+}
+function base64ToEncryptedKeystore(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const ciphertext = base64ToCiphertext(obj.encryptedKeys);
+    const result = {
+      userID: obj.userID,
+      type: obj.type,
+      encryptedKeys: ciphertext
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to convert base64 to encrypted keystore", { cause: error });
+  }
+}
+function mediaKeysToBase64(keys) {
+  try {
+    const json = JSON.stringify({
+      olmKey: uint8ArrayToBase64(keys.olmKey),
+      pqKey: uint8ArrayToBase64(keys.pqKey),
+      index: keys.index.toString(),
+      userID: keys.userID
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert media keys to base64", { cause: error });
+  }
+}
+async function base64ToMediaKeys(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const result = {
+      olmKey: base64ToUint8Array(obj.olmKey),
+      pqKey: base64ToUint8Array(obj.pqKey),
+      index: Number(obj.index),
+      userID: obj.userID
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed convert base64 to media keys", { cause: error });
+  }
+}
+async function base64ToPublicKey(base64) {
+  try {
+    const json = atob(base64);
+    const obj = JSON.parse(json);
+    const eccPublicKeyBytes = base64ToUint8Array(obj.eccPublicKey);
+    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);
+    const kyberPublicKey = base64ToUint8Array(obj.kyberPublicKey);
+    return {
+      eccPublicKey,
+      kyberPublicKey
+    };
+  } catch (error) {
+    throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
+  }
+}
+async function publicKeyToBase64(key) {
+  try {
+    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);
+    const json = JSON.stringify({
+      eccPublicKey: uint8ArrayToBase64(eccPublicKeyArray),
+      kyberPublicKey: uint8ArrayToBase64(key.kyberPublicKey)
+    });
+    const base64 = btoa(json);
+    return base64;
+  } catch (error) {
+    throw new Error("Failed to convert key of the type PublicKeys to base64", { cause: error });
+  }
+}
+function genMnemonic(bits) {
+  return bip39.generateMnemonic(wordlist, bits);
+}
+
+export { UTF8ToUint8, base64ToCiphertext, base64ToEncryptedKeystore, base64ToEncryptionKeys, base64ToIdentityKeys, base64ToMediaKeys, base64ToPublicKey, base64ToUint8Array, ciphertextToBase64, encryptedKeystoreToBase64, encryptionKeysToBase64, genMnemonic, hexToUint8Array, identityKeysToBase64, mediaKeysToBase64, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8 };
+//# sourceMappingURL=utils.mjs.map
+//# sourceMappingURL=utils.mjs.map