@aeternity/aepp-sdk 11.0.0 → 12.1.0

package/src/utils/crypto.js

@@ -1,229 +0,0 @@
-/*
- * ISC License (ISC)
- * Copyright 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
-/**
- * Crypto module
- * @module @aeternity/aepp-sdk/es/utils/crypto
- * @example import { Crypto } from '@aeternity/aepp-sdk'
- */
-
-import nacl from 'tweetnacl'
-import aesjs from 'aes-js'
-import shajs from 'sha.js'
-
-import { str2buf } from './bytes'
-import { encode, decode } from '../tx/builder/helpers'
-import { hash } from './crypto-ts'
-import { NotImplementedError } from './errors'
-
-export * from './crypto-ts'
-
-const Ecb = aesjs.ModeOfOperation.ecb
-
-/**
- * Generate address from secret key
- * @rtype (secret: String) => tx: Promise[String]
- * @param {String} secret - Private key
- * @return {String} Public key
- */
-export function getAddressFromPriv (secret) {
-  const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret))
-  const publicBuffer = Buffer.from(keys.publicKey)
-  return encode(publicBuffer, 'ak')
-}
-
-/**
- * Check if address is valid
- * @rtype (input: String) => valid: Boolean
- * @param {String} address - Address
- * @param {String} prefix Transaction prefix. Default: 'ak'
- * @return {Boolean} valid
- */
-export function isAddressValid (address, prefix = 'ak') {
-  try {
-    decode(address, prefix)
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-/**
- * Calculate SHA256 hash of `input`
- * @rtype (input: String) => hash: String
- * @param {String} input - Data to hash
- * @return {String} Hash
- */
-export function sha256hash (input) {
-  return shajs('sha256').update(input).digest()
-}
-
-/**
- * Generate a random salt (positive integer)
- * @rtype () => salt: Number
- * @return {Number} random salt
- */
-export function salt () {
-  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER))
-}
-
-/**
- * Converts a positive integer to the smallest possible
- * representation in a binary digit representation
- * @rtype (value: Number) => Buffer
- * @param {Number} value - Value to encode
- * @return {Buffer} - Encoded data
- */
-export function encodeUnsigned (value) {
-  const binary = Buffer.allocUnsafe(4)
-  binary.writeUInt32BE(value)
-  return binary.slice(binary.findIndex(i => i !== 0))
-}
-
-// Todo Duplicated in tx builder. remove
-/**
- * Compute contract address
- * @rtype (owner: String, nonce: Number) => String
- * @param {String} owner - Address of contract owner
- * @param {Number} nonce - Round when contract was created
- * @return {String} - Contract address
- */
-export function encodeContractAddress (owner, nonce) {
-  const publicKey = decode(owner, 'ak')
-  const binary = Buffer.concat([publicKey, encodeUnsigned(nonce)])
-  return encode(hash(binary), 'ct')
-}
-
-// KEY-PAIR HELPERS
-
-/**
- * Generate keyPair from secret key
- * @rtype (secret: Uint8Array) => KeyPair
- * @param {Uint8Array} secret - secret key
- * @return {Object} - Object with Private(privateKey) and Public(publicKey) keys
- */
-export function generateKeyPairFromSecret (secret) {
-  return nacl.sign.keyPair.fromSecretKey(secret)
-}
-
-/**
- * Generate a random ED25519 keypair
- * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}
- * @param {Boolean} raw - Whether to return raw (binary) keys
- * @return {Object} Key pair
- */
-export function generateKeyPair (raw = false) {
-  // <node>/apps/aens/test/aens_test_utils.erl
-  const keyPair = nacl.sign.keyPair()
-
-  const publicBuffer = Buffer.from(keyPair.publicKey)
-  const secretBuffer = Buffer.from(keyPair.secretKey)
-
-  if (raw) {
-    return {
-      publicKey: publicBuffer,
-      secretKey: secretBuffer
-    }
-  } else {
-    return {
-      publicKey: encode(publicBuffer, 'ak'),
-      secretKey: secretBuffer.toString('hex')
-    }
-  }
-}
-
-/**
- * Encrypt given data using `password`
- * @rtype (password: String, binaryData: Buffer) => Uint8Array
- * @param {String} password - Password to encrypt with
- * @param {Buffer} binaryData - Data to encrypt
- * @return {Uint8Array} Encrypted data
- */
-export function encryptKey (password, binaryData) {
-  const hashedPasswordBytes = sha256hash(password)
-  const aesEcb = new Ecb(hashedPasswordBytes)
-  return aesEcb.encrypt(binaryData)
-}
-
-/**
- * Decrypt given data using `password`
- * @rtype (password: String, encrypted: String) => Uint8Array
- * @param {String} password - Password to decrypt with
- * @param {String} encrypted - Data to decrypt
- * @return {Buffer} Decrypted data
- */
-export function decryptKey (password, encrypted) {
-  const encryptedBytes = Buffer.from(encrypted)
-  const hashedPasswordBytes = sha256hash(password)
-  const aesEcb = new Ecb(hashedPasswordBytes)
-  return Buffer.from(aesEcb.decrypt(encryptedBytes))
-}
-
-// SIGNATURES
-
-/**
- * Generate signature
- * @rtype (data: String|Buffer, privateKey: Buffer) => Buffer
- * @param {String|Buffer} data - Data to sign
- * @param {String|Buffer} privateKey - Key to sign with
- * @return {Buffer|Uint8Array} Signature
- */
-export function sign (data, privateKey) {
-  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey))
-}
-
-/**
- * Verify that signature was signed by public key
- * @rtype (str: String, signature: Buffer, publicKey: Buffer) => Boolean
- * @param {String|Buffer} str - Data to verify
- * @param {Buffer} signature - Signature to verify
- * @param {Buffer} publicKey - Key to verify against
- * @return {Boolean} Valid?
- */
-export function verify (str, signature, publicKey) {
-  return nacl.sign.detached.verify(new Uint8Array(str), signature, publicKey)
-}
-
-export function messageToHash (message) {
-  const p = Buffer.from('aeternity Signed Message:\n', 'utf8')
-  const msg = Buffer.from(message, 'utf8')
-  if (msg.length >= 0xFD) throw new NotImplementedError('Message too long')
-  return hash(Buffer.concat([Buffer.from([p.length]), p, Buffer.from([msg.length]), msg]))
-}
-
-export function signMessage (message, privateKey) {
-  return sign(messageToHash(message), privateKey)
-}
-
-export function verifyMessage (str, signature, publicKey) {
-  return verify(messageToHash(str), signature, publicKey)
-}
-
-/**
- * Check key pair for validity
- *
- * Sign a message, and then verifying that signature
- * @rtype (privateKey: Buffer, publicKey: Buffer) => Boolean
- * @param {Buffer} privateKey - Private key to verify
- * @param {Buffer} publicKey - Public key to verify
- * @return {Boolean} Valid?
- */
-export function isValidKeypair (privateKey, publicKey) {
-  const message = Buffer.from('TheMessage')
-  const signature = sign(message, privateKey)
-  return verify(message, signature, publicKey)
-}

package/src/utils/hd-wallet.js

@@ -1,100 +0,0 @@
-import nacl from 'tweetnacl'
-import { full as hmac } from 'tweetnacl-auth'
-import { fromString } from 'bip32-path'
-import { decryptKey, encryptKey } from './crypto'
-import { encode } from '../tx/builder/helpers'
-import {
-  InvalidDerivationPathError, NotHardenedSegmentError, UnsupportedChildIndexError
-} from './errors'
-
-const ED25519_CURVE = Buffer.from('ed25519 seed')
-const HARDENED_OFFSET = 0x80000000
-
-const toHex = (buffer) => Buffer.from(buffer).toString('hex')
-
-export function derivePathFromKey (path, key) {
-  const segments = path === '' ? [] : fromString(path).toPathArray()
-  segments.forEach((segment, i) => {
-    if (segment < HARDENED_OFFSET) {
-      throw new NotHardenedSegmentError(`Segment #${i + 1} is not hardened`)
-    }
-  })
-
-  return segments.reduce((parentKey, segment) => deriveChild(parentKey, segment), key)
-}
-
-export function derivePathFromSeed (path, seed) {
-  if (!['m', 'm/'].includes(path.slice(0, 2))) {
-    throw new InvalidDerivationPathError()
-  }
-  const masterKey = getMasterKeyFromSeed(seed)
-  return derivePathFromKey(path.slice(2), masterKey)
-}
-
-function formatAccount (keys) {
-  const { secretKey, publicKey } = keys
-  return {
-    secretKey: toHex(secretKey),
-    publicKey: encode(publicKey, 'ak')
-  }
-}
-
-export function getKeyPair (secretKey) {
-  return nacl.sign.keyPair.fromSeed(secretKey)
-}
-
-export function getMasterKeyFromSeed (seed) {
-  const I = hmac(seed, ED25519_CURVE)
-  const IL = I.slice(0, 32)
-  const IR = I.slice(32)
-  return {
-    secretKey: IL,
-    chainCode: IR
-  }
-}
-
-export function deriveChild ({ secretKey, chainCode }, index) {
-  if (index < HARDENED_OFFSET) {
-    throw new UnsupportedChildIndexError(index)
-  }
-  const indexBuffer = Buffer.allocUnsafe(4)
-  indexBuffer.writeUInt32BE(index, 0)
-
-  const data = Buffer.concat([Buffer.alloc(1, 0), Buffer.from(secretKey), Buffer.from(indexBuffer)])
-
-  const I = hmac(data, chainCode)
-  const IL = I.slice(0, 32)
-  const IR = I.slice(32)
-  return {
-    secretKey: IL,
-    chainCode: IR
-  }
-}
-
-export function generateSaveHDWalletFromSeed (seed, password) {
-  const walletKey = derivePathFromSeed('m/44h/457h', seed)
-  return {
-    secretKey: toHex(encryptKey(password, walletKey.secretKey)),
-    chainCode: toHex(encryptKey(password, walletKey.chainCode))
-  }
-}
-
-export function getSaveHDWalletAccounts (saveHDWallet, password, accountCount) {
-  const walletKey = {
-    secretKey: decryptKey(password, Buffer.from(saveHDWallet.secretKey, 'hex')),
-    chainCode: decryptKey(password, Buffer.from(saveHDWallet.chainCode, 'hex'))
-  }
-  return (new Array(accountCount)).fill()
-    .map((_, idx) =>
-      formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)))
-}
-
-export const getHdWalletAccountFromSeed = (seed, accountIdx) => {
-  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.js

@@ -1,26 +0,0 @@
-import JsonBig from '@aeternity/json-bigint'
-import BigNumber from 'bignumber.js'
-
-const jsonBig = JsonBig({ storeAsString: true })
-
-const convertValuesToBigNumbers = value => {
-  if (typeof value === 'object' && value !== null && value.constructor === Object) {
-    return Object.entries(value)
-      .map(([key, value]) => [key, convertValuesToBigNumbers(value)])
-      .reduce((p, [k, v]) => ({ ...p, [k]: v }), {})
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => convertValuesToBigNumbers(item))
-  }
-  if (typeof value === 'string' && BigNumber(value).toString(10) === value) {
-    const bn = BigNumber(value)
-    bn.toJSON = () => bn.toString(10)
-    return bn
-  }
-  return value
-}
-
-export default {
-  stringify: (object, ...args) => jsonBig.stringify(convertValuesToBigNumbers(object), ...args),
-  parse: jsonBig.parse
-}

package/src/utils/keystore.js

@@ -1,219 +0,0 @@
-import nacl from 'tweetnacl'
-import { v4 as uuid } from '@aeternity/uuid'
-import { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js'
-import { encode } from '../tx/builder/helpers'
-import { str2buf } from './bytes'
-import {
-  ArgumentError, InvalidKeyError, UnsupportedAlgorithmError, InvalidPasswordError
-} from './errors'
-
-/**
- * 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
-    }
-  }
-}
-
-// 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 }
-}
-
-function encryptXsalsa20Poly1305 ({ plaintext, key, nonce }) {
-  return nacl.secretbox(plaintext, nonce, key)
-}
-
-function decryptXsalsa20Poly1305 ({ ciphertext, key, nonce }) {
-  const res = nacl.secretbox.open(ciphertext, nonce, key)
-  if (!res) throw new InvalidPasswordError('Invalid password or nonce')
-  return res
-}
-
-/**
- * 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.
- */
-function encrypt (plaintext, key, nonce, algo = DEFAULTS.crypto.symmetric_alg) {
-  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)
-  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.
- */
-function decrypt (ciphertext, key, nonce, algo) {
-  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)
-  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.
- */
-async function deriveKey (password, nonce, options = {
-  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)
-
-  if (!Object.prototype.hasOwnProperty.call(DERIVED_KEY_FUNCTIONS, options.kdf)) {
-    throw new UnsupportedAlgorithmError(options.kdf)
-  }
-
-  return DERIVED_KEY_FUNCTIONS[options.kdf](password, nonce, options)
-}
-
-/**
- * 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}
- */
-function marshal (name, derivedKey, privateKey, nonce, salt, options = {}) {
-  const opt = Object.assign({}, DEFAULTS.crypto, options)
-  return Object.assign(
-    { name, version: 1, public_key: getAddressFromPriv(privateKey), id: uuid() },
-    {
-      crypto: Object.assign(
-        {
-          secret_type: opt.secret_type,
-          symmetric_alg: opt.symmetric_alg,
-          ciphertext: Buffer.from(encrypt(Buffer.from(privateKey), derivedKey, nonce, opt.symmetric_alg)).toString('hex'),
-          cipher_params: { nonce: Buffer.from(nonce).toString('hex') }
-        },
-        { kdf: opt.kdf, kdf_params: { ...opt.kdf_params, salt: Buffer.from(salt).toString('hex') } }
-      )
-    }
-  )
-}
-
-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,
-  nonce = nacl.randomBytes(24),
-  salt = nacl.randomBytes(16),
-  options = {}
-) {
-  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
-}