internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/utils.d.mts

@@ -1,5 +1,6 @@
-import { IdentityKeys, EncryptionKeys, EncryptedKeystore, MediaKeys, PublicKeys, SymmetricCiphertext } from './types.mjs';
+import { g as PublicKeysBase64, h as PublicKeys } from "./types-DwQJtrTx.mjs";
 
+//#region src/utils/converters.d.ts
 /**
  * Converts a Uint8Array into a hexadecimal string.
  *
@@ -42,99 +43,57 @@ declare function uint8ArrayToBase64(buffer: Uint8Array): string;
  * @returns A Uint8Array created from the base64 string.
  */
 declare function base64ToUint8Array(str: string): Uint8Array;
-
-/**
- * Converts identity keys to base64
- *
- * @param keys - The identity keys
- * @returns The resulting base64 string
- */
-declare function identityKeysToBase64(keys: IdentityKeys): Promise<string>;
-/**
- * Converts encryption keys to base64
- *
- * @param keys - The encryption keys
- * @returns The resulting base64 string
- */
-declare function encryptionKeysToBase64(keys: EncryptionKeys): Promise<string>;
-/**
- * Converts encrypted keystore to base64
- *
- * @param keystore - The encrypted keystore
- * @returns The resulting base64 string
- */
-declare function encryptedKeystoreToBase64(keystore: EncryptedKeystore): string;
-/**
- * Converts base64 to identity keys
- *
- * @param base64 - The base64 input
- * @returns The resulting idenity keys
- */
-declare function base64ToIdentityKeys(base64: string): Promise<IdentityKeys>;
-/**
- * Converts base64 to encryption keys
- *
- * @param base64 - The base64 input
- * @returns The resulting encryption keys
- */
-declare function base64ToEncryptionKeys(base64: string): Promise<EncryptionKeys>;
-/**
- * Converts base64 to encrypted keystore
- *
- * @param base64 - The base64 input
- * @returns The resulting encrypted keystore
- */
-declare function base64ToEncryptedKeystore(base64: string): EncryptedKeystore;
-/**
- * Converts media keys to base64
- *
- * @param keys - The media keys
- * @returns The resulting base64 string
- */
-declare function mediaKeysToBase64(keys: MediaKeys): string;
-/**
- * Converts base64 to media keys
- *
- * @param base64 - The base64 input
- * @returns The resulting media keys
- */
-declare function base64ToMediaKeys(base64: string): Promise<MediaKeys>;
+//#endregion
+//#region src/utils/keyConverters.d.ts
 /**
  * Converts a base64 string into PublicKeys type.
  *
  * @param base64 - The base64 representation of the public key.
  * @returns The resulting PublicKeys.
  */
-declare function base64ToPublicKey(base64: string): Promise<PublicKeys>;
+declare function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys>;
 /**
- * Converts a PublicKeys type into base64 string.
+ * Converts a PublicKeys type into PublicKeysBase64.
  *
  * @param key - The PublicKeys key.
- * @returns The resulting base64 string.
+ * @returns The resulting PublicKeysBase64.
  */
-declare function publicKeyToBase64(key: PublicKeys): Promise<string>;
-
+declare function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64>;
+//#endregion
+//#region src/utils/genMnemonic.d.ts
 /**
- * Converts encrypted message to base64 string
+ * Generates a mnemonic
  *
- * @param encryptedMessage - The encrypted message
- * @returns The resulting base64 string.
+ * @returns The generated mnemonic.
  */
-declare function ciphertextToBase64(encryptedMessage: SymmetricCiphertext): string;
+declare function genMnemonic(): string;
 /**
- * Converts base64 string to encrypted message
+ * Converts a mnemonic to Uint8Array
  *
- * @param base64 - The base64 representation of the encrypted message
- * @returns The resulting encrypted message.
+ * @param mnemonic - The mnemonic to convert
+ * @returns The mnemonic as Uint8Array
  */
-declare function base64ToCiphertext(base64: string): SymmetricCiphertext;
-
+declare function mnemonicToBytes(mnemonic: string): Uint8Array;
 /**
- * Generates a mnemonic of required bit strength
+ * Converts a Uint8Array to a mnemonic
  *
- * @param bits - The bit strength.
- * @returns The generated mnemonic.
+ * @param bytes - The bytes to convert
+ * @returns The mnemonic string
  */
-declare function genMnemonic(bits: number): string;
-
-export { UTF8ToUint8, base64ToCiphertext, base64ToEncryptedKeystore, base64ToEncryptionKeys, base64ToIdentityKeys, base64ToMediaKeys, base64ToPublicKey, base64ToUint8Array, ciphertextToBase64, encryptedKeystoreToBase64, encryptionKeysToBase64, genMnemonic, hexToUint8Array, identityKeysToBase64, mediaKeysToBase64, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8 };
+declare function bytesToMnemonic(bytes: Uint8Array): string;
+//#endregion
+//#region src/utils/genID.d.ts
+/**
+ * Creates a random identifier.
+ *
+ * @returns The resulting auxilary string
+ */
+declare function generateUuid(): string;
+declare function uuidToBytes(uuid: string): Uint8Array;
+declare function bytesToUuid(bytes: Uint8Array): string;
+declare namespace index_d_exports {
+  export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+}
+//#endregion
+export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, index_d_exports as t, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+//# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
-import { IdentityKeys, EncryptionKeys, EncryptedKeystore, MediaKeys, PublicKeys, SymmetricCiphertext } from './types.js';
+import { g as PublicKeysBase64, h as PublicKeys } from "./types-Ds3ivE9W.js";
 
+//#region src/utils/converters.d.ts
 /**
  * Converts a Uint8Array into a hexadecimal string.
  *
@@ -42,99 +43,57 @@ declare function uint8ArrayToBase64(buffer: Uint8Array): string;
  * @returns A Uint8Array created from the base64 string.
  */
 declare function base64ToUint8Array(str: string): Uint8Array;
-
-/**
- * Converts identity keys to base64
- *
- * @param keys - The identity keys
- * @returns The resulting base64 string
- */
-declare function identityKeysToBase64(keys: IdentityKeys): Promise<string>;
-/**
- * Converts encryption keys to base64
- *
- * @param keys - The encryption keys
- * @returns The resulting base64 string
- */
-declare function encryptionKeysToBase64(keys: EncryptionKeys): Promise<string>;
-/**
- * Converts encrypted keystore to base64
- *
- * @param keystore - The encrypted keystore
- * @returns The resulting base64 string
- */
-declare function encryptedKeystoreToBase64(keystore: EncryptedKeystore): string;
-/**
- * Converts base64 to identity keys
- *
- * @param base64 - The base64 input
- * @returns The resulting idenity keys
- */
-declare function base64ToIdentityKeys(base64: string): Promise<IdentityKeys>;
-/**
- * Converts base64 to encryption keys
- *
- * @param base64 - The base64 input
- * @returns The resulting encryption keys
- */
-declare function base64ToEncryptionKeys(base64: string): Promise<EncryptionKeys>;
-/**
- * Converts base64 to encrypted keystore
- *
- * @param base64 - The base64 input
- * @returns The resulting encrypted keystore
- */
-declare function base64ToEncryptedKeystore(base64: string): EncryptedKeystore;
-/**
- * Converts media keys to base64
- *
- * @param keys - The media keys
- * @returns The resulting base64 string
- */
-declare function mediaKeysToBase64(keys: MediaKeys): string;
-/**
- * Converts base64 to media keys
- *
- * @param base64 - The base64 input
- * @returns The resulting media keys
- */
-declare function base64ToMediaKeys(base64: string): Promise<MediaKeys>;
+//#endregion
+//#region src/utils/keyConverters.d.ts
 /**
  * Converts a base64 string into PublicKeys type.
  *
  * @param base64 - The base64 representation of the public key.
  * @returns The resulting PublicKeys.
  */
-declare function base64ToPublicKey(base64: string): Promise<PublicKeys>;
+declare function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys>;
 /**
- * Converts a PublicKeys type into base64 string.
+ * Converts a PublicKeys type into PublicKeysBase64.
  *
  * @param key - The PublicKeys key.
- * @returns The resulting base64 string.
+ * @returns The resulting PublicKeysBase64.
  */
-declare function publicKeyToBase64(key: PublicKeys): Promise<string>;
-
+declare function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64>;
+//#endregion
+//#region src/utils/genMnemonic.d.ts
 /**
- * Converts encrypted message to base64 string
+ * Generates a mnemonic
  *
- * @param encryptedMessage - The encrypted message
- * @returns The resulting base64 string.
+ * @returns The generated mnemonic.
  */
-declare function ciphertextToBase64(encryptedMessage: SymmetricCiphertext): string;
+declare function genMnemonic(): string;
 /**
- * Converts base64 string to encrypted message
+ * Converts a mnemonic to Uint8Array
  *
- * @param base64 - The base64 representation of the encrypted message
- * @returns The resulting encrypted message.
+ * @param mnemonic - The mnemonic to convert
+ * @returns The mnemonic as Uint8Array
  */
-declare function base64ToCiphertext(base64: string): SymmetricCiphertext;
-
+declare function mnemonicToBytes(mnemonic: string): Uint8Array;
 /**
- * Generates a mnemonic of required bit strength
+ * Converts a Uint8Array to a mnemonic
  *
- * @param bits - The bit strength.
- * @returns The generated mnemonic.
+ * @param bytes - The bytes to convert
+ * @returns The mnemonic string
  */
-declare function genMnemonic(bits: number): string;
-
-export { UTF8ToUint8, base64ToCiphertext, base64ToEncryptedKeystore, base64ToEncryptionKeys, base64ToIdentityKeys, base64ToMediaKeys, base64ToPublicKey, base64ToUint8Array, ciphertextToBase64, encryptedKeystoreToBase64, encryptionKeysToBase64, genMnemonic, hexToUint8Array, identityKeysToBase64, mediaKeysToBase64, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8 };
+declare function bytesToMnemonic(bytes: Uint8Array): string;
+//#endregion
+//#region src/utils/genID.d.ts
+/**
+ * Creates a random identifier.
+ *
+ * @returns The resulting auxilary string
+ */
+declare function generateUuid(): string;
+declare function uuidToBytes(uuid: string): Uint8Array;
+declare function bytesToUuid(bytes: Uint8Array): string;
+declare namespace index_d_exports {
+  export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+}
+//#endregion
+export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, index_d_exports as t, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,313 +1,16 @@
-'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
+const require_utils = require('./utils-CNs3cyDj.js');
+
+exports.UTF8ToUint8 = require_utils.UTF8ToUint8;
+exports.base64ToPublicKey = require_utils.base64ToPublicKey;
+exports.base64ToUint8Array = require_utils.base64ToUint8Array;
+exports.bytesToMnemonic = require_utils.bytesToMnemonic;
+exports.bytesToUuid = require_utils.bytesToUuid;
+exports.genMnemonic = require_utils.genMnemonic;
+exports.generateUuid = require_utils.generateUuid;
+exports.hexToUint8Array = require_utils.hexToUint8Array;
+exports.mnemonicToBytes = require_utils.mnemonicToBytes;
+exports.publicKeyToBase64 = require_utils.publicKeyToBase64;
+exports.uint8ArrayToBase64 = require_utils.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_utils.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_utils.uint8ToUTF8;
+exports.uuidToBytes = require_utils.uuidToBytes;