@aeternity/aepp-sdk 11.0.0 → 12.1.0

package/src/utils/hd-wallet.ts

@@ -0,0 +1,166 @@
+import nacl from 'tweetnacl';
+import { full as hmac } from 'tweetnacl-auth';
+import { fromString } from 'bip32-path';
+import aesjs from 'aes-js';
+import { sha256hash, encode, Encoding } from './encoder';
+import { CryptographyError } from './errors';
+import { bytesToHex } from './bytes';
+import { concatBuffers } from './other';
+
+const Ecb = aesjs.ModeOfOperation.ecb;
+
+// TODO: at least don't export `encryptKey` and `decryptKey`
+/**
+ * Encrypt given data using `password`
+ * @param password - Password to encrypt with
+ * @param binaryData - Data to encrypt
+ * @returns Encrypted data
+ * @deprecated use 'sha.js' and 'aes-js' packages directly instead
+ */
+export function encryptKey(password: string, binaryData: Uint8Array): Uint8Array {
+  const hashedPasswordBytes = sha256hash(password);
+  const aesEcb = new Ecb(hashedPasswordBytes);
+  return aesEcb.encrypt(binaryData);
+}
+
+/**
+ * Decrypt given data using `password`
+ * @param password - Password to decrypt with
+ * @param encrypted - Data to decrypt
+ * @returns Decrypted data
+ * @deprecated use 'sha.js' and 'aes-js' packages directly instead
+ */
+export function decryptKey(password: string, encrypted: Uint8Array): Uint8Array {
+  const encryptedBytes = Buffer.from(encrypted);
+  const hashedPasswordBytes = sha256hash(password);
+  const aesEcb = new Ecb(hashedPasswordBytes);
+  return aesEcb.decrypt(encryptedBytes);
+}
+
+/**
+ * @category exception
+ */
+export class DerivationError extends CryptographyError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DerivationError';
+  }
+}
+
+const ED25519_CURVE = Buffer.from('ed25519 seed');
+const HARDENED_OFFSET = 0x80000000;
+
+interface KeyTreeNode {
+  secretKey: Uint8Array;
+  chainCode: Uint8Array;
+}
+
+interface HDWallet {
+  secretKey: string;
+  chainCode: string;
+}
+
+interface Account {
+  secretKey: string;
+  publicKey: string;
+}
+
+type Dec<N extends number> = [-1, 0, 1, 2, 3, 4][N];
+type Bip32PathT<MaxLen extends number, H extends 'H' | 'h' | '\''> = MaxLen extends -1
+  ? `${number}${H}`
+  : Bip32PathT<Dec<MaxLen>, H> | `${Bip32PathT<Dec<MaxLen>, H>}/${number}${H}`;
+type Bip32Path<MaxLen extends number> =
+  '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
+
+export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
+  if (index < HARDENED_OFFSET) {
+    throw new DerivationError(`Segment ${index} is not hardened`);
+  }
+  const indexBuffer = Buffer.allocUnsafe(4);
+  indexBuffer.writeUInt32BE(index, 0);
+
+  const data = concatBuffers([Buffer.alloc(1, 0), secretKey, indexBuffer]);
+
+  const I = hmac(data, chainCode);
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    secretKey: IL,
+    chainCode: IR,
+  };
+}
+
+export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTreeNode {
+  const segments = path === '' ? [] : fromString(path).toPathArray();
+  segments.forEach((segment, i) => {
+    if (segment < HARDENED_OFFSET) {
+      throw new DerivationError(`Segment #${i + 1} is not hardened`);
+    }
+  });
+
+  return segments.reduce((parentKey, segment) => deriveChild(parentKey, segment), key);
+}
+
+export function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode {
+  const I = hmac(seed, ED25519_CURVE);
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    secretKey: IL,
+    chainCode: IR,
+  };
+}
+
+export function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8Array): KeyTreeNode {
+  if (!['m', 'm/'].includes(path.slice(0, 2))) {
+    throw new DerivationError('Root element is required');
+  }
+  const masterKey = getMasterKeyFromSeed(seed);
+  return derivePathFromKey(path.slice(2) as Bip32Path<5>, masterKey);
+}
+
+function formatAccount(keys: nacl.SignKeyPair): Account {
+  const { secretKey, publicKey } = keys;
+  return {
+    secretKey: bytesToHex(secretKey),
+    publicKey: encode(publicKey, Encoding.AccountAddress),
+  };
+}
+
+export function getKeyPair(secretKey: Uint8Array): nacl.SignKeyPair {
+  return nacl.sign.keyPair.fromSeed(secretKey);
+}
+
+export function generateSaveHDWalletFromSeed(seed: Uint8Array, password: string): HDWallet {
+  const walletKey = derivePathFromSeed('m/44h/457h', seed);
+  return {
+    secretKey: bytesToHex(encryptKey(password, walletKey.secretKey)),
+    chainCode: bytesToHex(encryptKey(password, walletKey.chainCode)),
+  };
+}
+
+export function getSaveHDWalletAccounts(
+  saveHDWallet: HDWallet,
+  password: string,
+  accountCount: number,
+): Account[] {
+  const walletKey = {
+    secretKey: decryptKey(password, Buffer.from(saveHDWallet.secretKey, 'hex')),
+    chainCode: decryptKey(password, Buffer.from(saveHDWallet.chainCode, 'hex')),
+  };
+  return (new Array(accountCount)).fill(undefined)
+    .map((_, idx) => formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)));
+}
+
+export const getHdWalletAccountFromSeed = (
+  seed: Uint8Array,
+  accountIdx: number,
+): Account & { idx: number } => {
+  const walletKey = derivePathFromSeed('m/44h/457h', seed);
+  const derived = derivePathFromKey(`${accountIdx}h/0h/0h`, walletKey);
+  const keyPair = getKeyPair(derived.secretKey);
+  return {
+    ...formatAccount(keyPair),
+    idx: accountIdx,
+  };
+};

package/src/utils/json-big.ts

@@ -0,0 +1,27 @@
+import JsonBig from 'json-bigint';
+import BigNumber from 'bignumber.js';
+import { mapObject } from './other';
+
+const jsonBig = JsonBig({ storeAsString: true });
+
+const convertValuesToBigNumbers = (value: any): any => {
+  if (typeof value === 'object' && value !== null && value.constructor === Object) {
+    return mapObject(value, ([k, v]) => [k, convertValuesToBigNumbers(v)]);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => convertValuesToBigNumbers(item));
+  }
+  if (typeof value === 'string' && new BigNumber(value).toString(10) === value) {
+    const bn = new BigNumber(value);
+    bn.toJSON = () => bn.toString(10);
+    return bn;
+  }
+  return value;
+};
+
+export default {
+  stringify: (...args: Parameters<typeof JsonBig['stringify']>): string => (
+    jsonBig.stringify(convertValuesToBigNumbers(args[0]), ...args.slice(1))
+  ),
+  parse: jsonBig.parse,
+};

package/src/utils/keystore.ts

@@ -0,0 +1,182 @@
+import nacl from 'tweetnacl';
+import { v4 as uuid } from '@aeternity/uuid';
+// js extension is required for mjs build
+// eslint-disable-next-line import/extensions
+import { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js';
+import { getAddressFromPriv } from './crypto';
+import { bytesToHex, hexToBytes } from './bytes';
+import { InvalidPasswordError } from './errors';
+
+const DERIVED_KEY_FUNCTIONS = {
+  async argon2id(
+    pass: string | Uint8Array,
+    salt: string | Uint8Array,
+    params: Partial<Keystore['crypto']['kdf_params']>,
+  ): Promise<Uint8Array> {
+    const { memlimit_kib: mem, opslimit: time } = params;
+
+    return (await hash({
+      hashLen: 32,
+      pass,
+      salt,
+      time,
+      mem,
+      type: ArgonType.Argon2id,
+    })).hash;
+  },
+};
+
+const CRYPTO_FUNCTIONS = {
+  'xsalsa20-poly1305': {
+    encrypt: nacl.secretbox,
+    decrypt(...args: Parameters<typeof nacl.secretbox.open>): Uint8Array {
+      const res = nacl.secretbox.open(...args);
+      if (res == null) throw new InvalidPasswordError();
+      return res;
+    },
+  },
+};
+
+export interface Keystore {
+  name: string;
+  version: 1;
+  public_key: string;
+  id: string;
+  crypto: {
+    secret_type: 'ed25519';
+    symmetric_alg: keyof typeof CRYPTO_FUNCTIONS;
+    ciphertext: string;
+    cipher_params: {
+      nonce: string;
+    };
+    kdf: keyof typeof DERIVED_KEY_FUNCTIONS;
+    kdf_params: {
+      memlimit_kib: number;
+      opslimit: number;
+      parallelism: number;
+      salt: string;
+    };
+  };
+}
+
+const CRYPTO_DEFAULTS = {
+  secret_type: 'ed25519',
+  symmetric_alg: 'xsalsa20-poly1305',
+  kdf: 'argon2id',
+  kdf_params: {
+    memlimit_kib: 65536,
+    opslimit: 3,
+    parallelism: 1,
+  },
+} as const;
+
+/**
+ * Symmetric private key encryption using secret (derived) key.
+ * @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: Uint8Array,
+  key: Uint8Array,
+  nonce: Uint8Array,
+  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
+): Uint8Array {
+  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key);
+}
+
+/**
+ * Symmetric private key decryption using secret (derived) key.
+ * @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: Uint8Array,
+  key: Uint8Array,
+  nonce: Uint8Array,
+  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
+): Uint8Array {
+  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key);
+}
+
+/**
+ * Derive secret key from password with key derivation function.
+ * @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: string | Uint8Array,
+  nonce: string | Uint8Array,
+  kdf: Keystore['crypto']['kdf'],
+  kdfParams: Omit<Keystore['crypto']['kdf_params'], 'salt'>,
+): Promise<Uint8Array> {
+  return 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.
+ */
+export async function recover(
+  password: string | Uint8Array,
+  { crypto }: Keystore,
+): Promise<string> {
+  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,
+  ));
+}
+
+/**
+ * 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.
+ */
+export async function dump(
+  name: string,
+  password: string | Uint8Array,
+  privateKey: string | Uint8Array,
+  nonce: Uint8Array = nacl.randomBytes(24),
+  salt: Uint8Array = nacl.randomBytes(16),
+  options?: Partial<Keystore['crypto']>,
+): Promise<Keystore> {
+  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(payload),
+    id: uuid(),
+    crypto: {
+      secret_type: opt.secret_type,
+      symmetric_alg: opt.symmetric_alg,
+      ciphertext: bytesToHex(encrypt(payload, derivedKey, nonce, opt.symmetric_alg)),
+      cipher_params: { nonce: bytesToHex(nonce) },
+      kdf: opt.kdf,
+      kdf_params: {
+        ...opt.kdf_params,
+        salt: bytesToHex(salt),
+      },
+    },
+  };
+}

package/src/utils/mptree.ts

@@ -15,127 +15,130 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { encode as rlpEncode } from 'rlp'
-import type { Input } from 'rlp'
-import { hash } from './crypto-ts'
+/* eslint-disable default-case */
+import { encode as rlpEncode } from 'rlp';
+import type { Input } from 'rlp';
+import { hash } from './crypto';
 import {
   MerkleTreeHashMismatchError,
   MissingNodeInTreeError,
   UnknownPathNibbleError,
-  UnknownNodeLengthError
-} from './errors'
+  UnknownNodeLengthError,
+} from './errors';
 
 enum NodeType {
   Branch,
   Extension,
-  Leaf
+  Leaf,
 }
 
-export type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>]
+export type MPTreeBinary = [Buffer, Array<[Buffer, Buffer[]]>];
 
 export default class MPTree {
-  private readonly rootHash: string
-  private readonly nodes: { [key: string]: Buffer[] }
+  private readonly rootHash: string;
 
-  private static nodeHash (node: Input): string {
-    return Buffer.from(hash(rlpEncode(node))).toString('hex')
+  private readonly nodes: { [key: string]: Buffer[] };
+
+  private static nodeHash(node: Input): string {
+    return Buffer.from(hash(rlpEncode(node))).toString('hex');
   }
 
   /**
    * 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) {
-    this.rootHash = binary[0].toString('hex')
+  constructor(binary: MPTreeBinary) {
+    this.rootHash = binary[0].toString('hex');
     this.nodes = Object.fromEntries(
-      binary[1].map((node) => [node[0].toString('hex'), node[1]])
-    )
+      binary[1].map((node) => [node[0].toString('hex'), node[1]]),
+    );
 
-    if (this.nodes[this.rootHash] === undefined) throw new MissingNodeInTreeError('Can\'t find a node by root hash')
+    if (this.nodes[this.rootHash] === undefined) throw new MissingNodeInTreeError('Can\'t find a node by root hash');
     Object.entries(this.nodes).forEach(([key, node]) => {
-      if (MPTree.nodeHash(node) !== key) throw new MerkleTreeHashMismatchError()
-      const { type, payload } = MPTree.parseNode(node)
+      if (MPTree.nodeHash(node) !== key) throw new MerkleTreeHashMismatchError();
+      const { type, payload } = MPTree.parseNode(node);
       switch (type) {
         case NodeType.Branch:
           payload
             .slice(0, 16)
-            .filter(n => n.length)
+            .filter((n) => n.length)
             .forEach((n) => {
               if (this.nodes[n.toString('hex')] === undefined) {
-                throw new MissingNodeInTreeError('Can\'t find a node by hash in branch node')
+                throw new MissingNodeInTreeError('Can\'t find a node by hash in branch node');
               }
-            })
-          break
+            });
+          break;
         case NodeType.Extension:
           if (this.nodes[payload[0].toString('hex')] === undefined) {
-            throw new MissingNodeInTreeError('Can\'t find a node by hash in extension node')
+            throw new MissingNodeInTreeError('Can\'t find a node by hash in extension node');
           }
       }
-    })
+    });
   }
 
-  isEqual (tree: MPTree): boolean {
-    return this.rootHash === tree.rootHash
+  isEqual(tree: MPTree): boolean {
+    return this.rootHash === tree.rootHash;
   }
 
-  private static parseNode (node: Buffer[]): { type: NodeType, payload: Buffer[], path: string | null } {
+  private static parseNode(node: Buffer[]): {
+    type: NodeType;
+    payload: Buffer[];
+    path: string | null;
+  } {
     switch (node.length) {
       case 17:
-        return { type: NodeType.Branch, payload: node, path: null }
+        return { type: NodeType.Branch, payload: node, path: null };
       case 2: {
-        const path = node[0].toString('hex')
-        const nibble = parseInt(path[0], 16)
-        if (nibble > 3) throw new UnknownPathNibbleError(nibble)
-        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf
-        const slice = [0, 2].includes(nibble) ? 2 : 1
-        return { type, payload: [node[1]], path: path.slice(slice) }
+        const nibble = node[0][0] >> 4; // eslint-disable-line no-bitwise
+        if (nibble > 3) throw new UnknownPathNibbleError(nibble);
+        const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf;
+        const slice = [0, 2].includes(nibble) ? 2 : 1;
+        return { type, payload: [node[1]], path: node[0].toString('hex').slice(slice) };
       }
       default:
-        throw new UnknownNodeLengthError(node.length)
+        throw new UnknownNodeLengthError(node.length);
     }
   }
 
   /**
    * Serialize Merkle Patricia Tree
-   * @rtype () => Array
-   * @return {Array} Binary
+   * @returns Binary
    */
-  serialize (): MPTreeBinary {
+  serialize(): MPTreeBinary {
     return [
       Buffer.from(this.rootHash, 'hex'),
       Object.entries(this.nodes).map(([mptHash, value]) => ([
         Buffer.from(mptHash, 'hex'),
-        value
-      ]))
-    ]
+        value,
+      ])),
+    ];
   }
 
   /**
    * 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 {
-    let searchFrom = this.rootHash
-    while (true) {
-      const { type, payload, path } = MPTree.parseNode(this.nodes[searchFrom])
+  get(_key: string): Buffer | undefined {
+    let searchFrom = this.rootHash;
+    let key = _key;
+    while (true) { // eslint-disable-line no-constant-condition
+      const { type, payload, path } = MPTree.parseNode(this.nodes[searchFrom]);
       switch (type) {
         case NodeType.Branch:
-          if (key.length === 0) return payload[16]
-          searchFrom = payload[parseInt(key[0], 16)].toString('hex')
-          key = key.substr(1)
-          break
+          if (key.length === 0) return payload[16];
+          searchFrom = payload[+`0x${key[0]}`].toString('hex');
+          key = key.substring(1);
+          break;
         case NodeType.Extension:
-          if (key.substr(0, path?.length) !== path) return undefined
-          searchFrom = payload[0].toString('hex')
-          key = key.substr(path.length)
-          break
+          if (key.substring(0, path?.length) !== path) return undefined;
+          searchFrom = payload[0].toString('hex');
+          key = key.substring(path.length);
+          break;
         case NodeType.Leaf:
-          if (path !== key) return undefined
-          return payload[0]
+          if (path !== key) return undefined;
+          return payload[0];
       }
     }
   }

package/src/utils/other.ts

@@ -1,51 +1,44 @@
-import { snakeToPascal, pascalToSnake } from './string'
+export const pause = async (duration: number): Promise<void> => new Promise((resolve) => {
+  setTimeout(resolve, duration);
+});
 
-export const pause = async (duration: number): Promise<void> =>
-  await new Promise(resolve => setTimeout(resolve, duration))
+export const mapObject = <InputV, OutputV>(
+  object: { [k: string]: InputV },
+  fn: (
+    value: [string, InputV], index: number, array: Array<[string, InputV]>
+  ) => [number | string, OutputV],
+): { [k: string]: OutputV } => Object.fromEntries(Object.entries(object).map(fn));
 
-export const mapObject = (
-  object: object,
-  fn: (value: [string, any], index: number, array: Array<[string, any]>) => Array<[string, any]>
-): object => Object.fromEntries(Object.entries(object).map(fn))
+// remove after dropping webpack4 support
+const isWebpack4Buffer = (() => {
+  try {
+    Buffer.concat([Uint8Array.from([])]);
+    return false;
+  } catch (error) {
+    return true;
+  }
+})();
 
-export const filterObject = (
-  object: object,
-  fn: (value: [string, any], index: number, array: Array<[string, any]>) => boolean
-): object => Object.fromEntries(Object.entries(object).filter(fn))
+export const concatBuffers = isWebpack4Buffer
+  ? (list: readonly Uint8Array[], totalLength?: number): Buffer => (
+    Buffer.concat(list.map((el) => Buffer.from(el)), totalLength)
+  )
+  : Buffer.concat;
 
 /**
- * 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
+ * Object key type guard
+ * @param key - Maybe object key
+ * @param object - Object
  */
-export const traverseKeys = (fn: Function, object: any): any => {
-  if (typeof object !== 'object' || object === null) return object
-  if (Array.isArray(object)) return object.map(i => traverseKeys(fn, i))
-  return mapObject(object, ([key, value]: [string, any]) => [
-    fn(key), traverseKeys(fn, value)
-  ])
+export function isKeyOfObject<T>(key: string | number | symbol, object: T): key is keyof T {
+  return key in object;
 }
 
 /**
- * snake_case key traversal
- * @static
- * @rtype (o: Object) => Object
- * @param {Object} object - Object to traverse
- * @return {Object} Transformed object
- * @see pascalToSnake
+ * Array item type guard
+ * @param item - Maybe array item
+ * @param array - Array
  */
-export const snakizeKeys = traverseKeys.bind(null, pascalToSnake)
-
-/**
- * PascalCase key traversal
- * @static
- * @rtype (o: Object) => Object
- * @param {Object} object - Object to traverse
- * @return {Object} Transformed object
- * @see snakeToPascal
- */
-export const pascalizeKeys = traverseKeys.bind(null, snakeToPascal)
+export function isItemOfArray<T>(item: any, array: readonly T[]): item is T {
+  return array.includes(item);
+}