@aeternity/aepp-sdk 12.0.0 → 12.1.0

package/src/utils/hd-wallet.ts

@@ -1,134 +1,166 @@
-import nacl from 'tweetnacl'
-import { full as hmac } from 'tweetnacl-auth'
-import { fromString } from 'bip32-path'
-import { decryptKey, encryptKey } from './crypto'
-import { encode } from './encoder'
-import { CryptographyError } from './errors'
-import { bytesToHex } from './bytes'
-import { concatBuffers } from './other'
+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'
+  constructor(message: string) {
+    super(message);
+    this.name = 'DerivationError';
   }
 }
 
-const ED25519_CURVE = Buffer.from('ed25519 seed')
-const HARDENED_OFFSET = 0x80000000
+const ED25519_CURVE = Buffer.from('ed25519 seed');
+const HARDENED_OFFSET = 0x80000000;
 
 interface KeyTreeNode {
-  secretKey: Uint8Array
-  chainCode: Uint8Array
+  secretKey: Uint8Array;
+  chainCode: Uint8Array;
 }
 
 interface HDWallet {
-  secretKey: string
-  chainCode: string
+  secretKey: string;
+  chainCode: string;
 }
 
 interface Account {
-  secretKey: string
-  publicKey: string
+  secretKey: string;
+  publicKey: string;
 }
 
-type Dec<N extends number> = [-1, 0, 1, 2, 3, 4][N]
+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}`
+  : Bip32PathT<Dec<MaxLen>, H> | `${Bip32PathT<Dec<MaxLen>, H>}/${number}${H}`;
 type Bip32Path<MaxLen extends number> =
-  '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>
+  '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
 
-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 derivePathFromSeed (path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8Array): KeyTreeNode {
-  if (!['m', 'm/'].includes(path.slice(0, 2))) {
-    throw new DerivationError('Root element is required')
+export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
+  if (index < HARDENED_OFFSET) {
+    throw new DerivationError(`Segment ${index} is not hardened`);
   }
-  const masterKey = getMasterKeyFromSeed(seed)
-  return derivePathFromKey(path.slice(2) as Bip32Path<5>, masterKey)
-}
+  const indexBuffer = Buffer.allocUnsafe(4);
+  indexBuffer.writeUInt32BE(index, 0);
+
+  const data = concatBuffers([Buffer.alloc(1, 0), secretKey, indexBuffer]);
 
-function formatAccount (keys: nacl.SignKeyPair): Account {
-  const { secretKey, publicKey } = keys
+  const I = hmac(data, chainCode);
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
   return {
-    secretKey: bytesToHex(secretKey),
-    publicKey: encode(publicKey, 'ak')
-  }
+    secretKey: IL,
+    chainCode: IR,
+  };
 }
 
-export function getKeyPair (secretKey: Uint8Array): nacl.SignKeyPair {
-  return nacl.sign.keyPair.fromSeed(secretKey)
+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)
+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
-  }
+    chainCode: IR,
+  };
 }
 
-export function deriveChild ({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
-  if (index < HARDENED_OFFSET) {
-    throw new DerivationError(`Segment ${index} is not hardened`)
+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 indexBuffer = Buffer.allocUnsafe(4)
-  indexBuffer.writeUInt32BE(index, 0)
-
-  const data = concatBuffers([Buffer.alloc(1, 0), secretKey, indexBuffer])
+  const masterKey = getMasterKeyFromSeed(seed);
+  return derivePathFromKey(path.slice(2) as Bip32Path<5>, masterKey);
+}
 
-  const I = hmac(data, chainCode)
-  const IL = I.slice(0, 32)
-  const IR = I.slice(32)
+function formatAccount(keys: nacl.SignKeyPair): Account {
+  const { secretKey, publicKey } = keys;
   return {
-    secretKey: IL,
-    chainCode: IR
-  }
+    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)
+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))
-  }
+    chainCode: bytesToHex(encryptKey(password, walletKey.chainCode)),
+  };
 }
 
-export function getSaveHDWalletAccounts (
-  saveHDWallet: HDWallet, password: string, accountCount: number
+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'))
-  }
+    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)))
+    .map((_, idx) => formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)));
 }
 
 export const getHdWalletAccountFromSeed = (
-  seed: Uint8Array, accountIdx: number
+  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)
+  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
-  }
-}
+    idx: accountIdx,
+  };
+};

package/src/utils/json-big.ts

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

package/src/utils/keystore.ts

@@ -1,17 +1,19 @@
-import nacl from 'tweetnacl'
-import { v4 as uuid } from '@aeternity/uuid'
-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'
+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 (
+  async argon2id(
     pass: string | Uint8Array,
     salt: string | Uint8Array,
-    params: Partial<Keystore['crypto']['kdf_params']>
+    params: Partial<Keystore['crypto']['kdf_params']>,
   ): Promise<Uint8Array> {
-    const { memlimit_kib: mem, opslimit: time } = params
+    const { memlimit_kib: mem, opslimit: time } = params;
 
     return (await hash({
       hashLen: 32,
@@ -19,42 +21,42 @@ const DERIVED_KEY_FUNCTIONS = {
       salt,
       time,
       mem,
-      type: ArgonType.Argon2id
-    })).hash
-  }
-}
+      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
-    }
-  }
-}
+    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
+  name: string;
+  version: 1;
+  public_key: string;
+  id: string;
   crypto: {
-    secret_type: 'ed25519'
-    symmetric_alg: keyof typeof CRYPTO_FUNCTIONS
-    ciphertext: string
+    secret_type: 'ed25519';
+    symmetric_alg: keyof typeof CRYPTO_FUNCTIONS;
+    ciphertext: string;
     cipher_params: {
-      nonce: string
-    }
-    kdf: keyof typeof DERIVED_KEY_FUNCTIONS
+      nonce: string;
+    };
+    kdf: keyof typeof DERIVED_KEY_FUNCTIONS;
     kdf_params: {
-      memlimit_kib: number
-      opslimit: number
-      parallelism: number
-      salt: string
-    }
-  }
+      memlimit_kib: number;
+      opslimit: number;
+      parallelism: number;
+      salt: string;
+    };
+  };
 }
 
 const CRYPTO_DEFAULTS = {
@@ -64,9 +66,9 @@ const CRYPTO_DEFAULTS = {
   kdf_params: {
     memlimit_kib: 65536,
     opslimit: 3,
-    parallelism: 1
-  }
-} as const
+    parallelism: 1,
+  },
+} as const;
 
 /**
  * Symmetric private key encryption using secret (derived) key.
@@ -76,13 +78,13 @@ const CRYPTO_DEFAULTS = {
  * @param algo - Encryption algorithm.
  * @returns Encrypted data.
  */
-function encrypt (
+function encrypt(
   plaintext: Uint8Array,
   key: Uint8Array,
   nonce: Uint8Array,
-  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg
+  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
 ): Uint8Array {
-  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key)
+  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key);
 }
 
 /**
@@ -93,13 +95,13 @@ function encrypt (
  * @param algo - Encryption algorithm.
  * @returns Decrypted data.
  */
-function decrypt (
+function decrypt(
   ciphertext: Uint8Array,
   key: Uint8Array,
   nonce: Uint8Array,
-  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg
+  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
 ): Uint8Array {
-  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key)
+  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key);
 }
 
 /**
@@ -110,13 +112,13 @@ function decrypt (
  * @param kdfParams - KDF parameters.
  * @returns Secret key derived from password.
  */
-async function deriveKey (
+async function deriveKey(
   password: string | Uint8Array,
   nonce: string | Uint8Array,
   kdf: Keystore['crypto']['kdf'],
-  kdfParams: Omit<Keystore['crypto']['kdf_params'], 'salt'>
+  kdfParams: Omit<Keystore['crypto']['kdf_params'], 'salt'>,
 ): Promise<Uint8Array> {
-  return await DERIVED_KEY_FUNCTIONS[kdf](password, nonce, kdfParams)
+  return DERIVED_KEY_FUNCTIONS[kdf](password, nonce, kdfParams);
 }
 
 /**
@@ -125,16 +127,17 @@ async function deriveKey (
  * @param keystore - Keystore object.
  * @returns Plaintext private key.
  */
-export async function recover (
-  password: string | Uint8Array, { crypto }: Keystore
+export async function recover(
+  password: string | Uint8Array,
+  { crypto }: Keystore,
 ): Promise<string> {
-  const salt = hexToBytes(crypto.kdf_params.salt)
+  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
-  ))
+    crypto.symmetric_alg,
+  ));
 }
 
 /**
@@ -148,17 +151,17 @@ export async function recover (
  * @param options.kdf - Key derivation function.
  * @param options.kdf_params - KDF parameters.
  */
-export async function dump (
+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']>
+  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
+  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,
@@ -172,8 +175,8 @@ export async function dump (
       kdf: opt.kdf,
       kdf_params: {
         ...opt.kdf_params,
-        salt: bytesToHex(salt)
-      }
-    }
-  }
+        salt: bytesToHex(salt),
+      },
+    },
+  };
 }