internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/utils.js

@@ -1,313 +1,17 @@
-'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
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_genID = require('./genID-YJSl3YhL.js');
+
+exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
+exports.base64ToPublicKey = require_genID.base64ToPublicKey;
+exports.base64ToUint8Array = require_genID.base64ToUint8Array;
+exports.bytesToMnemonic = require_genID.bytesToMnemonic;
+exports.bytesToUuid = require_genID.bytesToUuid;
+exports.genMnemonic = require_genID.genMnemonic;
+exports.generateUuid = require_genID.generateUuid;
+exports.hexToUint8Array = require_genID.hexToUint8Array;
+exports.mnemonicToBytes = require_genID.mnemonicToBytes;
+exports.publicKeyToBase64 = require_genID.publicKeyToBase64;
+exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
+exports.uuidToBytes = require_genID.uuidToBytes;

package/dist/utils.mjs

@@ -1,273 +1,3 @@
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
-import * as bip39 from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
+import { a as genMnemonic, c as publicKeyToBase64, d as hexToUint8Array, f as uint8ArrayToBase64, i as bytesToMnemonic, l as UTF8ToUint8, m as uint8ToUTF8, n as generateUuid, o as mnemonicToBytes, p as uint8ArrayToHex, r as uuidToBytes, s as base64ToPublicKey, t as bytesToUuid, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
 
-// 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
+export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };