@com-chain/jsc3l 2.0.1-rc.0

package/src/ethereum/cipher.ts

@@ -0,0 +1,118 @@
+import crypto from 'crypto'
+import { ec as EC } from 'elliptic'
+
+/// Code adapted from https://github.com/LimelabsTech/eth-ecies
+
+const ec = new EC('secp256k1')
+
+function AES256CbcEncrypt (iv, key, plaintext) {
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv)
+  const firstChunk = cipher.update(plaintext)
+  const secondChunk = cipher.final()
+
+  return Buffer.concat([firstChunk, secondChunk])
+}
+
+function AES256CbcDecrypt (iv, key, ciphertext) {
+  const cipher = crypto.createDecipheriv('aes-256-cbc', key, iv)
+  const firstChunk = cipher.update(ciphertext)
+  const secondChunk = cipher.final()
+
+  return Buffer.concat([firstChunk, secondChunk])
+}
+
+function BufferEqual (b1, b2) {
+  if (b1.length !== b2.length) {
+    return false
+  }
+
+  let res = 0
+  for (let i = 0; i < b1.length; i++) {
+    res |= b1[i] ^ b2[i]
+  }
+
+  return res === 0
+}
+
+function Encrypt (publicKey, plaintext) {
+  /* DEBUG */
+
+  const pubKeyTo = Buffer.from(publicKey)
+  const ephemPrivKey = ec.keyFromPrivate(crypto.randomBytes(32))
+  const ephemPubKey = ephemPrivKey.getPublic()
+  const ephemPubKeyEncoded = Buffer.from(ephemPubKey.encode())
+
+  // Every EC public key begins with the 0x04 prefix before giving
+  // the location of the two point on the curve
+  const concatenated = Buffer.concat([Buffer.from([0x04]), pubKeyTo])
+  const keys = ec.keyFromPublic(concatenated)
+  const pub = keys.getPublic()
+  const px = ephemPrivKey.derive(pub)
+  const hash = crypto.createHash('sha512')
+    .update(Buffer.from(px.toArray())).digest()
+  const iv = crypto.randomBytes(16)
+  const encryptionKey = hash.slice(0, 32)
+  const macKey = hash.slice(32)
+  const ciphertext = AES256CbcEncrypt(iv, encryptionKey, plaintext)
+  const dataToMac = Buffer.concat([iv, ephemPubKeyEncoded, ciphertext])
+  const mac = crypto.createHmac('sha256', macKey).update(dataToMac).digest()
+
+  const serializedCiphertext = Buffer.concat([
+    iv, // 16 bytes
+    ephemPubKeyEncoded, // 65 bytes
+    mac, // 32 bytes
+    ciphertext
+  ])
+
+  return serializedCiphertext.toString('hex')
+}
+
+function Decrypt (privateKey, encrypted) {
+  const encryptedBuff = Buffer.from(encrypted, 'hex')
+  const privateKeyBuff = Buffer.from(privateKey)
+
+  // Read iv, ephemPubKey, mac, ciphertext from encrypted message
+
+  const iv = encryptedBuff.slice(0, 16)
+  const ephemPubKeyEncoded = encryptedBuff.slice(16, 81)
+  const mac = encryptedBuff.slice(81, 113)
+  const ciphertext = encryptedBuff.slice(113)
+  const ephemPubKey = ec.keyFromPublic(ephemPubKeyEncoded).getPublic()
+
+  const px = ec.keyFromPrivate(privateKeyBuff).derive(ephemPubKey)
+  const hash = crypto.createHash('sha512')
+    .update(Buffer.from(px.toArray())).digest()
+  const encryptionKey = hash.slice(0, 32)
+  const macKey = hash.slice(32)
+  const dataToMac = Buffer.concat([iv, ephemPubKeyEncoded, ciphertext])
+  const computedMac = crypto.createHmac('sha256', macKey)
+    .update(dataToMac).digest()
+
+  // Verify mac
+  if (!BufferEqual(computedMac, mac)) {
+    throw new Error('MAC mismatch')
+  }
+
+  const plaintext = AES256CbcDecrypt(iv, encryptionKey, ciphertext)
+
+  return plaintext.toString()
+}
+
+
+export function shortenAddress (address) {
+  if (address.toLowerCase().substring(0, 2) === '0x') {
+    address = address.substr(2)
+  }
+  return address
+}
+
+export function cipherMsg (publicKey, message) {
+  const msgBuff = Buffer.from(message)
+  const key = Buffer.from(shortenAddress(publicKey), 'hex')
+  return Encrypt(key, msgBuff)
+}
+
+export function decipherMsg (privateKey, ciphered) {
+  const key = Buffer.from(shortenAddress(privateKey), 'hex')
+  return Decrypt(key, ciphered)
+}

package/src/ethereum/ethFuncs.ts

@@ -0,0 +1,73 @@
+import BigNumber from 'bignumber.js'
+import ethUtil from 'ethereumjs-util'
+
+import * as etherUnits from './etherUnits'
+
+function isChecksumAddress (address) {
+  return address === ethUtil.toChecksumAddress(address)
+}
+
+export function validateEtherAddress (address) {
+  if (address.substring(0, 2) !== '0x') return false
+  else if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) return false
+  else if (/^(0x)?[0-9a-f]{40}$/.test(address) ||
+           /^(0x)?[0-9A-F]{40}$/.test(address)) return true
+  else { return isChecksumAddress(address) }
+}
+
+export function validateHexString (str) {
+  if (str === '') return true
+  str = str.substring(0, 2) === '0x'
+    ? str.substring(2).toUpperCase()
+    : str.toUpperCase()
+  const re = /^[0-9A-F]+$/g
+  return re.test(str)
+}
+
+export function sanitizeHex (hex) {
+  hex = hex.substring(0, 2) === '0x' ? hex.substring(2) : hex
+  if (hex === '') return ''
+  return '0x' + padLeftEven(hex)
+}
+
+function padLeftEven (hex) {
+  hex = hex.length % 2 !== 0 ? '0' + hex : hex
+  return hex
+}
+
+export function addTinyMoreToGas (hex) {
+  hex = this.sanitizeHex(hex)
+  return new BigNumber(hex).plus(etherUnits.getValueOfUnit('gwei'))
+    .toDigits(2).toString(16)
+}
+
+export function decimalToHex (dec) {
+  return new BigNumber(dec).toString(16)
+}
+
+export function getNakedAddress (address) {
+  return address.toLowerCase().replace('0x', '')
+}
+
+export function padLeft (n, width, z?) {
+  z = z || '0'
+  n = n + ''
+  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n
+}
+
+export function getDataObj (to, func, arrVals) {
+  let val = ''
+  for (let i = 0; i < arrVals.length; i++) val += padLeft(arrVals[i], 64)
+  return { to: to, data: func + val }
+}
+
+export function encodeNumber (number) {
+  let valueHex
+  if (number < 0) {
+    valueHex = padLeft(new BigNumber(16).pow(64).plus(number).toString(16), 64)
+  } else {
+    valueHex = padLeft(new BigNumber(number).toString(16), 64)
+  }
+
+  return valueHex
+}

package/src/ethereum/etherUnits.ts

@@ -0,0 +1,66 @@
+import BigNumber from 'bignumber.js'
+
+const unitMap = {
+  wei: '1',
+  kwei: '1000',
+  ada: '1000',
+  femtoether: '1000',
+  mwei: '1000000',
+  babbage: '1000000',
+  picoether: '1000000',
+  gwei: '1000000000',
+  shannon: '1000000000',
+  nanoether: '1000000000',
+  nano: '1000000000',
+  szabo: '1000000000000',
+  microether: '1000000000000',
+  micro: '1000000000000',
+  finney: '1000000000000000',
+  milliether: '1000000000000000',
+  milli: '1000000000000000',
+  ether: '1000000000000000000',
+  kether: '1000000000000000000000',
+  grand: '1000000000000000000000',
+  einstein: '1000000000000000000000',
+  mether: '1000000000000000000000000',
+  gether: '1000000000000000000000000000',
+  tether: '1000000000000000000000000000000'
+}
+
+export function getValueOfUnit (unit) {
+  unit = unit ? unit.toLowerCase() : 'ether'
+  const unitValue = unitMap[unit]
+  if (unitValue === undefined) {
+    throw new Error(
+      "This unit doesn't exists, please use the " +
+        'one of the following units ' + JSON.stringify(unitMap, null, 2))
+  }
+  return new BigNumber(unitValue, 10)
+}
+
+export function fiatToWei (number, pricePerEther) {
+  return new BigNumber(String(number))
+    .div(pricePerEther)
+    .times(this.getValueOfUnit('ether'))
+    .round(0)
+    .toString(10)
+}
+
+export function toFiat (number, unit, multi) {
+  return new BigNumber(this.toEther(number, unit))
+    .times(multi)
+    .round(5)
+    .toString(10)
+}
+
+export function toEther (number, unit) {
+  return new BigNumber(this.toWei(number, unit))
+    .div(this.getValueOfUnit('ether'))
+    .toString(10)
+}
+
+export function toWei (number, unit) {
+  return new BigNumber(String(number))
+    .times(this.getValueOfUnit(unit))
+    .toString(10)
+}

package/src/ethereum/myetherwallet.ts

@@ -0,0 +1,354 @@
+import crypto from 'crypto'
+import { v4 as uuidv4 } from 'uuid'
+import ethUtil from 'ethereumjs-util'
+import scrypt from 'scryptsy'
+
+
+function decipherBuffer (decipher, data) {
+  return Buffer.concat([decipher.update(data), decipher.final()])
+}
+
+
+function decodeCryptojsSalt (input) {
+  const ciphertext = Buffer.from(input, 'base64')
+  if (ciphertext.slice(0, 8).toString() === 'Salted__') {
+    return {
+      salt: ciphertext.slice(8, 16),
+      ciphertext: ciphertext.slice(16)
+    }
+  } else {
+    return {
+      ciphertext: ciphertext
+    }
+  }
+}
+
+function evpKdf (data, salt, opts) {
+  // A single EVP iteration, returns `D_i`, where block equlas to `D_(i-1)`
+
+  function iter (block) {
+    let hash = crypto.createHash(opts.digest || 'md5')
+    hash.update(block)
+    hash.update(data)
+    hash.update(salt)
+    block = hash.digest()
+    for (let i = 1; i < (opts.count || 1); i++) {
+      hash = crypto.createHash(opts.digest || 'md5')
+      hash.update(block)
+      block = hash.digest()
+    }
+    return block
+  }
+  const keysize = opts.keysize || 16
+  const ivsize = opts.ivsize || 16
+  const ret = []
+  let i = 0
+  while (Buffer.concat(ret).length < (keysize + ivsize)) {
+    ret[i] = iter((i === 0) ? Buffer.alloc(0) : ret[i - 1])
+    i++
+  }
+  const tmp = Buffer.concat(ret)
+  return {
+    key: tmp.slice(0, keysize),
+    iv: tmp.slice(keysize, keysize + ivsize)
+  }
+}
+
+
+
+export default class Wallet {
+  privKey
+
+  constructor (priv?) {
+    if (!priv) {
+      priv = crypto.randomBytes(32)
+    }
+    this.privKey = priv.length === 32 ? priv : Buffer.from(priv, 'hex')
+  }
+
+  static generate (icapDirect) {
+    if (!icapDirect) {
+      return new this()
+    }
+
+    while (true) {
+      const privKey = crypto.randomBytes(32)
+      if (ethUtil.privateToAddress(privKey)[0] === 0) {
+        return new this(privKey)
+      }
+    }
+  }
+
+  static fromPrivateKey (priv) {
+    return new this(priv)
+  }
+
+  getPrivateKey () { return this.privKey }
+  getPrivateKeyString () { return this.getPrivateKey().toString('hex') }
+  getPublicKey () { return ethUtil.privateToPublic(this.privKey) }
+  getPublicKeyString () { return '0x' + this.getPublicKey().toString('hex') }
+  getAddress () { return ethUtil.privateToAddress(this.privKey) }
+  getAddressString () { return '0x' + this.getAddress().toString('hex') }
+  getChecksumAddressString () {
+    return ethUtil.toChecksumAddress(this.getAddressString())
+  }
+
+  toV3 (password, opts) {
+    opts = opts || {}
+    const salt = opts.salt || crypto.randomBytes(32)
+    const iv = opts.iv || crypto.randomBytes(16)
+    let derivedKey
+    const kdf = opts.kdf || 'scrypt'
+    const kdfparams: {[k: string]: any} = {
+      dklen: opts.dklen || 32,
+      salt: salt.toString('hex')
+    }
+    if (kdf === 'pbkdf2') {
+      kdfparams.c = opts.c || 262144
+      kdfparams.prf = 'hmac-sha256'
+      derivedKey = crypto.pbkdf2Sync(
+        Buffer.from(password), salt, kdfparams.c, kdfparams.dklen, 'sha256')
+    } else if (kdf === 'scrypt') {
+      // FIXME: support progress reporting callback
+      kdfparams.n = opts.n || 262144
+      kdfparams.r = opts.r || 8
+      kdfparams.p = opts.p || 1
+      derivedKey = scrypt(
+        Buffer.from(password), salt, kdfparams.n, kdfparams.r,
+        kdfparams.p, kdfparams.dklen)
+    } else {
+      throw new Error('Unsupported kdf')
+    }
+    const cipher = crypto.createCipheriv(opts.cipher || 'aes-128-ctr',
+      derivedKey.slice(0, 16), iv)
+    if (!cipher) {
+      throw new Error('Unsupported cipher')
+    }
+    const ciphertext = Buffer.concat(
+      [cipher.update(this.privKey), cipher.final()])
+    const mac = ethUtil.keccak(
+      Buffer.concat([derivedKey.slice(16, 32), ciphertext]))
+
+    const obj: {[k: string]: any} = {
+      version: 3,
+      id: uuidv4({
+        random: opts.uuid || crypto.randomBytes(16)
+      }),
+      address: this.getAddress().toString('hex'),
+      Crypto: {
+        ciphertext: ciphertext.toString('hex'),
+        cipherparams: {
+          iv: iv.toString('hex')
+        },
+        cipher: opts.cipher || 'aes-128-ctr',
+        kdf: kdf,
+        kdfparams: kdfparams,
+        mac: mac.toString('hex')
+      },
+      // ComChain addition:
+      server: { name: opts.server_name }
+    }
+
+    if (typeof opts.message_key !== 'undefined') {
+      obj.message_key = opts.message_key
+    }
+
+    return obj
+  }
+
+
+  cipher (password, data, kdfparams) {
+    if (!kdfparams) {
+      throw new Error(
+        'Wallet.cipher(..) requires a 3rd parameter kdfparams.'
+      )
+    }
+    const iv = crypto.randomBytes(16)
+    const derivedKey = scrypt(Buffer.from(password),
+      Buffer.from(kdfparams.salt, 'hex'),
+      kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen)
+
+    const cipher = crypto.createCipheriv(
+      'aes-128-ctr', derivedKey.slice(0, 16), iv)
+
+    const ciphertext = Buffer.concat([cipher.update(data), cipher.final()])
+    const mac = ethUtil.keccak(
+      Buffer.concat([derivedKey.slice(16, 32), ciphertext]))
+    return {
+      crypto: {
+        ciphertext: ciphertext.toString('hex'),
+        cipherparams: {
+          iv: iv.toString('hex')
+        },
+        cipher: 'aes-128-ctr',
+        kdf: 'scrypt',
+        kdfparams: kdfparams,
+        mac: mac.toString('hex')
+      }
+    }
+  }
+
+  decifer (input, password) {
+    const json = (typeof input === 'object')
+      ? input
+      : JSON.parse(input.toLowerCase())
+
+    const kdfparams = json.crypto.kdfparams
+    const derivedKey = scrypt(
+      Buffer.from(password),
+      Buffer.from(kdfparams.salt, 'hex'),
+      kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen)
+
+    const ciphertext = Buffer.from(json.crypto.ciphertext, 'hex')
+    const mac = ethUtil.keccak(
+      Buffer.concat([derivedKey.slice(16, 32), ciphertext]))
+    if (mac.toString('hex') !== json.crypto.mac) {
+      throw new Error('Key derivation failed - possibly wrong passphrase')
+    }
+    const decipher = crypto.createDecipheriv(
+      json.crypto.cipher, derivedKey.slice(0, 16),
+      Buffer.from(json.crypto.cipherparams.iv, 'hex'))
+    return decipherBuffer(decipher, ciphertext)
+  }
+
+  toJSON () {
+    return {
+      address: this.getAddressString(),
+      checksumAddress: this.getChecksumAddressString(),
+      privKey: this.getPrivateKeyString(),
+      pubKey: this.getPublicKeyString(),
+      publisher: 'MyEtherWallet',
+      encrypted: false,
+      version: 2
+    }
+  }
+
+  static fromMyEtherWallet (input, password) {
+    const json = (typeof input === 'object') ? input : JSON.parse(input)
+    let privKey
+    if (!json.locked) {
+      if (json.private.length !== 64) {
+        throw new Error('Invalid private key length')
+      }
+      privKey = Buffer.from(json.private, 'hex')
+    } else {
+      if (typeof password !== 'string') {
+        throw new Error('Password required')
+      }
+      if (password.length < 7) {
+        throw new Error('Password must be at least 7 characters')
+      }
+      let cipher = json.encrypted ? json.private.slice(0, 128) : json.private
+      cipher = decodeCryptojsSalt(cipher)
+      const evp = evpKdf(Buffer.from(password), cipher.salt, {
+        keysize: 32,
+        ivsize: 16
+      })
+      const decipher = crypto.createDecipheriv('aes-256-cbc', evp.key, evp.iv)
+      privKey = decipherBuffer(decipher, Buffer.from(cipher.ciphertext))
+      privKey = Buffer.from((privKey.toString()), 'hex')
+    }
+    const wallet = new this(privKey)
+    if (wallet.getAddressString() !== json.address) {
+      throw new Error('Invalid private key or address')
+    }
+    return wallet
+  }
+
+  static fromMyEtherWalletV2 (input) {
+    const json = (typeof input === 'object') ? input : JSON.parse(input)
+    if (json.privKey.length !== 64) {
+      throw new Error('Invalid private key length')
+    };
+    const privKey = Buffer.from(json.privKey, 'hex')
+    return new this(privKey)
+  }
+
+  static fromEthSale (input, password) {
+    const json = (typeof input === 'object') ? input : JSON.parse(input)
+    const encseed = Buffer.from(json.encseed, 'hex')
+    const derivedKey = crypto.pbkdf2Sync(
+      Buffer.from(password), Buffer.from(password), 2000, 32, 'sha256')
+      .slice(0, 16)
+    const decipher = crypto.createDecipheriv(
+      'aes-128-cbc', derivedKey, encseed.slice(0, 16))
+    const seed = decipherBuffer(decipher, encseed.slice(16))
+    const wallet = new this(ethUtil.keccak(seed))
+    if (wallet.getAddress().toString('hex') !== json.ethaddr) {
+      throw new Error('Decoded key mismatch - possibly wrong passphrase')
+    }
+    return wallet
+  }
+
+  static fromMyEtherWalletKey (input, password) {
+    let cipher = input.slice(0, 128)
+    cipher = decodeCryptojsSalt(cipher)
+    const evp = evpKdf(Buffer.from(password), cipher.salt, {
+      keysize: 32,
+      ivsize: 16
+    })
+    const decipher = crypto.createDecipheriv('aes-256-cbc', evp.key, evp.iv)
+    let privKey = decipherBuffer(decipher,
+      Buffer.from(cipher.ciphertext))
+    privKey = Buffer.from((privKey.toString()), 'hex')
+    return new this(privKey)
+  }
+
+  static fromV3 (input, password, nonStrict) {
+    const json = (typeof input === 'object')
+      ? input
+      : JSON.parse(nonStrict ? input.toLowerCase() : input)
+    if (json.version !== 3) {
+      throw new Error('Not a V3 wallet')
+    }
+    let derivedKey
+    let kdfparams
+    if (json.crypto.kdf === 'scrypt') {
+      kdfparams = json.crypto.kdfparams
+      derivedKey = scrypt(
+        Buffer.from(password),
+        Buffer.from(kdfparams.salt, 'hex'),
+        kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen)
+    } else if (json.crypto.kdf === 'pbkdf2') {
+      kdfparams = json.crypto.kdfparams
+      if (kdfparams.prf !== 'hmac-sha256') {
+        throw new Error('Unsupported parameters to PBKDF2')
+      }
+      derivedKey = crypto.pbkdf2Sync(
+        Buffer.from(password),
+        Buffer.from(kdfparams.salt, 'hex'),
+        kdfparams.c, kdfparams.dklen, 'sha256')
+    } else {
+      throw new Error('Unsupported key derivation scheme')
+    }
+    const ciphertext = Buffer.from(json.crypto.ciphertext, 'hex')
+    const mac = ethUtil.keccak(Buffer.concat(
+      [derivedKey.slice(16, 32), ciphertext]))
+    if (mac.toString('hex') !== json.crypto.mac) {
+      throw new Error('Key derivation failed - possibly wrong passphrase')
+    }
+    const decipher = crypto.createDecipheriv(
+      json.crypto.cipher, derivedKey.slice(0, 16),
+      Buffer.from(json.crypto.cipherparams.iv, 'hex'))
+    const seed = decipherBuffer(decipher, ciphertext)
+    return new this(seed)
+  }
+
+  toV3String (password, opts) {
+    return JSON.stringify(this.toV3(password, opts))
+  }
+
+  getV3Filename (timestamp) {
+    const ts = timestamp ? new Date(timestamp) : new Date()
+    return `UTC--${ts.toJSON().replace(/:/g, '-')}--${this.getAddress().toString('hex')}`
+  }
+
+  signMessage (msg) {
+    const msgHash = ethUtil.hashPersonalMessage(ethUtil.toBuffer(msg))
+    const signature = ethUtil.ecsign(msgHash, this.privKey)
+    return ethUtil.bufferToHex(
+      Buffer.concat([signature.r, signature.s, ethUtil.toBuffer(signature.v)]))
+  }
+
+
+}

package/src/ethereum/uiFuncs.ts

@@ -0,0 +1,55 @@
+import Tx from 'ethereumjs-tx'
+import * as ethFuncs from './ethFuncs'
+import * as etherUnits from './etherUnits'
+
+
+function isNumeric (n) {
+  return !isNaN(parseFloat(n)) && isFinite(n)
+}
+
+function isTxDataValid (txData) {
+  if (txData.to !== '0xCONTRACT' &&
+      !ethFuncs.validateEtherAddress(txData.to)) {
+    throw new Error('ERROR_6')
+  } else if (!isNumeric(txData.value) ||
+             parseFloat(txData.value) < 0) {
+    throw new Error('ERROR_8')
+  } else if (!isNumeric(txData.gasLimit) ||
+             parseFloat(txData.gasLimit) <= 0) {
+    throw new Error('ERROR_9')
+  } else if (!ethFuncs.validateHexString(txData.data)) {
+    throw new Error('ERROR_10')
+  }
+  if (txData.to === '0xCONTRACT') txData.to = ''
+}
+
+export function generateTx (txData, data) {
+  try {
+    isTxDataValid(txData)
+
+    const rawTx: {[k: string]: any} = {
+      nonce: ethFuncs.sanitizeHex(data.nonce),
+      gasPrice: ethFuncs.sanitizeHex(
+        ethFuncs.addTinyMoreToGas(data.gasprice)),
+      gasLimit: ethFuncs.sanitizeHex(
+        ethFuncs.decimalToHex(txData.gasLimit)),
+      to: ethFuncs.sanitizeHex(txData.to),
+      value: ethFuncs.sanitizeHex(
+        ethFuncs.decimalToHex(etherUnits.toWei(txData.value, txData.unit))),
+      data: ethFuncs.sanitizeHex(txData.data)
+    }
+    const eTx = new Tx(rawTx)
+
+    eTx.sign(Buffer.from(txData.key, 'hex'))
+    rawTx.rawTx = JSON.stringify(rawTx)
+    rawTx.signedTx = '0x' + eTx.serialize().toString('hex')
+    rawTx.isError = false
+    return rawTx
+  } catch (e) {
+    return {
+      isError: true,
+      error: e
+    }
+  }
+}
+