internxt-crypto 0.0.9-alpha → 0.0.10-alpha

package/dist/keystore-crypto.d.mts

@@ -0,0 +1,66 @@
+import { EncryptionKeys, EncryptedKeystore, IdentityKeys } from './types.mjs';
+
+/**
+ * Generates recovery codes
+ *
+ * @returns The generated recovery codes
+ */
+declare function generateRecoveryCodes(): string;
+/**
+ * Generates encryption keys
+ *
+ * @returns The generated encryption keys
+ */
+declare function generateEncryptionKeys(): Promise<EncryptionKeys>;
+/**
+ * Generates email encryption keys and creates encrypted encryption and recovery keystores
+ * The encryption key is derived from the base key (stored in session storage)
+ *
+ * @returns The encryption and recovery keystores
+ */
+declare function createEncryptionAndRecoveryKeystores(): Promise<{
+    encryptionKeystore: EncryptedKeystore;
+    recoveryKeystore: EncryptedKeystore;
+    recoveryCodes: string;
+}>;
+/**
+ * Opens the encryption keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
+/**
+ * Opens the recovery keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param recoveryCodes - The user's recovery codes
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
+
+/**
+ * Generates user idenity keys
+ *
+ * @returns The user identity keys
+ */
+declare function generateIdentityKeys(): Promise<IdentityKeys>;
+/**
+ * Generates user identity keys and creates an encrypted identity keystore
+ * The encryption key is derived from the base key (stored in session storage)
+ *
+ * @returns The encrypted idenity keystore
+ */
+declare function createIdentityKeystore(): Promise<EncryptedKeystore>;
+/**
+ * Opens the encrypted identity keystore
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted identity keystore
+ * @returns The identity keys
+ */
+declare function openIdentityKeystore(encryptedKeystore: EncryptedKeystore): Promise<IdentityKeys>;
+
+export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };

package/dist/keystore-crypto.d.ts

@@ -0,0 +1,66 @@
+import { EncryptionKeys, EncryptedKeystore, IdentityKeys } from './types.js';
+
+/**
+ * Generates recovery codes
+ *
+ * @returns The generated recovery codes
+ */
+declare function generateRecoveryCodes(): string;
+/**
+ * Generates encryption keys
+ *
+ * @returns The generated encryption keys
+ */
+declare function generateEncryptionKeys(): Promise<EncryptionKeys>;
+/**
+ * Generates email encryption keys and creates encrypted encryption and recovery keystores
+ * The encryption key is derived from the base key (stored in session storage)
+ *
+ * @returns The encryption and recovery keystores
+ */
+declare function createEncryptionAndRecoveryKeystores(): Promise<{
+    encryptionKeystore: EncryptedKeystore;
+    recoveryKeystore: EncryptedKeystore;
+    recoveryCodes: string;
+}>;
+/**
+ * Opens the encryption keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openEncryptionKeystore(encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
+/**
+ * Opens the recovery keystore and returns the email encryption keys
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param recoveryCodes - The user's recovery codes
+ * @param encryptedKeystore - The encrypted keystore containing encryption keys
+ * @returns The encryption keys
+ */
+declare function openRecoveryKeystore(recoveryCodes: string, encryptedKeystore: EncryptedKeystore): Promise<EncryptionKeys>;
+
+/**
+ * Generates user idenity keys
+ *
+ * @returns The user identity keys
+ */
+declare function generateIdentityKeys(): Promise<IdentityKeys>;
+/**
+ * Generates user identity keys and creates an encrypted identity keystore
+ * The encryption key is derived from the base key (stored in session storage)
+ *
+ * @returns The encrypted idenity keystore
+ */
+declare function createIdentityKeystore(): Promise<EncryptedKeystore>;
+/**
+ * Opens the encrypted identity keystore
+ * The decryption key is derived from the base key (stored in session storage)
+ *
+ * @param encryptedKeystore - The encrypted identity keystore
+ * @returns The identity keys
+ */
+declare function openIdentityKeystore(encryptedKeystore: EncryptedKeystore): Promise<IdentityKeys>;
+
+export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };

package/dist/keystore-crypto.js

@@ -0,0 +1,530 @@
+'use strict';
+
+var utils_js = require('@noble/hashes/utils.js');
+var bip39 = require('@scure/bip39');
+var english = require('@scure/bip39/wordlists/english');
+var blake3_js = require('@noble/hashes/blake3.js');
+var utils_js$1 = require('@noble/post-quantum/utils.js');
+var mlKem_js = require('@noble/post-quantum/ml-kem.js');
+
+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 UTF8ToUint8(str) {
+  return new TextEncoder().encode(str);
+}
+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 AES_ALGORITHM = "AES-GCM";
+var AES_KEY_BIT_LENGTH = 256;
+var AUX_LEN = 128;
+var IV_LEN_BYTES = 16;
+var KEY_FORMAT = "raw";
+var ECC_ALGORITHM = "X25519";
+var CONTEXT_LOGIN = "CRYPTO library 2025-07-26 16:18:03 key for opening identity keystore";
+var CONTEXT_ENC_KEYSTORE = "CRYPTO library 2025-07-30 16:18:03 key for opening encryption keys keystore";
+var CONTEXT_RECOVERY = "CRYPTO library 2025-07-30 16:20:00 key for account recovery";
+var IDENTITY_KEYSTORE_TAG = "Identity keystore";
+var ENCRYPTION_KEYSTORE_TAG = "Encryption keystore";
+var RECOVERY_KEYSTORE_TAG = "Key recovery keystroe";
+
+// src/asymmetric-crypto/keys.ts
+async function generateEccKeys() {
+  try {
+    return await crypto.subtle.generateKey(
+      {
+        name: ECC_ALGORITHM
+      },
+      true,
+      ["deriveBits"]
+    );
+  } catch (error) {
+    throw new Error("Failed to generate elliptic curve key pair", { cause: error });
+  }
+}
+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/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 });
+  }
+}
+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 genMnemonic(bits) {
+  return bip39__namespace.generateMnemonic(english.wordlist, bits);
+}
+function getBytesFromString(bytes, value) {
+  return blake3_js.blake3(utils_js.utf8ToBytes(value), { dkLen: bytes });
+}
+
+// src/symmetric-crypto/keys.ts
+async function importSymmetricCryptoKey(keyData) {
+  return crypto.subtle.importKey(
+    KEY_FORMAT,
+    new Uint8Array(keyData),
+    {
+      name: AES_ALGORITHM,
+      length: AES_KEY_BIT_LENGTH
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+async function createNISTbasedIV(freeField) {
+  try {
+    if (!freeField) {
+      return utils_js$1.randomBytes(IV_LEN_BYTES);
+    }
+    const iv = new Uint8Array(16);
+    const randFiled = utils_js$1.randomBytes(12);
+    iv.set(randFiled, 0);
+    const freeFiledFixedLength = await getBytesFromString(4, freeField);
+    iv.set(freeFiledFixedLength, 12);
+    return iv;
+  } catch (error) {
+    throw new Error("Failed to create IV", { cause: error });
+  }
+}
+async function makeAuxFixedLength(aux) {
+  return getBytesFromString(AUX_LEN / 8, aux);
+}
+async function encryptMessage(message, encryptionKey, iv, additionalData) {
+  try {
+    const encrypted = await crypto.subtle.encrypt(
+      { name: AES_ALGORITHM, iv, additionalData },
+      encryptionKey,
+      message
+    );
+    return new Uint8Array(encrypted);
+  } catch (error) {
+    throw new Error("Failed to encrypt symmetrically", { cause: error });
+  }
+}
+async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
+  try {
+    const decrypted = await crypto.subtle.decrypt(
+      { name: AES_ALGORITHM, iv, additionalData },
+      encryptionKey,
+      ciphertext
+    );
+    return new Uint8Array(decrypted);
+  } catch (error) {
+    throw new Error("Failed to decrypt symmetrically", { cause: error });
+  }
+}
+
+// src/symmetric-crypto/aes.ts
+async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
+  try {
+    const iv = await createNISTbasedIV(freeField);
+    const additionalData = await makeAuxFixedLength(aux);
+    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
+    return { ciphertext, iv };
+  } catch (error) {
+    throw new Error("Failed to encrypt symmetrically", { cause: error });
+  }
+}
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+  try {
+    const additionalData = await makeAuxFixedLength(aux);
+    const result = await decryptMessage(
+      encryptedMessage.ciphertext,
+      encryptedMessage.iv,
+      encryptionKey,
+      additionalData
+    );
+    return result;
+  } catch (error) {
+    throw new Error("Failed to decrypt symmetrically", { cause: error });
+  }
+}
+
+// src/storage-service/sessionStorageService.ts
+function get(key) {
+  return sessionStorage.getItem(key);
+}
+function set(key, value) {
+  return sessionStorage.setItem(key, value);
+}
+function removeItem(key) {
+  sessionStorage.removeItem(key);
+}
+function exists(key) {
+  return !!sessionStorage.getItem(key);
+}
+function clear() {
+  sessionStorage.clear();
+}
+var sessionStorageService = {
+  set,
+  get,
+  removeItem,
+  exists,
+  clear
+};
+var sessionStorageService_default = sessionStorageService;
+function deriveSymmetricKeyFromContext(context, baseKey) {
+  return blake3_js.blake3(baseKey, { context: UTF8ToUint8(context) });
+}
+async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
+  try {
+    if (baseKey.length != AES_KEY_BIT_LENGTH / 8) {
+      throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
+    }
+    if (!context) {
+      throw new Error("Context is empry");
+    }
+    const keyBytes = deriveSymmetricKeyFromContext(context, baseKey);
+    const key = await importSymmetricCryptoKey(keyBytes);
+    return key;
+  } catch (error) {
+    throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
+  }
+}
+
+// src/keystore-crypto/core.ts
+async function encryptKeystoreContent(secretKey, content, userID, tag) {
+  try {
+    const aux = userID + tag;
+    const message = base64ToUint8Array(content);
+    const result = await encryptSymmetrically(secretKey, message, aux);
+    return result;
+  } catch (error) {
+    throw new Error("Failed to encrypt keystore content", { cause: error });
+  }
+}
+async function decryptKeystoreContent(secretKey, encryptedKeys, userID, tag) {
+  try {
+    const aux = userID + tag;
+    const content = await decryptSymmetrically(secretKey, encryptedKeys, aux);
+    const result = uint8ArrayToBase64(content);
+    return result;
+  } catch (error) {
+    throw new Error("Failed to decrypt keystore content", { cause: error });
+  }
+}
+function getUserID() {
+  try {
+    const userID = sessionStorageService_default.get("userID");
+    if (!userID) {
+      throw new Error("No UserID");
+    }
+    return userID;
+  } catch (error) {
+    throw new Error("Failed to get UserID from session storage", { cause: error });
+  }
+}
+function getBaseKey() {
+  try {
+    const baseKeyBase64 = sessionStorageService_default.get("baseKey");
+    if (!baseKeyBase64) {
+      throw new Error("No base key");
+    }
+    return base64ToUint8Array(baseKeyBase64);
+  } catch (error) {
+    throw new Error("Failed to get base key from session storage", { cause: error });
+  }
+}
+async function deriveIdentityKeystoreKey(baseKey) {
+  return deriveSymmetricCryptoKeyFromContext(CONTEXT_LOGIN, baseKey);
+}
+async function deriveRecoveryKey(recoveryCodes) {
+  const recoveryCodesBuffer = await getBytesFromString(AES_KEY_BIT_LENGTH / 8, recoveryCodes);
+  return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);
+}
+async function deriveEncryptionKeystoreKey(baseKey) {
+  return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
+}
+function generateKyberKeys(seed) {
+  try {
+    return mlKem_js.ml_kem768.keygen(seed);
+  } catch (error) {
+    throw new Error("Failed to generate Kyber keys", { cause: error });
+  }
+}
+
+// src/keystore-crypto/emailEncryptionKey.ts
+function generateRecoveryCodes() {
+  return genMnemonic(AES_KEY_BIT_LENGTH);
+}
+async function generateEncryptionKeys() {
+  try {
+    const keyPair = await generateEccKeys();
+    const keyPairKyber = generateKyberKeys();
+    const result = {
+      userPrivateKey: keyPair.privateKey,
+      userPublicKey: keyPair.publicKey,
+      userPublicKyberKey: keyPairKyber.publicKey,
+      userPrivateKyberKey: keyPairKyber.secretKey
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to generate encryption keys", { cause: error });
+  }
+}
+async function createEncryptionAndRecoveryKeystores() {
+  try {
+    const userID = getUserID();
+    const baseKey = getBaseKey();
+    const keys = await generateEncryptionKeys();
+    const content = await encryptionKeysToBase64(keys);
+    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
+    const ciphertext = await encryptKeystoreContent(secretKey, content, userID, ENCRYPTION_KEYSTORE_TAG);
+    const encryptionKeystore = {
+      userID,
+      type: "encryption" /* ENCRYPTION */,
+      encryptedKeys: ciphertext
+    };
+    const recoveryCodes = generateRecoveryCodes();
+    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
+    const encKeys = await encryptKeystoreContent(recoveryKey, content, userID, RECOVERY_KEYSTORE_TAG);
+    const recoveryKeystore = {
+      userID,
+      type: "recovery" /* RECOVERY */,
+      encryptedKeys: encKeys
+    };
+    return { encryptionKeystore, recoveryKeystore, recoveryCodes };
+  } catch (error) {
+    throw new Error("Failed to create encryption and recovery keystores", { cause: error });
+  }
+}
+async function openEncryptionKeystore(encryptedKeystore) {
+  try {
+    if (encryptedKeystore.type != "encryption" /* ENCRYPTION */) {
+      throw new Error("Input is invalid");
+    }
+    const baseKey = getBaseKey();
+    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
+    const json = await decryptKeystoreContent(
+      secretKey,
+      encryptedKeystore.encryptedKeys,
+      encryptedKeystore.userID,
+      ENCRYPTION_KEYSTORE_TAG
+    );
+    const keys = await base64ToEncryptionKeys(json);
+    return keys;
+  } catch (error) {
+    throw new Error("Failed to open encryption keystore", { cause: error });
+  }
+}
+async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
+  try {
+    if (encryptedKeystore.type != "recovery" /* RECOVERY */) {
+      throw new Error("Input is invalid");
+    }
+    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
+    const json = await decryptKeystoreContent(
+      recoveryKey,
+      encryptedKeystore.encryptedKeys,
+      encryptedKeystore.userID,
+      RECOVERY_KEYSTORE_TAG
+    );
+    const keys = await base64ToEncryptionKeys(json);
+    return keys;
+  } catch (error) {
+    throw new Error("Failed to open recovery keystore", { cause: error });
+  }
+}
+
+// src/keystore-crypto/userIdenityKey.ts
+async function generateIdentityKeys() {
+  try {
+    const keyPair = await generateEccKeys();
+    const result = {
+      userPrivateKey: keyPair.privateKey,
+      userPublicKey: keyPair.publicKey
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to generate idenity keys", { cause: error });
+  }
+}
+async function createIdentityKeystore() {
+  try {
+    const type = "identity" /* IDENTITY */;
+    const userID = getUserID();
+    const baseKey = getBaseKey();
+    const keys = await generateIdentityKeys();
+    const content = await identityKeysToBase64(keys);
+    const secretKey = await deriveIdentityKeystoreKey(baseKey);
+    const encryptedKeys = await encryptKeystoreContent(secretKey, content, userID, IDENTITY_KEYSTORE_TAG);
+    const result = {
+      userID,
+      type,
+      encryptedKeys
+    };
+    return result;
+  } catch (error) {
+    throw new Error("Failed to create identity keystore", { cause: error });
+  }
+}
+async function openIdentityKeystore(encryptedKeystore) {
+  try {
+    if (encryptedKeystore.type != "identity" /* IDENTITY */) {
+      throw new Error("Input is invalid");
+    }
+    const baseKey = getBaseKey();
+    const secretKey = await deriveIdentityKeystoreKey(baseKey);
+    const json = await decryptKeystoreContent(
+      secretKey,
+      encryptedKeystore.encryptedKeys,
+      encryptedKeystore.userID,
+      IDENTITY_KEYSTORE_TAG
+    );
+    const keys = await base64ToIdentityKeys(json);
+    return keys;
+  } catch (error) {
+    throw new Error("Failed to open identity keystore", { cause: error });
+  }
+}
+
+exports.createEncryptionAndRecoveryKeystores = createEncryptionAndRecoveryKeystores;
+exports.createIdentityKeystore = createIdentityKeystore;
+exports.generateEncryptionKeys = generateEncryptionKeys;
+exports.generateIdentityKeys = generateIdentityKeys;
+exports.generateRecoveryCodes = generateRecoveryCodes;
+exports.openEncryptionKeystore = openEncryptionKeystore;
+exports.openIdentityKeystore = openIdentityKeystore;
+exports.openRecoveryKeystore = openRecoveryKeystore;
+//# sourceMappingURL=keystore-crypto.js.map
+//# sourceMappingURL=keystore-crypto.js.map