1 files changed, 567 insertions, 0 deletions
diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
new file mode 100644
index 000000000..10d686e23
--- /dev/null
+++ b/app/scripts/keyring-controller.js
@@ -0,0 +1,567 @@
+const async = require('async')
+const ethUtil = require('ethereumjs-util')
+const ethBinToOps = require('eth-bin-to-ops')
+const EthQuery = require('eth-query')
+const bip39 = require('bip39')
+const Transaction = require('ethereumjs-tx')
+const EventEmitter = require('events').EventEmitter
+
+const normalize = require('./lib/sig-util').normalize
+const encryptor = require('./lib/encryptor')
+const messageManager = require('./lib/message-manager')
+const autoFaucet = require('./lib/auto-faucet')
+const IdStoreMigrator = require('./lib/idStore-migrator')
+const BN = ethUtil.BN
+
+// Keyrings:
+const SimpleKeyring = require('./keyrings/simple')
+const HdKeyring = require('./keyrings/hd')
+const keyringTypes = [
+  SimpleKeyring,
+  HdKeyring,
+]
+
+const createId = require('./lib/random-id')
+
+module.exports = class KeyringController extends EventEmitter {
+
+  constructor (opts) {
+    super()
+    this.configManager = opts.configManager
+    this.ethStore = opts.ethStore
+    this.encryptor = encryptor
+    this.keyringTypes = keyringTypes
+
+    this.keyrings = []
+    this.identities = {} // Essentially a name hash
+
+    this._unconfTxCbs = {}
+    this._unconfMsgCbs = {}
+
+    this.getNetwork = opts.getNetwork
+
+    // TEMPORARY UNTIL FULL DEPRECATION:
+    this.idStoreMigrator = new IdStoreMigrator({
+      configManager: this.configManager,
+    })
+  }
+
+  getState () {
+    const configManager = this.configManager
+    const address = configManager.getSelectedAccount()
+    const wallet = configManager.getWallet() // old style vault
+    const vault = configManager.getVault() // new style vault
+
+    return {
+      seedWords: this.configManager.getSeedWords(),
+      isInitialized: (!!wallet || !!vault),
+      isUnlocked: !!this.key,
+      isDisclaimerConfirmed: this.configManager.getConfirmedDisclaimer(), // AUDIT this.configManager.getConfirmedDisclaimer(),
+      unconfTxs: this.configManager.unconfirmedTxs(),
+      transactions: this.configManager.getTxList(),
+      unconfMsgs: messageManager.unconfirmedMsgs(),
+      messages: messageManager.getMsgList(),
+      selectedAddress: address,
+      selectedAccount: address,
+      shapeShiftTxList: this.configManager.getShapeShiftTxList(),
+      currentFiat: this.configManager.getCurrentFiat(),
+      conversionRate: this.configManager.getConversionRate(),
+      conversionDate: this.configManager.getConversionDate(),
+      keyringTypes: this.keyringTypes.map((krt) => krt.type()),
+      identities: this.identities,
+    }
+  }
+
+  setStore (ethStore) {
+    this.ethStore = ethStore
+  }
+
+  createNewVaultAndKeychain (password, entropy, cb) {
+    this.createNewVault(password, entropy, (err) => {
+      if (err) return cb(err)
+      this.createFirstKeyTree(password, cb)
+    })
+  }
+
+  createNewVaultAndRestore (password, seed, cb) {
+    if (typeof password !== 'string') {
+      return cb('Password must be text.')
+    }
+
+    if (!bip39.validateMnemonic(seed)) {
+      return cb('Seed phrase is invalid.')
+    }
+
+    this.clearKeyrings()
+
+    this.createNewVault(password, '', (err) => {
+      if (err) return cb(err)
+      this.addNewKeyring('HD Key Tree', {
+        mnemonic: seed,
+        numberOfAccounts: 1,
+      }, (err) => {
+        if (err) return cb(err)
+        const firstKeyring = this.keyrings[0]
+        const accounts = firstKeyring.getAccounts()
+        const firstAccount = accounts[0]
+        const hexAccount = normalize(firstAccount)
+        this.configManager.setSelectedAccount(hexAccount)
+        this.setupAccounts(accounts)
+
+        this.emit('update')
+        cb()
+      })
+    })
+  }
+
+  migrateAndGetKey (password) {
+    let key
+    const shouldMigrate = !!this.configManager.getWallet() && !this.configManager.getVault()
+
+    return this.loadKey(password)
+    .then((derivedKey) => {
+      key = derivedKey
+      this.key = key
+      return this.idStoreMigrator.oldSeedForPassword(password)
+    })
+    .then((serialized) => {
+      if (serialized && shouldMigrate) {
+        const keyring = this.restoreKeyring(serialized)
+        this.keyrings.push(keyring)
+        this.configManager.setSelectedAccount(keyring.getAccounts()[0])
+      }
+      return key
+    })
+  }
+
+  createNewVault (password, entropy, cb) {
+    const configManager = this.configManager
+    const salt = this.encryptor.generateSalt()
+    configManager.setSalt(salt)
+
+    return this.migrateAndGetKey(password)
+    .then(() => {
+      return this.persistAllKeyrings()
+    })
+    .then(() => {
+      cb()
+    })
+    .catch((err) => {
+      cb(err)
+    })
+  }
+
+  createFirstKeyTree (password, cb) {
+    this.clearKeyrings()
+    this.addNewKeyring('HD Key Tree', {numberOfAccounts: 1}, (err) => {
+      const accounts = this.keyrings[0].getAccounts()
+      const firstAccount = accounts[0]
+      const hexAccount = normalize(firstAccount)
+      this.configManager.setSelectedAccount(firstAccount)
+
+      this.placeSeedWords()
+      autoFaucet(hexAccount)
+      this.setupAccounts(accounts)
+      this.persistAllKeyrings()
+      .then(() => {
+        cb(err)
+      })
+      .catch((reason) => {
+        cb(reason)
+      })
+    })
+  }
+
+  placeSeedWords () {
+    const firstKeyring = this.keyrings[0]
+    const seedWords = firstKeyring.serialize().mnemonic
+    this.configManager.setSeedWords(seedWords)
+  }
+
+  submitPassword (password, cb) {
+    this.migrateAndGetKey(password)
+    .then((key) => {
+      return this.unlockKeyrings(key)
+    })
+    .then((keyrings) => {
+      this.keyrings = keyrings
+      this.setupAccounts()
+      this.emit('update')
+      cb(null, this.getState())
+    })
+    .catch((err) => {
+      console.error(err)
+      cb(err)
+    })
+  }
+
+  loadKey (password) {
+    const salt = this.configManager.getSalt() || this.encryptor.generateSalt()
+    return this.encryptor.keyFromPassword(password + salt)
+    .then((key) => {
+      this.key = key
+      this.configManager.setSalt(salt)
+      return key
+    })
+  }
+
+  addNewKeyring (type, opts, cb) {
+    const Keyring = this.getKeyringClassForType(type)
+    const keyring = new Keyring(opts)
+    const accounts = keyring.getAccounts()
+
+    this.keyrings.push(keyring)
+    this.setupAccounts(accounts)
+    this.persistAllKeyrings()
+    .then(() => {
+      cb()
+    })
+    .catch((reason) => {
+      cb(reason)
+    })
+  }
+
+  addNewAccount (keyRingNum = 0, cb) {
+    const ring = this.keyrings[keyRingNum]
+    const accounts = ring.addAccounts(1)
+    this.setupAccounts(accounts)
+    this.persistAllKeyrings()
+    .then(() => {
+      cb()
+    })
+    .catch((reason) => {
+      cb(reason)
+    })
+  }
+
+  setupAccounts (accounts) {
+    var arr = accounts || this.getAccounts()
+    arr.forEach((account) => {
+      this.getBalanceAndNickname(account)
+    })
+  }
+
+  // Takes an account address and an iterator representing
+  // the current number of named accounts.
+  getBalanceAndNickname (account) {
+    const address = normalize(account)
+    this.ethStore.addAccount(address)
+    this.createNickname(address)
+  }
+
+  createNickname (address) {
+    const hexAddress = normalize(address)
+    var i = Object.keys(this.identities).length
+    const oldNickname = this.configManager.nicknameForWallet(address)
+    const name = oldNickname || `Account ${++i}`
+    this.identities[hexAddress] = {
+      address: hexAddress,
+      name,
+    }
+    return this.saveAccountLabel(hexAddress, name)
+  }
+
+  saveAccountLabel (account, label, cb) {
+    const address = normalize(account)
+    const configManager = this.configManager
+    configManager.setNicknameForWallet(address, label)
+    this.identities[address].name = label
+    if (cb) {
+      cb(null, label)
+    } else {
+      return label
+    }
+  }
+
+  persistAllKeyrings () {
+    const serialized = this.keyrings.map((k) => {
+      return {
+        type: k.type,
+        data: k.serialize(),
+      }
+    })
+
+    return this.encryptor.encryptWithKey(this.key, serialized)
+    .then((encryptedString) => {
+      this.configManager.setVault(encryptedString)
+      return true
+    })
+  }
+
+  unlockKeyrings (key) {
+    const encryptedVault = this.configManager.getVault()
+    return this.encryptor.decryptWithKey(key, encryptedVault)
+    .then((vault) => {
+      vault.forEach(this.restoreKeyring.bind(this))
+      return this.keyrings
+    })
+  }
+
+  restoreKeyring (serialized) {
+    const { type, data } = serialized
+    const Keyring = this.getKeyringClassForType(type)
+    const keyring = new Keyring()
+    keyring.deserialize(data)
+
+    const accounts = keyring.getAccounts()
+    this.setupAccounts(accounts)
+
+    this.keyrings.push(keyring)
+    return keyring
+  }
+
+  getKeyringClassForType (type) {
+    const Keyring = this.keyringTypes.reduce((res, kr) => {
+      if (kr.type() === type) {
+        return kr
+      } else {
+        return res
+      }
+    })
+    return Keyring
+  }
+
+  getAccounts () {
+    const keyrings = this.keyrings || []
+    return keyrings.map(kr => kr.getAccounts())
+    .reduce((res, arr) => {
+      return res.concat(arr)
+    }, [])
+  }
+
+  setSelectedAddress (address, cb) {
+    var addr = normalize(address)
+    this.configManager.setSelectedAccount(addr)
+    cb(null, addr)
+  }
+
+  addUnconfirmedTransaction (txParams, onTxDoneCb, cb) {
+    var self = this
+    const configManager = this.configManager
+
+    // create txData obj with parameters and meta data
+    var time = (new Date()).getTime()
+    var txId = createId()
+    txParams.metamaskId = txId
+    txParams.metamaskNetworkId = this.getNetwork()
+    var txData = {
+      id: txId,
+      txParams: txParams,
+      time: time,
+      status: 'unconfirmed',
+      gasMultiplier: configManager.getGasMultiplier() || 1,
+      metamaskNetworkId: this.getNetwork(),
+    }
+
+
+    // keep the onTxDoneCb around for after approval/denial (requires user interaction)
+    // This onTxDoneCb fires completion to the Dapp's write operation.
+    this._unconfTxCbs[txId] = onTxDoneCb
+
+    var provider = this.ethStore._query.currentProvider
+    var query = new EthQuery(provider)
+
+    // calculate metadata for tx
+    async.parallel([
+      analyzeForDelegateCall,
+      estimateGas,
+    ], didComplete)
+
+    // perform static analyis on the target contract code
+    function analyzeForDelegateCall (cb) {
+      if (txParams.to) {
+        query.getCode(txParams.to, function (err, result) {
+          if (err) return cb(err)
+          var code = ethUtil.toBuffer(result)
+          if (code !== '0x') {
+            var ops = ethBinToOps(code)
+            var containsDelegateCall = ops.some((op) => op.name === 'DELEGATECALL')
+            txData.containsDelegateCall = containsDelegateCall
+            cb()
+          } else {
+            cb()
+          }
+        })
+      } else {
+        cb()
+      }
+    }
+
+    function estimateGas (cb) {
+      query.estimateGas(txParams, function (err, result) {
+        if (err) return cb(err)
+        txData.estimatedGas = self.addGasBuffer(result)
+        cb()
+      })
+    }
+
+    function didComplete (err) {
+      if (err) return cb(err)
+      configManager.addTx(txData)
+      // signal update
+      self.emit('update')
+      // signal completion of add tx
+      cb(null, txData)
+    }
+  }
+
+  addUnconfirmedMessage (msgParams, cb) {
+    // create txData obj with parameters and meta data
+    var time = (new Date()).getTime()
+    var msgId = createId()
+    var msgData = {
+      id: msgId,
+      msgParams: msgParams,
+      time: time,
+      status: 'unconfirmed',
+    }
+    messageManager.addMsg(msgData)
+    console.log('addUnconfirmedMessage:', msgData)
+
+    // keep the cb around for after approval (requires user interaction)
+    // This cb fires completion to the Dapp's write operation.
+    this._unconfMsgCbs[msgId] = cb
+
+    // signal update
+    this.emit('update')
+    return msgId
+  }
+
+  approveTransaction (txId, cb) {
+    const configManager = this.configManager
+    var approvalCb = this._unconfTxCbs[txId] || noop
+
+    // accept tx
+    cb()
+    approvalCb(null, true)
+    // clean up
+    configManager.confirmTx(txId)
+    delete this._unconfTxCbs[txId]
+    this.emit('update')
+  }
+
+  cancelTransaction (txId, cb) {
+    const configManager = this.configManager
+    var approvalCb = this._unconfTxCbs[txId] || noop
+
+    // reject tx
+    approvalCb(null, false)
+    // clean up
+    configManager.rejectTx(txId)
+    delete this._unconfTxCbs[txId]
+
+    if (cb && typeof cb === 'function') {
+      cb()
+    }
+  }
+
+  signTransaction (txParams, cb) {
+    try {
+      const address = normalize(txParams.from)
+      const keyring = this.getKeyringForAccount(address)
+
+      // Handle gas pricing
+      var gasMultiplier = this.configManager.getGasMultiplier() || 1
+      var gasPrice = new BN(ethUtil.stripHexPrefix(txParams.gasPrice), 16)
+      gasPrice = gasPrice.mul(new BN(gasMultiplier * 100, 10)).div(new BN(100, 10))
+      txParams.gasPrice = ethUtil.intToHex(gasPrice.toNumber())
+
+      // normalize values
+      txParams.to = normalize(txParams.to)
+      txParams.from = normalize(txParams.from)
+      txParams.value = normalize(txParams.value)
+      txParams.data = normalize(txParams.data)
+      txParams.gasLimit = normalize(txParams.gasLimit || txParams.gas)
+      txParams.nonce = normalize(txParams.nonce)
+
+      let tx = new Transaction(txParams)
+      tx = keyring.signTransaction(address, tx)
+
+      // Add the tx hash to the persisted meta-tx object
+      var txHash = ethUtil.bufferToHex(tx.hash())
+      var metaTx = this.configManager.getTx(txParams.metamaskId)
+      metaTx.hash = txHash
+      this.configManager.updateTx(metaTx)
+
+      // return raw serialized tx
+      var rawTx = ethUtil.bufferToHex(tx.serialize())
+      cb(null, rawTx)
+    } catch (e) {
+      cb(e)
+    }
+  }
+
+  signMessage (msgParams, cb) {
+    try {
+      const keyring = this.getKeyringForAccount(msgParams.from)
+      const address = normalize(msgParams.from)
+      const rawSig = keyring.signMessage(address, msgParams.data)
+      cb(null, rawSig)
+    } catch (e) {
+      cb(e)
+    }
+  }
+
+  getKeyringForAccount (address) {
+    const hexed = normalize(address)
+    return this.keyrings.find((ring) => {
+      return ring.getAccounts()
+      .map(normalize)
+      .includes(hexed)
+    })
+  }
+
+  cancelMessage (msgId, cb) {
+    if (cb && typeof cb === 'function') {
+      cb()
+    }
+  }
+
+  setLocked (cb) {
+    this.key = null
+    this.keyrings = []
+    this.emit('update')
+    cb()
+  }
+
+  exportAccount (address, cb) {
+    try {
+      const keyring = this.getKeyringForAccount(address)
+      const privateKey = keyring.exportAccount(normalize(address))
+      cb(null, privateKey)
+    } catch (e) {
+      cb(e)
+    }
+  }
+
+  addGasBuffer (gas) {
+    const gasBuffer = new BN('100000', 10)
+    const bnGas = new BN(ethUtil.stripHexPrefix(gas), 16)
+    const correct = bnGas.add(gasBuffer)
+    return ethUtil.addHexPrefix(correct.toString(16))
+  }
+
+  clearSeedWordCache (cb) {
+    this.configManager.setSeedWords(null)
+    cb(null, this.configManager.getSelectedAccount())
+  }
+
+  clearKeyrings () {
+    let accounts
+    try {
+      accounts = Object.keys(this.ethStore._currentState.accounts)
+    } catch (e) {
+      accounts = []
+    }
+    accounts.forEach((address) => {
+      this.ethStore.removeAccount(address)
+    })
+
+    this.keyrings = []
+    this.identities = {}
+    this.configManager.setSelectedAccount()
+  }
+
+}
+
+function noop () {}