@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/es/utils/keystore.mjs

@@ -1,7 +1,3 @@
-import _buffer from "buffer";
-const {
-  Buffer: _Buffer
-} = _buffer;
 import nacl from 'tweetnacl';
 import { v4 as uuid } from '@aeternity/uuid';
 import _aeternityArgon2BrowserDistArgon2BundledMinJs from '@aeternity/argon2-browser/dist/argon2-bundled.min.js';
@@ -9,232 +5,141 @@ const {
   ArgonType,
   hash
 } = _aeternityArgon2BrowserDistArgon2BundledMinJs;
-import { encode } from "../tx/builder/helpers.mjs";
-import { str2buf } from "./bytes.mjs";
-import { ArgumentError, InvalidKeyError, UnsupportedAlgorithmError, InvalidPasswordError } from "./errors.mjs";
-/**
- * KeyStore module
- * @module @aeternity/aepp-sdk/es/utils/keystore
- * @example import { Keystore } from '@aeternity/aepp-sdk'
- * @example const { Keystore } = require('@aeternity/aepp-sdk')
- */
-
-const DEFAULTS = {
-  crypto: {
-    secret_type: 'ed25519',
-    symmetric_alg: 'xsalsa20-poly1305',
-    kdf: 'argon2id',
-    kdf_params: {
-      memlimit_kib: 65536,
-      opslimit: 3,
-      parallelism: 1
-    }
+import { getAddressFromPriv } from "./crypto.mjs";
+import { bytesToHex, hexToBytes } from "./bytes.mjs";
+import { InvalidPasswordError } from "./errors.mjs";
+const DERIVED_KEY_FUNCTIONS = {
+  async argon2id(pass, salt, params) {
+    const {
+      memlimit_kib: mem,
+      opslimit: time
+    } = params;
+    return (await hash({
+      hashLen: 32,
+      pass,
+      salt,
+      time,
+      mem,
+      type: ArgonType.Argon2id
+    })).hash;
   }
-}; // DERIVED KEY PART
 
-const DERIVED_KEY_FUNCTIONS = {
-  argon2id: deriveKeyUsingArgon2id
 };
-export async function deriveKeyUsingArgon2id(pass, salt, options) {
-  const {
-    memlimit_kib: mem,
-    opslimit: time
-  } = options.kdf_params;
-  const result = (await hash({
-    hashLen: 32,
-    pass,
-    salt,
-    time,
-    mem,
-    type: ArgonType.Argon2id
-  })).hash;
-  return _Buffer.from(result);
-} // CRYPTO PART
-
 const CRYPTO_FUNCTIONS = {
   'xsalsa20-poly1305': {
-    encrypt: encryptXsalsa20Poly1305,
-    decrypt: decryptXsalsa20Poly1305
-  }
-};
+    encrypt: nacl.secretbox,
 
-function encryptXsalsa20Poly1305(_ref) {
-  let {
-    plaintext,
-    key,
-    nonce
-  } = _ref;
-  return nacl.secretbox(plaintext, nonce, key);
-}
+    decrypt() {
+      const res = nacl.secretbox.open(...arguments);
+      if (res == null) throw new InvalidPasswordError();
+      return res;
+    }
 
-function decryptXsalsa20Poly1305(_ref2) {
-  let {
-    ciphertext,
-    key,
-    nonce
-  } = _ref2;
-  const res = nacl.secretbox.open(ciphertext, nonce, key);
-  if (!res) throw new InvalidPasswordError('Invalid password or nonce');
-  return res;
-}
+  }
+};
+const CRYPTO_DEFAULTS = {
+  secret_type: 'ed25519',
+  symmetric_alg: 'xsalsa20-poly1305',
+  kdf: 'argon2id',
+  kdf_params: {
+    memlimit_kib: 65536,
+    opslimit: 3,
+    parallelism: 1
+  }
+};
 /**
  * Symmetric private key encryption using secret (derived) key.
- * @param {Buffer|string} plaintext Data to be encrypted.
- * @param {Buffer|string} key Secret key.
- * @param {Buffer|string} nonce Randomly generated nonce.
- * @param {string=} algo Encryption algorithm (default: DEFAULTS.crypto.symmetric_alg).
- * @return {Buffer} Encrypted data.
+ * @param plaintext - Data to be encrypted.
+ * @param key - Secret key.
+ * @param nonce - Randomly generated nonce.
+ * @param algo - Encryption algorithm.
+ * @returns Encrypted data.
  */
 
-
 function encrypt(plaintext, key, nonce) {
-  let algo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULTS.crypto.symmetric_alg;
-  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo);
-  return CRYPTO_FUNCTIONS[algo].encrypt({
-    plaintext,
-    nonce,
-    key
-  });
+  let algo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : CRYPTO_DEFAULTS.symmetric_alg;
+  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key);
 }
 /**
  * Symmetric private key decryption using secret (derived) key.
- * @param {Buffer|Uint8Array} ciphertext Data to be decrypted.
- * @param {Buffer|Uint8Array} key Secret key.
- * @param {Buffer|Uint8Array} nonce Nonce from key-object.
- * @param {string=} algo Encryption algorithm.
- * @return {Buffer} Decrypted data.
+ * @param ciphertext - Data to be decrypted.
+ * @param key - Secret key.
+ * @param nonce - Nonce from key-object.
+ * @param algo - Encryption algorithm.
+ * @returns Decrypted data.
  */
 
 
-function decrypt(ciphertext, key, nonce, algo) {
-  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo);
-  return CRYPTO_FUNCTIONS[algo].decrypt({
-    ciphertext,
-    nonce,
-    key
-  });
+function decrypt(ciphertext, key, nonce) {
+  let algo = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : CRYPTO_DEFAULTS.symmetric_alg;
+  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key);
 }
 /**
  * Derive secret key from password with key derivation function.
- * @param {string} password User-supplied password.
- * @param {Buffer|Uint8Array} nonce Randomly generated nonce.
- * @param {Object=} options Encryption parameters.
- * @param {string=} options.kdf Key derivation function (default: DEFAULTS.crypto.kdf).
- * @param {Object=} options.kdf_params KDF parameters (default: DEFAULTS.crypto.kdf_params).
- * @return {Buffer} Secret key derived from password.
+ * @param password - User-supplied password.
+ * @param nonce - Randomly generated nonce.
+ * @param kdf - Key derivation function.
+ * @param kdfParams - KDF parameters.
+ * @returns Secret key derived from password.
  */
 
 
-async function deriveKey(password, nonce) {
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-    kdf_params: DEFAULTS.crypto.kdf_params,
-    kdf: DEFAULTS.crypto.kdf
-  };
-  if (!nonce) throw new ArgumentError('nonce', 'provided', nonce);
-  if (password == null) throw new ArgumentError('password', 'provided', password);
+async function deriveKey(password, nonce, kdf, kdfParams) {
+  return await DERIVED_KEY_FUNCTIONS[kdf](password, nonce, kdfParams);
+}
+/**
+ * Recover plaintext private key from secret-storage key object.
+ * @param password - Keystore object password.
+ * @param keystore - Keystore object.
+ * @returns Plaintext private key.
+ */
 
-  if (!Object.prototype.hasOwnProperty.call(DERIVED_KEY_FUNCTIONS, options.kdf)) {
-    throw new UnsupportedAlgorithmError(options.kdf);
-  }
 
-  return DERIVED_KEY_FUNCTIONS[options.kdf](password, nonce, options);
+export async function recover(password, _ref) {
+  let {
+    crypto
+  } = _ref;
+  const salt = hexToBytes(crypto.kdf_params.salt);
+  return bytesToHex(decrypt(hexToBytes(crypto.ciphertext), await deriveKey(password, salt, crypto.kdf, crypto.kdf_params), hexToBytes(crypto.cipher_params.nonce), crypto.symmetric_alg));
 }
 /**
- * Assemble key data object in secret-storage format.
- * @param {Buffer} name Key name.
- * @param {Buffer} derivedKey Password-derived secret key.
- * @param {Buffer} privateKey Private key.
- * @param {Buffer} nonce Randomly generated 24byte nonce.
- * @param {Buffer} salt Randomly generated 16byte salt.
- * @param {Object=} options Encryption parameters.
- * @param {string=} options.kdf Key derivation function (default: argon2id).
- * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
- * @param {Object=} options.kdf_params KDF parameters (default: constants.<kdf>).
- * @return {Object}
+ * Export private key to keystore secret-storage format.
+ * @param name - Key name.
+ * @param password - User-supplied password.
+ * @param privateKey - Private key as hex-string or a Buffer.
+ * @param nonce - Randomly generated 24byte nonce.
+ * @param salt - Randomly generated 16byte salt.
+ * @param options - Encryption parameters.
+ * @param options.kdf - Key derivation function.
+ * @param options.kdf_params - KDF parameters.
  */
 
-
-function marshal(name, derivedKey, privateKey, nonce, salt) {
-  let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
-  const opt = Object.assign({}, DEFAULTS.crypto, options);
-  return Object.assign({
+export async function dump(name, password, privateKey) {
+  let nonce = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : nacl.randomBytes(24);
+  let salt = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : nacl.randomBytes(16);
+  let options = arguments.length > 5 ? arguments[5] : undefined;
+  const opt = { ...CRYPTO_DEFAULTS,
+    ...options
+  };
+  const derivedKey = await deriveKey(password, salt, opt.kdf, opt.kdf_params);
+  const payload = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;
+  return {
     name,
     version: 1,
-    public_key: getAddressFromPriv(privateKey),
-    id: uuid()
-  }, {
-    crypto: Object.assign({
+    public_key: getAddressFromPriv(payload),
+    id: uuid(),
+    crypto: {
       secret_type: opt.secret_type,
       symmetric_alg: opt.symmetric_alg,
-      ciphertext: _Buffer.from(encrypt(_Buffer.from(privateKey), derivedKey, nonce, opt.symmetric_alg)).toString('hex'),
+      ciphertext: bytesToHex(encrypt(payload, derivedKey, nonce, opt.symmetric_alg)),
       cipher_params: {
-        nonce: _Buffer.from(nonce).toString('hex')
-      }
-    }, {
+        nonce: bytesToHex(nonce)
+      },
       kdf: opt.kdf,
       kdf_params: { ...opt.kdf_params,
-        salt: _Buffer.from(salt).toString('hex')
+        salt: bytesToHex(salt)
       }
-    })
-  });
-}
-
-export function getAddressFromPriv(secret) {
-  const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret));
-
-  const publicBuffer = _Buffer.from(keys.publicKey);
-
-  return encode(publicBuffer, 'ak');
-}
-/**
- * Recover plaintext private key from secret-storage key object.
- * @param {String} password Keystore object password.
- * @param {Object} keyObject Keystore object.
- * @return {Buffer} Plaintext private key.
- */
-
-export async function recover(password, keyObject) {
-  validateKeyObj(keyObject);
-  const nonce = Uint8Array.from(str2buf(keyObject.crypto.cipher_params.nonce));
-  const salt = Uint8Array.from(str2buf(keyObject.crypto.kdf_params.salt));
-  const kdfParams = keyObject.crypto.kdf_params;
-  const kdf = keyObject.crypto.kdf;
-  const key = await decrypt(Uint8Array.from(str2buf(keyObject.crypto.ciphertext)), await deriveKey(password, salt, {
-    kdf,
-    kdf_params: kdfParams
-  }), nonce, keyObject.crypto.symmetric_alg);
-  if (!key) throw new InvalidPasswordError('Invalid password');
-  if (_Buffer.from(key).length === 64) return _Buffer.from(key).toString('hex');
-  return _Buffer.from(key).toString('utf-8');
-}
-/**
- * Export private key to keystore secret-storage format.
- * @param {String} name Key name.
- * @param {String} password User-supplied password.
- * @param {String|Buffer} privateKey Private key as hex-string or a Buffer.
- * @param {Buffer} nonce Randomly generated 24byte nonce.
- * @param {Buffer} salt Randomly generated 16byte salt.
- * @param {Object=} options Encryption parameters.
- * @param {String=} options.kdf Key derivation function (default: pbkdf2).
- * @param {String=} options.cipher Symmetric cipher (default: constants.cipher).
- * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
- * @return {Object}
- */
-
-export async function dump(name, password, privateKey) {
-  let nonce = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : nacl.randomBytes(24);
-  let salt = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : nacl.randomBytes(16);
-  let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
-  const opt = Object.assign({}, DEFAULTS.crypto, options);
-  return marshal(name, await deriveKey(password, salt, opt), typeof privateKey === 'string' ? _Buffer.from(privateKey, 'hex') : privateKey, nonce, salt, opt);
-}
-export function validateKeyObj(obj) {
-  const root = ['crypto', 'id', 'version', 'public_key'];
-  const cryptoKeys = ['cipher_params', 'ciphertext', 'symmetric_alg', 'kdf', 'kdf_params'];
-  const missingRootKeys = root.filter(key => !Object.prototype.hasOwnProperty.call(obj, key));
-  if (missingRootKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingRootKeys}`);
-  const missingCryptoKeys = cryptoKeys.filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key));
-  if (missingCryptoKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingCryptoKeys}`);
-  return true;
+    }
+  };
 }
 //# sourceMappingURL=keystore.mjs.map

package/es/utils/keystore.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/keystore.js"],"names":["nacl","v4","uuid","encode","str2buf","ArgumentError","InvalidKeyError","UnsupportedAlgorithmError","InvalidPasswordError","DEFAULTS","crypto","secret_type","symmetric_alg","kdf","kdf_params","memlimit_kib","opslimit","parallelism","DERIVED_KEY_FUNCTIONS","argon2id","deriveKeyUsingArgon2id","pass","salt","options","mem","time","result","hash","hashLen","type","ArgonType","Argon2id","from","CRYPTO_FUNCTIONS","encrypt","encryptXsalsa20Poly1305","decrypt","decryptXsalsa20Poly1305","plaintext","key","nonce","secretbox","ciphertext","res","open","algo","deriveKey","password","Object","prototype","hasOwnProperty","call","marshal","name","derivedKey","privateKey","opt","assign","version","public_key","getAddressFromPriv","id","toString","cipher_params","secret","keys","sign","keyPair","fromSecretKey","publicBuffer","publicKey","recover","keyObject","validateKeyObj","Uint8Array","kdfParams","length","dump","randomBytes","obj","root","cryptoKeys","missingRootKeys","filter","missingCryptoKeys"],"mappings":"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","sourcesContent":["import nacl from 'tweetnacl'\nimport { v4 as uuid } from '@aeternity/uuid'\nimport { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js'\nimport { encode } from '../tx/builder/helpers'\nimport { str2buf } from './bytes'\nimport {\n  ArgumentError, InvalidKeyError, UnsupportedAlgorithmError, InvalidPasswordError\n} from './errors'\n\n/**\n * KeyStore module\n * @module @aeternity/aepp-sdk/es/utils/keystore\n * @example import { Keystore } from '@aeternity/aepp-sdk'\n * @example const { Keystore } = require('@aeternity/aepp-sdk')\n */\n\nconst DEFAULTS = {\n  crypto: {\n    secret_type: 'ed25519',\n    symmetric_alg: 'xsalsa20-poly1305',\n    kdf: 'argon2id',\n    kdf_params: {\n      memlimit_kib: 65536,\n      opslimit: 3,\n      parallelism: 1\n    }\n  }\n}\n\n// DERIVED KEY PART\nconst DERIVED_KEY_FUNCTIONS = {\n  argon2id: deriveKeyUsingArgon2id\n}\n\nexport async function deriveKeyUsingArgon2id (pass, salt, options) {\n  const { memlimit_kib: mem, opslimit: time } = options.kdf_params\n\n  const result = (await hash({\n    hashLen: 32,\n    pass,\n    salt,\n    time,\n    mem,\n    type: ArgonType.Argon2id\n  })).hash\n  return Buffer.from(result)\n}\n\n// CRYPTO PART\nconst CRYPTO_FUNCTIONS = {\n  'xsalsa20-poly1305': { encrypt: encryptXsalsa20Poly1305, decrypt: decryptXsalsa20Poly1305 }\n}\n\nfunction encryptXsalsa20Poly1305 ({ plaintext, key, nonce }) {\n  return nacl.secretbox(plaintext, nonce, key)\n}\n\nfunction decryptXsalsa20Poly1305 ({ ciphertext, key, nonce }) {\n  const res = nacl.secretbox.open(ciphertext, nonce, key)\n  if (!res) throw new InvalidPasswordError('Invalid password or nonce')\n  return res\n}\n\n/**\n * Symmetric private key encryption using secret (derived) key.\n * @param {Buffer|string} plaintext Data to be encrypted.\n * @param {Buffer|string} key Secret key.\n * @param {Buffer|string} nonce Randomly generated nonce.\n * @param {string=} algo Encryption algorithm (default: DEFAULTS.crypto.symmetric_alg).\n * @return {Buffer} Encrypted data.\n */\nfunction encrypt (plaintext, key, nonce, algo = DEFAULTS.crypto.symmetric_alg) {\n  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)\n  return CRYPTO_FUNCTIONS[algo].encrypt({ plaintext, nonce, key })\n}\n\n/**\n * Symmetric private key decryption using secret (derived) key.\n * @param {Buffer|Uint8Array} ciphertext Data to be decrypted.\n * @param {Buffer|Uint8Array} key Secret key.\n * @param {Buffer|Uint8Array} nonce Nonce from key-object.\n * @param {string=} algo Encryption algorithm.\n * @return {Buffer} Decrypted data.\n */\nfunction decrypt (ciphertext, key, nonce, algo) {\n  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)\n  return CRYPTO_FUNCTIONS[algo].decrypt({ ciphertext, nonce, key })\n}\n\n/**\n * Derive secret key from password with key derivation function.\n * @param {string} password User-supplied password.\n * @param {Buffer|Uint8Array} nonce Randomly generated nonce.\n * @param {Object=} options Encryption parameters.\n * @param {string=} options.kdf Key derivation function (default: DEFAULTS.crypto.kdf).\n * @param {Object=} options.kdf_params KDF parameters (default: DEFAULTS.crypto.kdf_params).\n * @return {Buffer} Secret key derived from password.\n */\nasync function deriveKey (password, nonce, options = {\n  kdf_params: DEFAULTS.crypto.kdf_params,\n  kdf: DEFAULTS.crypto.kdf\n}) {\n  if (!nonce) throw new ArgumentError('nonce', 'provided', nonce)\n  if (password == null) throw new ArgumentError('password', 'provided', password)\n\n  if (!Object.prototype.hasOwnProperty.call(DERIVED_KEY_FUNCTIONS, options.kdf)) {\n    throw new UnsupportedAlgorithmError(options.kdf)\n  }\n\n  return DERIVED_KEY_FUNCTIONS[options.kdf](password, nonce, options)\n}\n\n/**\n * Assemble key data object in secret-storage format.\n * @param {Buffer} name Key name.\n * @param {Buffer} derivedKey Password-derived secret key.\n * @param {Buffer} privateKey Private key.\n * @param {Buffer} nonce Randomly generated 24byte nonce.\n * @param {Buffer} salt Randomly generated 16byte salt.\n * @param {Object=} options Encryption parameters.\n * @param {string=} options.kdf Key derivation function (default: argon2id).\n * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).\n * @param {Object=} options.kdf_params KDF parameters (default: constants.<kdf>).\n * @return {Object}\n */\nfunction marshal (name, derivedKey, privateKey, nonce, salt, options = {}) {\n  const opt = Object.assign({}, DEFAULTS.crypto, options)\n  return Object.assign(\n    { name, version: 1, public_key: getAddressFromPriv(privateKey), id: uuid() },\n    {\n      crypto: Object.assign(\n        {\n          secret_type: opt.secret_type,\n          symmetric_alg: opt.symmetric_alg,\n          ciphertext: Buffer.from(encrypt(Buffer.from(privateKey), derivedKey, nonce, opt.symmetric_alg)).toString('hex'),\n          cipher_params: { nonce: Buffer.from(nonce).toString('hex') }\n        },\n        { kdf: opt.kdf, kdf_params: { ...opt.kdf_params, salt: Buffer.from(salt).toString('hex') } }\n      )\n    }\n  )\n}\n\nexport function getAddressFromPriv (secret) {\n  const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret))\n  const publicBuffer = Buffer.from(keys.publicKey)\n  return encode(publicBuffer, 'ak')\n}\n\n/**\n * Recover plaintext private key from secret-storage key object.\n * @param {String} password Keystore object password.\n * @param {Object} keyObject Keystore object.\n * @return {Buffer} Plaintext private key.\n */\nexport async function recover (password, keyObject) {\n  validateKeyObj(keyObject)\n  const nonce = Uint8Array.from(str2buf(keyObject.crypto.cipher_params.nonce))\n  const salt = Uint8Array.from(str2buf(keyObject.crypto.kdf_params.salt))\n  const kdfParams = keyObject.crypto.kdf_params\n  const kdf = keyObject.crypto.kdf\n\n  const key = await decrypt(\n    Uint8Array.from(str2buf(keyObject.crypto.ciphertext)),\n    await deriveKey(password, salt, { kdf, kdf_params: kdfParams }),\n    nonce,\n    keyObject.crypto.symmetric_alg\n  )\n  if (!key) throw new InvalidPasswordError('Invalid password')\n\n  if (Buffer.from(key).length === 64) return Buffer.from(key).toString('hex')\n  return Buffer.from(key).toString('utf-8')\n}\n\n/**\n * Export private key to keystore secret-storage format.\n * @param {String} name Key name.\n * @param {String} password User-supplied password.\n * @param {String|Buffer} privateKey Private key as hex-string or a Buffer.\n * @param {Buffer} nonce Randomly generated 24byte nonce.\n * @param {Buffer} salt Randomly generated 16byte salt.\n * @param {Object=} options Encryption parameters.\n * @param {String=} options.kdf Key derivation function (default: pbkdf2).\n * @param {String=} options.cipher Symmetric cipher (default: constants.cipher).\n * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).\n * @return {Object}\n */\nexport async function dump (\n  name,\n  password,\n  privateKey,\n  nonce = nacl.randomBytes(24),\n  salt = nacl.randomBytes(16),\n  options = {}\n) {\n  const opt = Object.assign({}, DEFAULTS.crypto, options)\n  return marshal(\n    name,\n    await deriveKey(password, salt, opt),\n    typeof privateKey === 'string' ? Buffer.from(privateKey, 'hex') : privateKey,\n    nonce,\n    salt,\n    opt\n  )\n}\n\nexport function validateKeyObj (obj) {\n  const root = ['crypto', 'id', 'version', 'public_key']\n  const cryptoKeys = ['cipher_params', 'ciphertext', 'symmetric_alg', 'kdf', 'kdf_params']\n\n  const missingRootKeys = root.filter(key => !Object.prototype.hasOwnProperty.call(obj, key))\n  if (missingRootKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingRootKeys}`)\n\n  const missingCryptoKeys = cryptoKeys\n    .filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))\n  if (missingCryptoKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingCryptoKeys}`)\n\n  return true\n}\n"],"file":"keystore.mjs"}
+{"version":3,"file":"keystore.mjs","names":["nacl","v4","uuid","getAddressFromPriv","bytesToHex","hexToBytes","InvalidPasswordError","DERIVED_KEY_FUNCTIONS","argon2id","pass","salt","params","memlimit_kib","mem","opslimit","time","hash","hashLen","type","ArgonType","Argon2id","CRYPTO_FUNCTIONS","encrypt","secretbox","decrypt","res","open","CRYPTO_DEFAULTS","secret_type","symmetric_alg","kdf","kdf_params","parallelism","plaintext","key","nonce","algo","ciphertext","deriveKey","password","kdfParams","recover","crypto","cipher_params","dump","name","privateKey","randomBytes","options","opt","derivedKey","payload","version","public_key","id"],"sources":["../../src/utils/keystore.ts"],"sourcesContent":["import nacl from 'tweetnacl'\nimport { v4 as uuid } from '@aeternity/uuid'\nimport { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js'\nimport { getAddressFromPriv } from './crypto'\nimport { bytesToHex, hexToBytes } from './bytes'\nimport { InvalidPasswordError } from './errors'\n\nconst DERIVED_KEY_FUNCTIONS = {\n  async argon2id (\n    pass: string | Uint8Array,\n    salt: string | Uint8Array,\n    params: Partial<Keystore['crypto']['kdf_params']>\n  ): Promise<Uint8Array> {\n    const { memlimit_kib: mem, opslimit: time } = params\n\n    return (await hash({\n      hashLen: 32,\n      pass,\n      salt,\n      time,\n      mem,\n      type: ArgonType.Argon2id\n    })).hash\n  }\n}\n\nconst CRYPTO_FUNCTIONS = {\n  'xsalsa20-poly1305': {\n    encrypt: nacl.secretbox,\n    decrypt (...args: Parameters<typeof nacl.secretbox.open>): Uint8Array {\n      const res = nacl.secretbox.open(...args)\n      if (res == null) throw new InvalidPasswordError()\n      return res\n    }\n  }\n}\n\nexport interface Keystore {\n  name: string\n  version: 1\n  public_key: string\n  id: string\n  crypto: {\n    secret_type: 'ed25519'\n    symmetric_alg: keyof typeof CRYPTO_FUNCTIONS\n    ciphertext: string\n    cipher_params: {\n      nonce: string\n    }\n    kdf: keyof typeof DERIVED_KEY_FUNCTIONS\n    kdf_params: {\n      memlimit_kib: number\n      opslimit: number\n      parallelism: number\n      salt: string\n    }\n  }\n}\n\nconst CRYPTO_DEFAULTS = {\n  secret_type: 'ed25519',\n  symmetric_alg: 'xsalsa20-poly1305',\n  kdf: 'argon2id',\n  kdf_params: {\n    memlimit_kib: 65536,\n    opslimit: 3,\n    parallelism: 1\n  }\n} as const\n\n/**\n * Symmetric private key encryption using secret (derived) key.\n * @param plaintext - Data to be encrypted.\n * @param key - Secret key.\n * @param nonce - Randomly generated nonce.\n * @param algo - Encryption algorithm.\n * @returns Encrypted data.\n */\nfunction encrypt (\n  plaintext: Uint8Array,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg\n): Uint8Array {\n  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key)\n}\n\n/**\n * Symmetric private key decryption using secret (derived) key.\n * @param ciphertext - Data to be decrypted.\n * @param key - Secret key.\n * @param nonce - Nonce from key-object.\n * @param algo - Encryption algorithm.\n * @returns Decrypted data.\n */\nfunction decrypt (\n  ciphertext: Uint8Array,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg\n): Uint8Array {\n  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key)\n}\n\n/**\n * Derive secret key from password with key derivation function.\n * @param password - User-supplied password.\n * @param nonce - Randomly generated nonce.\n * @param kdf - Key derivation function.\n * @param kdfParams - KDF parameters.\n * @returns Secret key derived from password.\n */\nasync function deriveKey (\n  password: string | Uint8Array,\n  nonce: string | Uint8Array,\n  kdf: Keystore['crypto']['kdf'],\n  kdfParams: Omit<Keystore['crypto']['kdf_params'], 'salt'>\n): Promise<Uint8Array> {\n  return await DERIVED_KEY_FUNCTIONS[kdf](password, nonce, kdfParams)\n}\n\n/**\n * Recover plaintext private key from secret-storage key object.\n * @param password - Keystore object password.\n * @param keystore - Keystore object.\n * @returns Plaintext private key.\n */\nexport async function recover (\n  password: string | Uint8Array, { crypto }: Keystore\n): Promise<string> {\n  const salt = hexToBytes(crypto.kdf_params.salt)\n  return bytesToHex(decrypt(\n    hexToBytes(crypto.ciphertext),\n    await deriveKey(password, salt, crypto.kdf, crypto.kdf_params),\n    hexToBytes(crypto.cipher_params.nonce),\n    crypto.symmetric_alg\n  ))\n}\n\n/**\n * Export private key to keystore secret-storage format.\n * @param name - Key name.\n * @param password - User-supplied password.\n * @param privateKey - Private key as hex-string or a Buffer.\n * @param nonce - Randomly generated 24byte nonce.\n * @param salt - Randomly generated 16byte salt.\n * @param options - Encryption parameters.\n * @param options.kdf - Key derivation function.\n * @param options.kdf_params - KDF parameters.\n */\nexport async function dump (\n  name: string,\n  password: string | Uint8Array,\n  privateKey: string | Uint8Array,\n  nonce: Uint8Array = nacl.randomBytes(24),\n  salt: Uint8Array = nacl.randomBytes(16),\n  options?: Partial<Keystore['crypto']>\n): Promise<Keystore> {\n  const opt = { ...CRYPTO_DEFAULTS, ...options }\n  const derivedKey = await deriveKey(password, salt, opt.kdf, opt.kdf_params)\n  const payload = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey\n  return {\n    name,\n    version: 1,\n    public_key: getAddressFromPriv(payload),\n    id: uuid(),\n    crypto: {\n      secret_type: opt.secret_type,\n      symmetric_alg: opt.symmetric_alg,\n      ciphertext: bytesToHex(encrypt(payload, derivedKey, nonce, opt.symmetric_alg)),\n      cipher_params: { nonce: bytesToHex(nonce) },\n      kdf: opt.kdf,\n      kdf_params: {\n        ...opt.kdf_params,\n        salt: bytesToHex(salt)\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/es/{mptree.d.ts → utils/mptree.d.ts}

@@ -6,24 +6,21 @@ export default class MPTree {
     private static nodeHash;
     /**
      * Deserialize Merkle Patricia Tree
-     * @rtype (binary: Array) => MPTree
-     * @param {Array} binary - Binary
-     * @return {MPTree} Merkle Patricia Tree
+     * @param binary - Binary
+     * @returns Merkle Patricia Tree
      */
     constructor(binary: MPTreeBinary);
     isEqual(tree: MPTree): boolean;
     private static parseNode;
     /**
      * Serialize Merkle Patricia Tree
-     * @rtype () => Array
-     * @return {Array} Binary
+     * @returns Binary
      */
     serialize(): MPTreeBinary;
     /**
      * Retrieve value from Merkle Patricia Tree
-     * @rtype (key: String) => Buffer
-     * @param {String} key - The key of the element to retrieve
-     * @return {Buffer} Value associated to the specified key
+     * @param key - The key of the element to retrieve
+     * @returns Value associated to the specified key
      */
     get(key: string): Buffer | undefined;
 }

package/es/utils/mptree.mjs

@@ -1,4 +1,5 @@
 import _buffer from "buffer";
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
 const {
   Buffer: _Buffer
 } = _buffer;
@@ -23,7 +24,7 @@ import _rlp from 'rlp';
 const {
   encode: rlpEncode
 } = _rlp;
-import { hash } from "./crypto-ts.mjs";
+import { hash } from "./crypto.mjs";
 import { MerkleTreeHashMismatchError, MissingNodeInTreeError, UnknownPathNibbleError, UnknownNodeLengthError } from "./errors.mjs";
 var NodeType;
 
@@ -39,9 +40,8 @@ export default class MPTree {
   }
   /**
    * Deserialize Merkle Patricia Tree
-   * @rtype (binary: Array) => MPTree
-   * @param {Array} binary - Binary
-   * @return {MPTree} Merkle Patricia Tree
+   * @param binary - Binary
+   * @returns Merkle Patricia Tree
    */
 
 
@@ -90,15 +90,16 @@ export default class MPTree {
 
       case 2:
         {
-          const path = node[0].toString('hex');
-          const nibble = parseInt(path[0], 16);
+          var _context;
+
+          const nibble = node[0][0] >> 4;
           if (nibble > 3) throw new UnknownPathNibbleError(nibble);
           const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf;
-          const slice = [0, 2].includes(nibble) ? 2 : 1;
+          const slice = _includesInstanceProperty(_context = [0, 2]).call(_context, nibble) ? 2 : 1;
           return {
             type,
             payload: [node[1]],
-            path: path.slice(slice)
+            path: node[0].toString('hex').slice(slice)
           };
         }
 
@@ -108,8 +109,7 @@ export default class MPTree {
   }
   /**
    * Serialize Merkle Patricia Tree
-   * @rtype () => Array
-   * @return {Array} Binary
+   * @returns Binary
    */
 
 
@@ -121,9 +121,8 @@ export default class MPTree {
   }
   /**
    * Retrieve value from Merkle Patricia Tree
-   * @rtype (key: String) => Buffer
-   * @param {String} key - The key of the element to retrieve
-   * @return {Buffer} Value associated to the specified key
+   * @param key - The key of the element to retrieve
+   * @returns Value associated to the specified key
    */
 
 
@@ -140,7 +139,7 @@ export default class MPTree {
       switch (type) {
         case NodeType.Branch:
           if (key.length === 0) return payload[16];
-          searchFrom = payload[parseInt(key[0], 16)].toString('hex');
+          searchFrom = payload[+`0x${key[0]}`].toString('hex');
           key = key.substr(1);
           break;
 

package/es/utils/mptree.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/mptree.ts"],"names":["hash","MerkleTreeHashMismatchError","MissingNodeInTreeError","UnknownPathNibbleError","UnknownNodeLengthError","NodeType","MPTree","nodeHash","node","from","rlpEncode","toString","constructor","binary","rootHash","nodes","Object","fromEntries","map","undefined","entries","forEach","key","type","payload","parseNode","Branch","slice","filter","n","length","Extension","isEqual","tree","path","nibble","parseInt","Leaf","includes","serialize","mptHash","value","get","searchFrom","substr"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,iBAAoC,KAApC;;;;SAESA,I;SAEPC,2B,EACAC,sB,EACAC,sB,EACAC,sB;IAGGC,Q;;WAAAA,Q;AAAAA,EAAAA,Q,CAAAA,Q;AAAAA,EAAAA,Q,CAAAA,Q;AAAAA,EAAAA,Q,CAAAA,Q;GAAAA,Q,KAAAA,Q;;AAQL,eAAe,MAAMC,MAAN,CAAa;AAIH,SAARC,QAAQ,CAAEC,IAAF,EAAuB;AAC5C,WAAO,QAAOC,IAAP,CAAYT,IAAI,CAACU,SAAS,CAACF,IAAD,CAAV,CAAhB,EAAmCG,QAAnC,CAA4C,KAA5C,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACEC,EAAAA,WAAW,CAAEC,MAAF,EAAwB;AACjC,SAAKC,QAAL,GAAgBD,MAAM,CAAC,CAAD,CAAN,CAAUF,QAAV,CAAmB,KAAnB,CAAhB;AACA,SAAKI,KAAL,GAAaC,MAAM,CAACC,WAAP,CACXJ,MAAM,CAAC,CAAD,CAAN,CAAUK,GAAV,CAAeV,IAAD,IAAU,CAACA,IAAI,CAAC,CAAD,CAAJ,CAAQG,QAAR,CAAiB,KAAjB,CAAD,EAA0BH,IAAI,CAAC,CAAD,CAA9B,CAAxB,CADW,CAAb;AAIA,QAAI,KAAKO,KAAL,CAAW,KAAKD,QAAhB,MAA8BK,SAAlC,EAA6C,MAAM,IAAIjB,sBAAJ,CAA2B,iCAA3B,CAAN;AAC7Cc,IAAAA,MAAM,CAACI,OAAP,CAAe,KAAKL,KAApB,EAA2BM,OAA3B,CAAmC,QAAiB;AAAA,UAAhB,CAACC,GAAD,EAAMd,IAAN,CAAgB;AAClD,UAAIF,MAAM,CAACC,QAAP,CAAgBC,IAAhB,MAA0Bc,GAA9B,EAAmC,MAAM,IAAIrB,2BAAJ,EAAN;AACnC,YAAM;AAAEsB,QAAAA,IAAF;AAAQC,QAAAA;AAAR,UAAoBlB,MAAM,CAACmB,SAAP,CAAiBjB,IAAjB,CAA1B;;AACA,cAAQe,IAAR;AACE,aAAKlB,QAAQ,CAACqB,MAAd;AACEF,UAAAA,OAAO,CACJG,KADH,CACS,CADT,EACY,EADZ,EAEGC,MAFH,CAEUC,CAAC,IAAIA,CAAC,CAACC,MAFjB,EAGGT,OAHH,CAGYQ,CAAD,IAAO;AACd,gBAAI,KAAKd,KAAL,CAAWc,CAAC,CAAClB,QAAF,CAAW,KAAX,CAAX,MAAkCQ,SAAtC,EAAiD;AAC/C,oBAAM,IAAIjB,sBAAJ,CAA2B,2CAA3B,CAAN;AACD;AACF,WAPH;AAQA;;AACF,aAAKG,QAAQ,CAAC0B,SAAd;AACE,cAAI,KAAKhB,KAAL,CAAWS,OAAO,CAAC,CAAD,CAAP,CAAWb,QAAX,CAAoB,KAApB,CAAX,MAA2CQ,SAA/C,EAA0D;AACxD,kBAAM,IAAIjB,sBAAJ,CAA2B,8CAA3B,CAAN;AACD;;AAdL;AAgBD,KAnBD;AAoBD;;AAED8B,EAAAA,OAAO,CAAEC,IAAF,EAAyB;AAC9B,WAAO,KAAKnB,QAAL,KAAkBmB,IAAI,CAACnB,QAA9B;AACD;;AAEuB,SAATW,SAAS,CAAEjB,IAAF,EAA8E;AACpG,YAAQA,IAAI,CAACsB,MAAb;AACE,WAAK,EAAL;AACE,eAAO;AAAEP,UAAAA,IAAI,EAAElB,QAAQ,CAACqB,MAAjB;AAAyBF,UAAAA,OAAO,EAAEhB,IAAlC;AAAwC0B,UAAAA,IAAI,EAAE;AAA9C,SAAP;;AACF,WAAK,CAAL;AAAQ;AACN,gBAAMA,IAAI,GAAG1B,IAAI,CAAC,CAAD,CAAJ,CAAQG,QAAR,CAAiB,KAAjB,CAAb;AACA,gBAAMwB,MAAM,GAAGC,QAAQ,CAACF,IAAI,CAAC,CAAD,CAAL,EAAU,EAAV,CAAvB;AACA,cAAIC,MAAM,GAAG,CAAb,EAAgB,MAAM,IAAIhC,sBAAJ,CAA2BgC,MAA3B,CAAN;AAChB,gBAAMZ,IAAI,GAAGY,MAAM,IAAI,CAAV,GAAc9B,QAAQ,CAAC0B,SAAvB,GAAmC1B,QAAQ,CAACgC,IAAzD;AACA,gBAAMV,KAAK,GAAG,CAAC,CAAD,EAAI,CAAJ,EAAOW,QAAP,CAAgBH,MAAhB,IAA0B,CAA1B,GAA8B,CAA5C;AACA,iBAAO;AAAEZ,YAAAA,IAAF;AAAQC,YAAAA,OAAO,EAAE,CAAChB,IAAI,CAAC,CAAD,CAAL,CAAjB;AAA4B0B,YAAAA,IAAI,EAAEA,IAAI,CAACP,KAAL,CAAWA,KAAX;AAAlC,WAAP;AACD;;AACD;AACE,cAAM,IAAIvB,sBAAJ,CAA2BI,IAAI,CAACsB,MAAhC,CAAN;AAZJ;AAcD;AAED;AACF;AACA;AACA;AACA;;;AACES,EAAAA,SAAS,GAAkB;AACzB,WAAO,CACL,QAAO9B,IAAP,CAAY,KAAKK,QAAjB,EAA2B,KAA3B,CADK,EAELE,MAAM,CAACI,OAAP,CAAe,KAAKL,KAApB,EAA2BG,GAA3B,CAA+B;AAAA,UAAC,CAACsB,OAAD,EAAUC,KAAV,CAAD;AAAA,aAAuB,CACpD,QAAOhC,IAAP,CAAY+B,OAAZ,EAAqB,KAArB,CADoD,EAEpDC,KAFoD,CAAvB;AAAA,KAA/B,CAFK,CAAP;AAOD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACEC,EAAAA,GAAG,CAAEpB,GAAF,EAAmC;AACpC,QAAIqB,UAAU,GAAG,KAAK7B,QAAtB;;AACA,WAAO,IAAP,EAAa;AACX,YAAM;AAAES,QAAAA,IAAF;AAAQC,QAAAA,OAAR;AAAiBU,QAAAA;AAAjB,UAA0B5B,MAAM,CAACmB,SAAP,CAAiB,KAAKV,KAAL,CAAW4B,UAAX,CAAjB,CAAhC;;AACA,cAAQpB,IAAR;AACE,aAAKlB,QAAQ,CAACqB,MAAd;AACE,cAAIJ,GAAG,CAACQ,MAAJ,KAAe,CAAnB,EAAsB,OAAON,OAAO,CAAC,EAAD,CAAd;AACtBmB,UAAAA,UAAU,GAAGnB,OAAO,CAACY,QAAQ,CAACd,GAAG,CAAC,CAAD,CAAJ,EAAS,EAAT,CAAT,CAAP,CAA8BX,QAA9B,CAAuC,KAAvC,CAAb;AACAW,UAAAA,GAAG,GAAGA,GAAG,CAACsB,MAAJ,CAAW,CAAX,CAAN;AACA;;AACF,aAAKvC,QAAQ,CAAC0B,SAAd;AACE,cAAIT,GAAG,CAACsB,MAAJ,CAAW,CAAX,EAAcV,IAAd,aAAcA,IAAd,uBAAcA,IAAI,CAAEJ,MAApB,MAAgCI,IAApC,EAA0C,OAAOf,SAAP;AAC1CwB,UAAAA,UAAU,GAAGnB,OAAO,CAAC,CAAD,CAAP,CAAWb,QAAX,CAAoB,KAApB,CAAb;AACAW,UAAAA,GAAG,GAAGA,GAAG,CAACsB,MAAJ,CAAWV,IAAI,CAACJ,MAAhB,CAAN;AACA;;AACF,aAAKzB,QAAQ,CAACgC,IAAd;AACE,cAAIH,IAAI,KAAKZ,GAAb,EAAkB,OAAOH,SAAP;AAClB,iBAAOK,OAAO,CAAC,CAAD,CAAd;AAbJ;AAeD;AACF;;AAzGyB","sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2021 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\n\nimport { encode as rlpEncode } from 'rlp'\nimport type { Input } from 'rlp'\nimport { hash } from './crypto-ts'\nimport {\n  MerkleTreeHashMismatchError,\n  MissingNodeInTreeError,\n  UnknownPathNibbleError,\n  UnknownNodeLengthError\n} from './errors'\n\nenum NodeType {\n  Branch,\n  Extension,\n  Leaf\n}\n\nexport type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>]\n\nexport default class MPTree {\n  private readonly rootHash: string\n  private readonly nodes: { [key: string]: Buffer[] }\n\n  private static nodeHash (node: Input): string {\n    return Buffer.from(hash(rlpEncode(node))).toString('hex')\n  }\n\n  /**\n   * Deserialize Merkle Patricia Tree\n   * @rtype (binary: Array) => MPTree\n   * @param {Array} binary - Binary\n   * @return {MPTree} Merkle Patricia Tree\n   */\n  constructor (binary: MPTreeBinary) {\n    this.rootHash = binary[0].toString('hex')\n    this.nodes = Object.fromEntries(\n      binary[1].map((node) => [node[0].toString('hex'), node[1]])\n    )\n\n    if (this.nodes[this.rootHash] === undefined) throw new MissingNodeInTreeError('Can\\'t find a node by root hash')\n    Object.entries(this.nodes).forEach(([key, node]) => {\n      if (MPTree.nodeHash(node) !== key) throw new MerkleTreeHashMismatchError()\n      const { type, payload } = MPTree.parseNode(node)\n      switch (type) {\n        case NodeType.Branch:\n          payload\n            .slice(0, 16)\n            .filter(n => n.length)\n            .forEach((n) => {\n              if (this.nodes[n.toString('hex')] === undefined) {\n                throw new MissingNodeInTreeError('Can\\'t find a node by hash in branch node')\n              }\n            })\n          break\n        case NodeType.Extension:\n          if (this.nodes[payload[0].toString('hex')] === undefined) {\n            throw new MissingNodeInTreeError('Can\\'t find a node by hash in extension node')\n          }\n      }\n    })\n  }\n\n  isEqual (tree: MPTree): boolean {\n    return this.rootHash === tree.rootHash\n  }\n\n  private static parseNode (node: Buffer[]): { type: NodeType, payload: Buffer[], path: string | null } {\n    switch (node.length) {\n      case 17:\n        return { type: NodeType.Branch, payload: node, path: null }\n      case 2: {\n        const path = node[0].toString('hex')\n        const nibble = parseInt(path[0], 16)\n        if (nibble > 3) throw new UnknownPathNibbleError(nibble)\n        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf\n        const slice = [0, 2].includes(nibble) ? 2 : 1\n        return { type, payload: [node[1]], path: path.slice(slice) }\n      }\n      default:\n        throw new UnknownNodeLengthError(node.length)\n    }\n  }\n\n  /**\n   * Serialize Merkle Patricia Tree\n   * @rtype () => Array\n   * @return {Array} Binary\n   */\n  serialize (): MPTreeBinary {\n    return [\n      Buffer.from(this.rootHash, 'hex'),\n      Object.entries(this.nodes).map(([mptHash, value]) => ([\n        Buffer.from(mptHash, 'hex'),\n        value\n      ]))\n    ]\n  }\n\n  /**\n   * Retrieve value from Merkle Patricia Tree\n   * @rtype (key: String) => Buffer\n   * @param {String} key - The key of the element to retrieve\n   * @return {Buffer} Value associated to the specified key\n   */\n  get (key: string): Buffer | undefined {\n    let searchFrom = this.rootHash\n    while (true) {\n      const { type, payload, path } = MPTree.parseNode(this.nodes[searchFrom])\n      switch (type) {\n        case NodeType.Branch:\n          if (key.length === 0) return payload[16]\n          searchFrom = payload[parseInt(key[0], 16)].toString('hex')\n          key = key.substr(1)\n          break\n        case NodeType.Extension:\n          if (key.substr(0, path?.length) !== path) return undefined\n          searchFrom = payload[0].toString('hex')\n          key = key.substr(path.length)\n          break\n        case NodeType.Leaf:\n          if (path !== key) return undefined\n          return payload[0]\n      }\n    }\n  }\n}\n"],"file":"mptree.mjs"}
+{"version":3,"file":"mptree.mjs","names":["hash","MerkleTreeHashMismatchError","MissingNodeInTreeError","UnknownPathNibbleError","UnknownNodeLengthError","NodeType","MPTree","nodeHash","node","from","rlpEncode","toString","constructor","binary","rootHash","nodes","Object","fromEntries","map","undefined","entries","forEach","key","type","payload","parseNode","Branch","slice","filter","n","length","Extension","isEqual","tree","path","nibble","Leaf","serialize","mptHash","value","get","searchFrom","substr"],"sources":["../../src/utils/mptree.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2021 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\n\nimport { encode as rlpEncode } from 'rlp'\nimport type { Input } from 'rlp'\nimport { hash } from './crypto'\nimport {\n  MerkleTreeHashMismatchError,\n  MissingNodeInTreeError,\n  UnknownPathNibbleError,\n  UnknownNodeLengthError\n} from './errors'\n\nenum NodeType {\n  Branch,\n  Extension,\n  Leaf\n}\n\nexport type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>]\n\nexport default class MPTree {\n  private readonly rootHash: string\n  private readonly nodes: { [key: string]: Buffer[] }\n\n  private static nodeHash (node: Input): string {\n    return Buffer.from(hash(rlpEncode(node))).toString('hex')\n  }\n\n  /**\n   * Deserialize Merkle Patricia Tree\n   * @param binary - Binary\n   * @returns Merkle Patricia Tree\n   */\n  constructor (binary: MPTreeBinary) {\n    this.rootHash = binary[0].toString('hex')\n    this.nodes = Object.fromEntries(\n      binary[1].map((node) => [node[0].toString('hex'), node[1]])\n    )\n\n    if (this.nodes[this.rootHash] === undefined) throw new MissingNodeInTreeError('Can\\'t find a node by root hash')\n    Object.entries(this.nodes).forEach(([key, node]) => {\n      if (MPTree.nodeHash(node) !== key) throw new MerkleTreeHashMismatchError()\n      const { type, payload } = MPTree.parseNode(node)\n      switch (type) {\n        case NodeType.Branch:\n          payload\n            .slice(0, 16)\n            .filter(n => n.length)\n            .forEach((n) => {\n              if (this.nodes[n.toString('hex')] === undefined) {\n                throw new MissingNodeInTreeError('Can\\'t find a node by hash in branch node')\n              }\n            })\n          break\n        case NodeType.Extension:\n          if (this.nodes[payload[0].toString('hex')] === undefined) {\n            throw new MissingNodeInTreeError('Can\\'t find a node by hash in extension node')\n          }\n      }\n    })\n  }\n\n  isEqual (tree: MPTree): boolean {\n    return this.rootHash === tree.rootHash\n  }\n\n  private static parseNode (node: Buffer[]): {\n    type: NodeType\n    payload: Buffer[]\n    path: string | null\n  } {\n    switch (node.length) {\n      case 17:\n        return { type: NodeType.Branch, payload: node, path: null }\n      case 2: {\n        const nibble = node[0][0] >> 4\n        if (nibble > 3) throw new UnknownPathNibbleError(nibble)\n        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf\n        const slice = [0, 2].includes(nibble) ? 2 : 1\n        return { type, payload: [node[1]], path: node[0].toString('hex').slice(slice) }\n      }\n      default:\n        throw new UnknownNodeLengthError(node.length)\n    }\n  }\n\n  /**\n   * Serialize Merkle Patricia Tree\n   * @returns Binary\n   */\n  serialize (): MPTreeBinary {\n    return [\n      Buffer.from(this.rootHash, 'hex'),\n      Object.entries(this.nodes).map(([mptHash, value]) => ([\n        Buffer.from(mptHash, 'hex'),\n        value\n      ]))\n    ]\n  }\n\n  /**\n   * Retrieve value from Merkle Patricia Tree\n   * @param key - The key of the element to retrieve\n   * @returns Value associated to the specified key\n   */\n  get (key: string): Buffer | undefined {\n    let searchFrom = this.rootHash\n    while (true) {\n      const { type, payload, path } = MPTree.parseNode(this.nodes[searchFrom])\n      switch (type) {\n        case NodeType.Branch:\n          if (key.length === 0) return payload[16]\n          searchFrom = payload[+`0x${key[0]}`].toString('hex')\n          key = key.substr(1)\n          break\n        case NodeType.Extension:\n          if (key.substr(0, path?.length) !== path) return undefined\n          searchFrom = payload[0].toString('hex')\n          key = key.substr(path.length)\n          break\n        case NodeType.Leaf:\n          if (path !== key) return undefined\n          return payload[0]\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/es/utils/other.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+export declare const pause: (duration: number) => Promise<void>;
+export declare const mapObject: <InputV, OutputV>(object: {
+    [k: string]: InputV;
+}, fn: (value: [string, InputV], index: number, array: [string, InputV][]) => [string | number, OutputV]) => {
+    [k: string]: OutputV;
+};
+export declare const concatBuffers: (list: readonly Uint8Array[], totalLength?: number | undefined) => Buffer;
+/**
+ * Object key type guard
+ * @param key - Object key
+ * @param object - object
+ */
+export declare function isKeyOfObject<T>(key: string | number | symbol, object: T): key is keyof T;

package/es/utils/other.mjs

@@ -1,43 +1,28 @@
-import { snakeToPascal, pascalToSnake } from "./string.mjs";
+import _buffer from "buffer";
+const {
+  Buffer: _Buffer
+} = _buffer;
 export const pause = async duration => await new Promise(resolve => setTimeout(resolve, duration));
-export const mapObject = (object, fn) => Object.fromEntries(Object.entries(object).map(fn));
-export const filterObject = (object, fn) => Object.fromEntries(Object.entries(object).filter(fn));
-/**
- * Key traversal metafunction
- * @static
- * @function
- * @rtype (fn: (s: String) => String) => (o: Object) => Object
- * @param {Function} fn - Key transformation function
- * @param {Object} object - Object to traverse
- * @return {Object} Transformed object
- */
+export const mapObject = (object, fn) => Object.fromEntries(Object.entries(object).map(fn)); // remove after dropping webpack4 support
 
-export const traverseKeys = (fn, object) => {
-  if (typeof object !== 'object' || object === null) return object;
-  if (Array.isArray(object)) return object.map(i => traverseKeys(fn, i));
-  return mapObject(object, _ref => {
-    let [key, value] = _ref;
-    return [fn(key), traverseKeys(fn, value)];
-  });
-};
-/**
- * snake_case key traversal
- * @static
- * @rtype (o: Object) => Object
- * @param {Object} object - Object to traverse
- * @return {Object} Transformed object
- * @see pascalToSnake
- */
+const isWebpack4Buffer = (() => {
+  try {
+    _Buffer.concat([Uint8Array.from([])]);
+
+    return false;
+  } catch (error) {
+    return true;
+  }
+})();
 
-export const snakizeKeys = traverseKeys.bind(null, pascalToSnake);
+export const concatBuffers = isWebpack4Buffer ? (list, totalLength) => _Buffer.concat(list.map(el => _Buffer.from(el)), totalLength) : _Buffer.concat;
 /**
- * PascalCase key traversal
- * @static
- * @rtype (o: Object) => Object
- * @param {Object} object - Object to traverse
- * @return {Object} Transformed object
- * @see snakeToPascal
+ * Object key type guard
+ * @param key - Object key
+ * @param object - object
  */
 
-export const pascalizeKeys = traverseKeys.bind(null, snakeToPascal);
+export function isKeyOfObject(key, object) {
+  return key in object;
+}
 //# sourceMappingURL=other.mjs.map