1 files changed, 54 insertions, 50 deletions

diff --git a/app/scripts/keyrings/hd.js b/app/scripts/keyrings/hd.js
index 4bfc56c15..1b9796e07 100644
--- a/app/scripts/keyrings/hd.js
+++ b/app/scripts/keyrings/hd.js
@@ -2,106 +2,110 @@ const EventEmitter = require('events').EventEmitter
 const hdkey = require('ethereumjs-wallet/hdkey')
 const bip39 = require('bip39')
 const ethUtil = require('ethereumjs-util')
-const type = 'HD Key Tree'
+
+// *Internal Deps
 const sigUtil = require('../lib/sig-util')
 
+// Options:
 const hdPathString = `m/44'/60'/0'/0`
+const type = 'HD Key Tree'
 
-module.exports = class HdKeyring extends EventEmitter {
+class HdKeyring extends EventEmitter {
 
-  static type() {
-    return type
-  }
+  /* PUBLIC METHODS */
 
-  constructor(opts = {}) {
+  constructor (opts = {}) {
     super()
     this.type = type
     this.deserialize(opts)
   }
 
-  deserialize(opts = {}) {
+  serialize () {
+    return Promise.resolve({
+      mnemonic: this.mnemonic,
+      numberOfAccounts: this.wallets.length,
+    })
+  }
+
+  deserialize (opts = {}) {
     this.opts = opts || {}
     this.wallets = []
     this.mnemonic = null
     this.root = null
 
-    if ('mnemonic' in opts) {
-      this.initFromMnemonic(opts.mnemonic)
+    if (opts.mnemonic) {
+      this._initFromMnemonic(opts.mnemonic)
     }
 
-    if ('n' in opts) {
-      this.addAccounts(opts.n)
-    }
-  }
-
-  initFromMnemonic(mnemonic) {
-    this.mnemonic = mnemonic
-    const seed = bip39.mnemonicToSeed(mnemonic)
-    this.hdWallet = hdkey.fromMasterSeed(seed)
-    this.root = this.hdWallet.derivePath(hdPathString)
-  }
-
-  serialize() {
-    return {
-      mnemonic: this.mnemonic,
-      n: this.wallets.length,
+    if (opts.numberOfAccounts) {
+      return this.addAccounts(opts.numberOfAccounts)
     }
-  }
 
-  exportAccount(address) {
-    const wallet = this.getWalletForAccount(address)
-    return wallet.getPrivateKey().toString('hex')
+    return Promise.resolve([])
   }
 
-  addAccounts(n = 1) {
+  addAccounts (numberOfAccounts = 1) {
     if (!this.root) {
-      this.initFromMnemonic(bip39.generateMnemonic())
+      this._initFromMnemonic(bip39.generateMnemonic())
     }
 
     const oldLen = this.wallets.length
     const newWallets = []
-    for (let i = oldLen; i < n + oldLen; i++) {
+    for (let i = oldLen; i < numberOfAccounts + oldLen; i++) {
       const child = this.root.deriveChild(i)
       const wallet = child.getWallet()
       newWallets.push(wallet)
       this.wallets.push(wallet)
     }
-    return newWallets.map(w => w.getAddress().toString('hex'))
+    const hexWallets = newWallets.map(w => w.getAddress().toString('hex'))
+    return Promise.resolve(hexWallets)
   }
 
-  getAccounts() {
-    return this.wallets.map(w => w.getAddress().toString('hex'))
+  getAccounts () {
+    return Promise.resolve(this.wallets.map(w => w.getAddress().toString('hex')))
   }
 
   // tx is an instance of the ethereumjs-transaction class.
-  signTransaction(address, tx) {
-    const wallet = this.getWalletForAccount(address)
+  signTransaction (address, tx) {
+    const wallet = this._getWalletForAccount(address)
     var privKey = wallet.getPrivateKey()
     tx.sign(privKey)
-    return tx
+    return Promise.resolve(tx)
   }
 
   // For eth_sign, we need to sign transactions:
-  signMessage(withAccount, data) {
-    const wallet = this.getWalletForAccount(withAccount)
-    const message = ethUtil.removeHexPrefix(data)
+  signMessage (withAccount, data) {
+    const wallet = this._getWalletForAccount(withAccount)
+    const message = ethUtil.stripHexPrefix(data)
     var privKey = wallet.getPrivateKey()
     var msgSig = ethUtil.ecsign(new Buffer(message, 'hex'), privKey)
     var rawMsgSig = ethUtil.bufferToHex(sigUtil.concatSig(msgSig.v, msgSig.r, msgSig.s))
-    return rawMsgSig
+    return Promise.resolve(rawMsgSig)
   }
 
-  getWalletForAccount(account) {
-    return this.wallets.find((w) => {
-      const address = w.getAddress().toString('hex')
-      return ((address === account) || (normalize(address) === account))
-    })
+  exportAccount (address) {
+    const wallet = this._getWalletForAccount(address)
+    return Promise.resolve(wallet.getPrivateKey().toString('hex'))
   }
 
 
+  /* PRIVATE METHODS */
 
-}
+  _initFromMnemonic (mnemonic) {
+    this.mnemonic = mnemonic
+    const seed = bip39.mnemonicToSeed(mnemonic)
+    this.hdWallet = hdkey.fromMasterSeed(seed)
+    this.root = this.hdWallet.derivePath(hdPathString)
+  }
 
-function normalize(address) {
-  return ethUtil.addHexPrefix(address.toLowerCase())
+
+  _getWalletForAccount (account) {
+    return this.wallets.find((w) => {
+      const address = w.getAddress().toString('hex')
+      return ((address === account) || (sigUtil.normalize(address) === account))
+    })
+  }
 }
+
+HdKeyring.type = type
+module.exports = HdKeyring