From 55d56f77cf42a9c4e80768fd7e4a9bb6f0485606 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Thu, 20 Oct 2016 16:44:31 -0700
Subject: Began adding first basic keyring

---
 app/scripts/keyring-controller.js  | 111 ++++++++++++++++++++++++++++++++++---
 app/scripts/keyrings/simple.js     |  41 ++++++++++++++
 app/scripts/lib/idStore.js         |   1 -
 app/scripts/metamask-controller.js |   2 +
 4 files changed, 146 insertions(+), 9 deletions(-)
 create mode 100644 app/scripts/keyrings/simple.js

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index d25dddba1..86d61b22b 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -1,7 +1,13 @@
 const EventEmitter = require('events').EventEmitter
 const encryptor = require('./lib/encryptor')
 const messageManager = require('./lib/message-manager')
+const ethUtil = require('ethereumjs-util')
 
+// Keyrings:
+const SimpleKeyring = require('./keyrings/simple')
+const keyringTypes = [
+  SimpleKeyring,
+]
 
 module.exports = class KeyringController extends EventEmitter {
 
@@ -9,14 +15,15 @@ module.exports = class KeyringController extends EventEmitter {
     super()
     this.configManager = opts.configManager
     this.ethStore = opts.ethStore
-    this.keyChains = []
+    this.keyrings = []
+    this.identities = {} // Essentially a nickname hash
   }
 
   getState() {
     return {
       isInitialized: !!this.configManager.getVault(),
       isUnlocked: !!this.key,
-      isConfirmed: true, // this.configManager.getConfirmed(),
+      isConfirmed: true, // AUDIT this.configManager.getConfirmed(),
       isEthConfirmed: this.configManager.getShouldntShowWarning(),
       unconfTxs: this.configManager.unconfirmedTxs(),
       transactions: this.configManager.getTxList(),
@@ -27,6 +34,8 @@ module.exports = class KeyringController extends EventEmitter {
       currentFiat: this.configManager.getCurrentFiat(),
       conversionRate: this.configManager.getConversionRate(),
       conversionDate: this.configManager.getConversionDate(),
+      keyringTypes: keyringTypes.map((krt) => krt.type()),
+      identities: this.identities,
     }
   }
 
@@ -39,7 +48,7 @@ module.exports = class KeyringController extends EventEmitter {
     this.configManager.setSalt(salt)
     this.loadKey(password)
     .then((key) => {
-      return encryptor.encryptWithKey(key, {})
+      return encryptor.encryptWithKey(key, [])
     })
     .then((encryptedString) => {
       this.configManager.setVault(encryptedString)
@@ -53,6 +62,10 @@ module.exports = class KeyringController extends EventEmitter {
   submitPassword(password, cb) {
     this.loadKey(password)
     .then((key) => {
+      return this.unlockKeyrings(key)
+    })
+    .then((keyrings) => {
+      this.keyrings = keyrings
       cb(null, this.getState())
     })
     .catch((err) => {
@@ -69,8 +82,94 @@ module.exports = class KeyringController extends EventEmitter {
     })
   }
 
+  addNewKeyring(type, opts, cb) {
+    const i = this.getAccounts().length
+    const Keyring = this.getKeyringClassForType(type)
+    const keyring = new Keyring(opts)
+    const accounts = keyring.addAccounts(1)
+
+    accounts.forEach((account) => {
+      this.createBalanceAndNickname(account, i)
+    })
+
+    this.persistAllKeyrings()
+    .then(() => {
+      cb(this.getState())
+    })
+    .catch((reason) => {
+      cb(reason)
+    })
+  }
+
+  // Takes an account address and an iterator representing
+  // the current number of nicknamed accounts.
+  createBalanceAndNickname(account, i) {
+    this.ethStore.addAccount(ethUtil.addHexPrefix(account))
+    const oldNickname = this.configManager.nicknameForWallet(account)
+    const nickname = oldNickname || `Account ${++i}`
+    this.identities[account] = {
+      address: account,
+      nickname,
+    }
+    this.saveAccountLabel(account, nickname)
+  }
+
+  saveAccountLabel (account, label, cb) {
+    const configManager = this.configManager
+    configManager.setNicknameForWallet(account, label)
+    if (cb) {
+      cb(null, label)
+    }
+  }
+
+  persistAllKeyrings() {
+    const serialized = this.keyrings.map(k => k.serialize())
+    return encryptor.encryptWithKey(this.key, serialized)
+    .then((encryptedString) => {
+      this.configManager.setVault(encryptedString)
+      return true
+    })
+    .catch((reason) => {
+      console.error('Failed to persist keyrings.', reason)
+    })
+  }
+
+  unlockKeyrings(key) {
+    const encryptedVault = this.configManager.getVault()
+    return encryptor.decryptWithKey(key, encryptedVault)
+    .then((vault) => {
+      this.keyrings = vault.map(this.restoreKeyring)
+      return this.keyrings
+    })
+  }
+
+  restoreKeyring(serialized) {
+    const { type } = serialized
+    const Keyring = this.getKeyringClassForType(type)
+    const keyring = new Keyring(serialized)
+    return keyring
+  }
+
+  getKeyringClassForType(type) {
+    const Keyring = keyringTypes.reduce((res, kr) => {
+      if (kr.type() === type) {
+        return kr
+      } else {
+        return res
+      }
+    })
+    return Keyring
+  }
+
+  getAccounts() {
+    return this.keyrings.map(kr => kr.getAccounts())
+    .reduce((res, arr) => {
+      return res.concat(arr)
+    }, [])
+  }
+
   setSelectedAddress(address, cb) {
-    this.selectedAddress = address
+    this.configManager.setSelectedAccount(address)
     cb(null, address)
   }
 
@@ -102,10 +201,6 @@ module.exports = class KeyringController extends EventEmitter {
     cb(null, '0xPrivateKey')
   }
 
-  saveAccountLabel(account, label, cb) {
-    cb(/* null, label */)
-  }
-
   tryPassword(password, cb) {
     cb()
   }
diff --git a/app/scripts/keyrings/simple.js b/app/scripts/keyrings/simple.js
new file mode 100644
index 000000000..3eda9b8f9
--- /dev/null
+++ b/app/scripts/keyrings/simple.js
@@ -0,0 +1,41 @@
+const EventEmitter = require('events').EventEmitter
+const Wallet = require('ethereumjs-wallet')
+const type = 'Simple Key Pair'
+
+module.exports = class SimpleKeyring extends EventEmitter {
+
+  static type() {
+    return type
+  }
+
+  constructor(opts) {
+    super()
+    this.type = type
+    this.opts = opts || {}
+    const walletData = this.opts.wallets || []
+    this.wallets = walletData.map((w) => {
+      return Wallet.fromPrivateKey(w)
+    })
+  }
+
+  serialize() {
+    return {
+      type,
+      wallets: this.wallets.map(w => w.getPrivateKey()),
+    }
+  }
+
+  addAccounts(n = 1) {
+    var newWallets = []
+    for (var i = 0; i < n; i++) {
+      newWallets.push(Wallet.generate())
+    }
+    this.wallets.concat(newWallets)
+    return newWallets.map(w => w.getAddress())
+  }
+
+  getAccounts() {
+    return this.wallets.map(w => w.getAddress())
+  }
+
+}
diff --git a/app/scripts/lib/idStore.js b/app/scripts/lib/idStore.js
index 9d0ca7f19..416b65b85 100644
--- a/app/scripts/lib/idStore.js
+++ b/app/scripts/lib/idStore.js
@@ -114,7 +114,6 @@ IdentityStore.prototype.getState = function () {
     conversionRate: configManager.getConversionRate(),
     conversionDate: configManager.getConversionDate(),
     gasMultiplier: configManager.getGasMultiplier(),
-
   }))
 }
 
diff --git a/app/scripts/metamask-controller.js b/app/scripts/metamask-controller.js
index 92551d633..0d12931f6 100644
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@@ -61,6 +61,7 @@ module.exports = class MetamaskController {
 
       // forward directly to idStore
       createNewVault: idStore.createNewVault.bind(idStore),
+      addNewKeyring: idStore.addNewKeyring.bind(idStore),
       submitPassword: idStore.submitPassword.bind(idStore),
       setSelectedAddress: idStore.setSelectedAddress.bind(idStore),
       approveTransaction: idStore.approveTransaction.bind(idStore),
@@ -183,6 +184,7 @@ module.exports = class MetamaskController {
     })
     this.idStore.on('update', function (state) {
       storeSetFromObj(publicConfigStore, idStoreToPublic(state))
+      this.sendUpdate()
     })
 
     // idStore substate
-- 
cgit 


From 957b7a72b55be864320a346108673d02448caefd Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Thu, 20 Oct 2016 17:24:03 -0700
Subject: Improved simple account generation

---
 app/scripts/keyring-controller.js | 61 ++++++++++++++++++++++++---------------
 app/scripts/keyrings/simple.js    | 24 ++++++++-------
 2 files changed, 51 insertions(+), 34 deletions(-)

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 86d61b22b..7179f756a 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -16,7 +16,7 @@ module.exports = class KeyringController extends EventEmitter {
     this.configManager = opts.configManager
     this.ethStore = opts.ethStore
     this.keyrings = []
-    this.identities = {} // Essentially a nickname hash
+    this.identities = {} // Essentially a name hash
   }
 
   getState() {
@@ -64,8 +64,7 @@ module.exports = class KeyringController extends EventEmitter {
     .then((key) => {
       return this.unlockKeyrings(key)
     })
-    .then((keyrings) => {
-      this.keyrings = keyrings
+    .then(() => {
       cb(null, this.getState())
     })
     .catch((err) => {
@@ -74,7 +73,7 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   loadKey(password) {
-    const salt = this.configManager.getSalt()
+    const salt = this.configManager.getSalt() || generateSalt()
     return encryptor.keyFromPassword(password + salt)
     .then((key) => {
       this.key = key
@@ -89,9 +88,10 @@ module.exports = class KeyringController extends EventEmitter {
     const accounts = keyring.addAccounts(1)
 
     accounts.forEach((account) => {
-      this.createBalanceAndNickname(account, i)
+      this.loadBalanceAndNickname(account, i)
     })
 
+    this.keyrings.push(keyring)
     this.persistAllKeyrings()
     .then(() => {
       cb(this.getState())
@@ -102,28 +102,36 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   // Takes an account address and an iterator representing
-  // the current number of nicknamed accounts.
-  createBalanceAndNickname(account, i) {
-    this.ethStore.addAccount(ethUtil.addHexPrefix(account))
-    const oldNickname = this.configManager.nicknameForWallet(account)
-    const nickname = oldNickname || `Account ${++i}`
-    this.identities[account] = {
-      address: account,
-      nickname,
+  // the current number of named accounts.
+  loadBalanceAndNickname(account, i) {
+    const address = ethUtil.addHexPrefix(account)
+    this.ethStore.addAccount(address)
+    const oldNickname = this.configManager.nicknameForWallet(address)
+    const name = oldNickname || `Account ${++i}`
+    this.identities[address] = {
+      address,
+      name,
     }
-    this.saveAccountLabel(account, nickname)
+    this.saveAccountLabel(address, name)
   }
 
   saveAccountLabel (account, label, cb) {
+    const address = ethUtil.addHexPrefix(account)
     const configManager = this.configManager
-    configManager.setNicknameForWallet(account, label)
+    configManager.setNicknameForWallet(address, label)
     if (cb) {
       cb(null, label)
     }
   }
 
   persistAllKeyrings() {
-    const serialized = this.keyrings.map(k => k.serialize())
+    const serialized = this.keyrings.map((k) => {
+      return {
+        type: k.type,
+        // keyring.serialize() must return a JSON-encodable object.
+        data: k.serialize(),
+      }
+    })
     return encryptor.encryptWithKey(this.key, serialized)
     .then((encryptedString) => {
       this.configManager.setVault(encryptedString)
@@ -138,15 +146,21 @@ module.exports = class KeyringController extends EventEmitter {
     const encryptedVault = this.configManager.getVault()
     return encryptor.decryptWithKey(key, encryptedVault)
     .then((vault) => {
-      this.keyrings = vault.map(this.restoreKeyring)
+      this.keyrings = vault.map(this.restoreKeyring.bind(this, 0))
       return this.keyrings
     })
   }
 
-  restoreKeyring(serialized) {
-    const { type } = serialized
+  restoreKeyring(serialized, i) {
+    const { type, data } = serialized
     const Keyring = this.getKeyringClassForType(type)
-    const keyring = new Keyring(serialized)
+    const keyring = new Keyring()
+    keyring.deserialize(data)
+
+    keyring.getAccounts().forEach((account) => {
+      this.loadBalanceAndNickname(account, i)
+    })
+
     return keyring
   }
 
@@ -162,7 +176,8 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   getAccounts() {
-    return this.keyrings.map(kr => kr.getAccounts())
+    const keyrings = this.keyrings || []
+    return keyrings.map(kr => kr.getAccounts())
     .reduce((res, arr) => {
       return res.concat(arr)
     }, [])
@@ -207,8 +222,8 @@ module.exports = class KeyringController extends EventEmitter {
 
 }
 
-function generateSalt (byteCount) {
-  var view = new Uint8Array(32)
+function generateSalt (byteCount = 32) {
+  var view = new Uint8Array(byteCount)
   global.crypto.getRandomValues(view)
   var b64encoded = btoa(String.fromCharCode.apply(null, view))
   return b64encoded
diff --git a/app/scripts/keyrings/simple.js b/app/scripts/keyrings/simple.js
index 3eda9b8f9..59d4691c6 100644
--- a/app/scripts/keyrings/simple.js
+++ b/app/scripts/keyrings/simple.js
@@ -12,17 +12,19 @@ module.exports = class SimpleKeyring extends EventEmitter {
     super()
     this.type = type
     this.opts = opts || {}
-    const walletData = this.opts.wallets || []
-    this.wallets = walletData.map((w) => {
-      return Wallet.fromPrivateKey(w)
-    })
+    this.wallets = []
   }
 
   serialize() {
-    return {
-      type,
-      wallets: this.wallets.map(w => w.getPrivateKey()),
-    }
+    return this.wallets.map(w => w.getPrivateKey().toString('hex'))
+  }
+
+  deserialize(wallets = []) {
+    this.wallets = wallets.map((w) => {
+      var b = new Buffer(w, 'hex')
+      const wallet = Wallet.fromPrivateKey(b)
+      return wallet
+    })
   }
 
   addAccounts(n = 1) {
@@ -30,12 +32,12 @@ module.exports = class SimpleKeyring extends EventEmitter {
     for (var i = 0; i < n; i++) {
       newWallets.push(Wallet.generate())
     }
-    this.wallets.concat(newWallets)
-    return newWallets.map(w => w.getAddress())
+    this.wallets = this.wallets.concat(newWallets)
+    return newWallets.map(w => w.getAddress().toString('hex'))
   }
 
   getAccounts() {
-    return this.wallets.map(w => w.getAddress())
+    return this.wallets.map(w => w.getAddress().toString('hex'))
   }
 
 }
-- 
cgit 


From 9560ae93ee66cd9466c95c98b6853c2062f21235 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Thu, 20 Oct 2016 19:01:04 -0700
Subject: Added tx and msg signing to keychain & controller

---
 app/scripts/background.js          |  8 ++---
 app/scripts/keyring-controller.js  | 56 ++++++++++++++++++++++++++++++-
 app/scripts/keyrings/simple.js     | 41 +++++++++++++++++++++++
 app/scripts/metamask-controller.js | 68 +++++++++++++++++++-------------------
 4 files changed, 134 insertions(+), 39 deletions(-)

(limited to 'app/scripts')

diff --git a/app/scripts/background.js b/app/scripts/background.js
index 652acc113..f05760ac3 100644
--- a/app/scripts/background.js
+++ b/app/scripts/background.js
@@ -21,7 +21,7 @@ const controller = new MetamaskController({
   setData,
   loadData,
 })
-const idStore = controller.idStore
+const keyringController = controller.keyringController
 
 function triggerUi () {
   if (!popupIsOpen) notification.show()
@@ -82,7 +82,7 @@ function setupControllerConnection (stream) {
     // push updates to popup
     controller.ethStore.on('update', controller.sendUpdate.bind(controller))
     controller.listeners.push(remote)
-    idStore.on('update', controller.sendUpdate.bind(controller))
+    keyringController.on('update', controller.sendUpdate.bind(controller))
 
     // teardown on disconnect
     eos(stream, () => {
@@ -96,9 +96,9 @@ function setupControllerConnection (stream) {
 // plugin badge text
 //
 
-idStore.on('update', updateBadge)
+keyringController.on('update', updateBadge)
 
-function updateBadge (state) {
+function updateBadge () {
   var label = ''
   var unconfTxs = controller.configManager.unconfirmedTxs()
   var unconfTxLen = Object.keys(unconfTxs).length
diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 7179f756a..7ebcc6b2c 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -2,6 +2,8 @@ const EventEmitter = require('events').EventEmitter
 const encryptor = require('./lib/encryptor')
 const messageManager = require('./lib/message-manager')
 const ethUtil = require('ethereumjs-util')
+const BN = ethUtil.BN
+const Transaction = require('ethereumjs-tx')
 
 // Keyrings:
 const SimpleKeyring = require('./keyrings/simple')
@@ -198,8 +200,60 @@ module.exports = class KeyringController extends EventEmitter {
     }
   }
 
+  signTransaction(txParams, cb) {
+    try {
+      const address = ethUtil.addHexPrefix(txParams.from.toLowercase())
+      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 = ethUtil.addHexPrefix(txParams.to.toLowerCase())
+      txParams.from = ethUtil.addHexPrefix(txParams.from.toLowerCase())
+      txParams.value = ethUtil.addHexPrefix(txParams.value)
+      txParams.data = ethUtil.addHexPrefix(txParams.data)
+      txParams.gasLimit = ethUtil.addHexPrefix(txParams.gasLimit || txParams.gas)
+      txParams.nonce = ethUtil.addHexPrefix(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) {
-    cb()
+    try {
+      const keyring = this.getKeyringForAccount(msgParams.from)
+      const address = ethUtil.addHexPrefix(msgParams.from.toLowercase())
+      const rawSig = keyring.signMessage(address, msgParams.data)
+      cb(null, rawSig)
+    } catch (e) {
+      cb(e)
+    }
+  }
+
+  getKeyringForAccount(address) {
+    const hexed = ethUtil.addHexPrefix(address.toLowerCase())
+    return this.keyrings.find((ring) => {
+      return ring.getAccounts()
+      .map(acct => ethUtil.addHexPrefix(acct.toLowerCase()))
+      .includes(hexed)
+    })
   }
 
   cancelMessage(msgId, cb) {
diff --git a/app/scripts/keyrings/simple.js b/app/scripts/keyrings/simple.js
index 59d4691c6..6c5af1884 100644
--- a/app/scripts/keyrings/simple.js
+++ b/app/scripts/keyrings/simple.js
@@ -1,5 +1,6 @@
 const EventEmitter = require('events').EventEmitter
 const Wallet = require('ethereumjs-wallet')
+const ethUtil = require('ethereumjs-util')
 const type = 'Simple Key Pair'
 
 module.exports = class SimpleKeyring extends EventEmitter {
@@ -40,4 +41,44 @@ module.exports = class SimpleKeyring extends EventEmitter {
     return 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)
+    var privKey = wallet.getPrivateKey()
+    tx.sign(privKey)
+    return tx
+  }
+
+  // For eth_sign, we need to sign transactions:
+  signMessage(withAccount, data) {
+    const wallet = this.getWalletForAccount(withAccount)
+    const message = ethUtil.removeHexPrefix(data)
+    var privKey = wallet.getPrivateKey()
+    var msgSig = ethUtil.ecsign(new Buffer(message, 'hex'), privKey)
+    var rawMsgSig = ethUtil.bufferToHex(concatSig(msgSig.v, msgSig.r, msgSig.s))
+    return rawMsgSig
+  }
+
+  getWalletForAccount(account) {
+    return this.wallets.find(w => w.getAddress().toString('hex') === account)
+  }
+
+}
+
+function concatSig (v, r, s) {
+  const rSig = ethUtil.fromSigned(r)
+  const sSig = ethUtil.fromSigned(s)
+  const vSig = ethUtil.bufferToInt(v)
+  const rStr = padWithZeroes(ethUtil.toUnsigned(rSig).toString('hex'), 64)
+  const sStr = padWithZeroes(ethUtil.toUnsigned(sSig).toString('hex'), 64)
+  const vStr = ethUtil.stripHexPrefix(ethUtil.intToHex(vSig))
+  return ethUtil.addHexPrefix(rStr.concat(sStr, vStr)).toString('hex')
+}
+
+function padWithZeroes (number, length) {
+  var myString = '' + number
+  while (myString.length < length) {
+    myString = '0' + myString
+  }
+  return myString
 }
diff --git a/app/scripts/metamask-controller.js b/app/scripts/metamask-controller.js
index 0d12931f6..96bd42513 100644
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@@ -1,7 +1,7 @@
 const extend = require('xtend')
 const EthStore = require('eth-store')
 const MetaMaskProvider = require('web3-provider-engine/zero.js')
-const IdentityStore = require('./keyring-controller')
+const KeyringController = require('./keyring-controller')
 const messageManager = require('./lib/message-manager')
 const HostStore = require('./lib/remote-store.js').HostStore
 const Web3 = require('web3')
@@ -15,12 +15,12 @@ module.exports = class MetamaskController {
     this.opts = opts
     this.listeners = []
     this.configManager = new ConfigManager(opts)
-    this.idStore = new IdentityStore({
+    this.keyringController = new KeyringController({
       configManager: this.configManager,
     })
     this.provider = this.initializeProvider(opts)
     this.ethStore = new EthStore(this.provider)
-    this.idStore.setStore(this.ethStore)
+    this.keyringController.setStore(this.ethStore)
     this.getNetwork()
     this.messageManager = messageManager
     this.publicConfigStore = this.initPublicConfigStore()
@@ -38,13 +38,13 @@ module.exports = class MetamaskController {
     return extend(
       this.state,
       this.ethStore.getState(),
-      this.idStore.getState(),
+      this.keyringController.getState(),
       this.configManager.getConfig()
     )
   }
 
   getApi () {
-    const idStore = this.idStore
+    const keyringController = this.keyringController
 
     return {
       getState: (cb) => { cb(null, this.getState()) },
@@ -59,19 +59,19 @@ module.exports = class MetamaskController {
       checkTOSChange: this.checkTOSChange.bind(this),
       setGasMultiplier: this.setGasMultiplier.bind(this),
 
-      // forward directly to idStore
-      createNewVault: idStore.createNewVault.bind(idStore),
-      addNewKeyring: idStore.addNewKeyring.bind(idStore),
-      submitPassword: idStore.submitPassword.bind(idStore),
-      setSelectedAddress: idStore.setSelectedAddress.bind(idStore),
-      approveTransaction: idStore.approveTransaction.bind(idStore),
-      cancelTransaction: idStore.cancelTransaction.bind(idStore),
-      signMessage: idStore.signMessage.bind(idStore),
-      cancelMessage: idStore.cancelMessage.bind(idStore),
-      setLocked: idStore.setLocked.bind(idStore),
-      exportAccount: idStore.exportAccount.bind(idStore),
-      saveAccountLabel: idStore.saveAccountLabel.bind(idStore),
-      tryPassword: idStore.tryPassword.bind(idStore),
+      // forward directly to keyringController
+      createNewVault: keyringController.createNewVault.bind(keyringController),
+      addNewKeyring: keyringController.addNewKeyring.bind(keyringController),
+      submitPassword: keyringController.submitPassword.bind(keyringController),
+      setSelectedAddress: keyringController.setSelectedAddress.bind(keyringController),
+      approveTransaction: keyringController.approveTransaction.bind(keyringController),
+      cancelTransaction: keyringController.cancelTransaction.bind(keyringController),
+      signMessage: keyringController.signMessage.bind(keyringController),
+      cancelMessage: keyringController.cancelMessage.bind(keyringController),
+      setLocked: keyringController.setLocked.bind(keyringController),
+      exportAccount: keyringController.exportAccount.bind(keyringController),
+      saveAccountLabel: keyringController.saveAccountLabel.bind(keyringController),
+      tryPassword: keyringController.tryPassword.bind(keyringController),
       // coinbase
       buyEth: this.buyEth.bind(this),
       // shapeshift
@@ -133,27 +133,27 @@ module.exports = class MetamaskController {
   }
 
   initializeProvider (opts) {
-    const idStore = this.idStore
+    const keyringController = this.keyringController
 
     var providerOpts = {
       rpcUrl: this.configManager.getCurrentRpcAddress(),
       // account mgmt
       getAccounts: (cb) => {
-        var selectedAddress = idStore.getSelectedAddress()
+        var selectedAddress = this.configManager.getSelectedAccount()
         var result = selectedAddress ? [selectedAddress] : []
         cb(null, result)
       },
       // tx signing
       approveTransaction: this.newUnsignedTransaction.bind(this),
       signTransaction: (...args) => {
-        idStore.signTransaction(...args)
+        keyringController.signTransaction(...args)
         this.sendUpdate()
       },
 
       // msg signing
       approveMessage: this.newUnsignedMessage.bind(this),
       signMessage: (...args) => {
-        idStore.signMessage(...args)
+        keyringController.signMessage(...args)
         this.sendUpdate()
       },
     }
@@ -161,7 +161,7 @@ module.exports = class MetamaskController {
     var provider = MetaMaskProvider(providerOpts)
     var web3 = new Web3(provider)
     this.web3 = web3
-    idStore.web3 = web3
+    keyringController.web3 = web3
 
     provider.on('block', this.processBlock.bind(this))
     provider.on('error', this.getNetwork.bind(this))
@@ -172,7 +172,7 @@ module.exports = class MetamaskController {
   initPublicConfigStore () {
     // get init state
     var initPublicState = extend(
-      idStoreToPublic(this.idStore.getState()),
+      keyringControllerToPublic(this.keyringController.getState()),
       configToPublic(this.configManager.getConfig())
     )
 
@@ -182,13 +182,13 @@ module.exports = class MetamaskController {
     this.configManager.subscribe(function (state) {
       storeSetFromObj(publicConfigStore, configToPublic(state))
     })
-    this.idStore.on('update', function (state) {
-      storeSetFromObj(publicConfigStore, idStoreToPublic(state))
+    this.keyringController.on('update', function (state) {
+      storeSetFromObj(publicConfigStore, keyringControllerToPublic(state))
       this.sendUpdate()
     })
 
-    // idStore substate
-    function idStoreToPublic (state) {
+    // keyringController substate
+    function keyringControllerToPublic (state) {
       return {
         selectedAddress: state.selectedAddress,
       }
@@ -211,12 +211,12 @@ module.exports = class MetamaskController {
   }
 
   newUnsignedTransaction (txParams, onTxDoneCb) {
-    const idStore = this.idStore
+    const keyringController = this.keyringController
 
     let err = this.enforceTxValidations(txParams)
     if (err) return onTxDoneCb(err)
 
-    idStore.addUnconfirmedTransaction(txParams, onTxDoneCb, (err, txData) => {
+    keyringController.addUnconfirmedTransaction(txParams, onTxDoneCb, (err, txData) => {
       if (err) return onTxDoneCb(err)
       this.sendUpdate()
       this.opts.showUnconfirmedTx(txParams, txData, onTxDoneCb)
@@ -231,9 +231,9 @@ module.exports = class MetamaskController {
   }
 
   newUnsignedMessage (msgParams, cb) {
-    var state = this.idStore.getState()
+    var state = this.keyringController.getState()
     if (!state.isUnlocked) {
-      this.idStore.addUnconfirmedMessage(msgParams, cb)
+      this.keyringController.addUnconfirmedMessage(msgParams, cb)
       this.opts.unlockAccountMessage()
     } else {
       this.addUnconfirmedMessage(msgParams, cb)
@@ -242,8 +242,8 @@ module.exports = class MetamaskController {
   }
 
   addUnconfirmedMessage (msgParams, cb) {
-    const idStore = this.idStore
-    const msgId = idStore.addUnconfirmedMessage(msgParams, cb)
+    const keyringController = this.keyringController
+    const msgId = keyringController.addUnconfirmedMessage(msgParams, cb)
     this.opts.showUnconfirmedMessage(msgParams, msgId)
   }
 
-- 
cgit 


From c3e1c5c57f2062155626647e239c2a760f3e4b8a Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Fri, 21 Oct 2016 11:10:36 -0700
Subject: Added SimpleKeyring tests

---
 app/scripts/keyring-controller.js |  2 ++
 app/scripts/keyrings/simple.js    | 20 ++------------------
 app/scripts/lib/sig-util.js       | 23 +++++++++++++++++++++++
 3 files changed, 27 insertions(+), 18 deletions(-)
 create mode 100644 app/scripts/lib/sig-util.js

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 7ebcc6b2c..8192ed790 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -263,6 +263,8 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   setLocked(cb) {
+    this.key = null
+    this.keyrings = []
     cb()
   }
 
diff --git a/app/scripts/keyrings/simple.js b/app/scripts/keyrings/simple.js
index 6c5af1884..9e832f274 100644
--- a/app/scripts/keyrings/simple.js
+++ b/app/scripts/keyrings/simple.js
@@ -2,6 +2,7 @@ const EventEmitter = require('events').EventEmitter
 const Wallet = require('ethereumjs-wallet')
 const ethUtil = require('ethereumjs-util')
 const type = 'Simple Key Pair'
+const sigUtil = require('../lib/sig-util')
 
 module.exports = class SimpleKeyring extends EventEmitter {
 
@@ -55,7 +56,7 @@ module.exports = class SimpleKeyring extends EventEmitter {
     const message = ethUtil.removeHexPrefix(data)
     var privKey = wallet.getPrivateKey()
     var msgSig = ethUtil.ecsign(new Buffer(message, 'hex'), privKey)
-    var rawMsgSig = ethUtil.bufferToHex(concatSig(msgSig.v, msgSig.r, msgSig.s))
+    var rawMsgSig = ethUtil.bufferToHex(sigUtil.concatSig(msgSig.v, msgSig.r, msgSig.s))
     return rawMsgSig
   }
 
@@ -65,20 +66,3 @@ module.exports = class SimpleKeyring extends EventEmitter {
 
 }
 
-function concatSig (v, r, s) {
-  const rSig = ethUtil.fromSigned(r)
-  const sSig = ethUtil.fromSigned(s)
-  const vSig = ethUtil.bufferToInt(v)
-  const rStr = padWithZeroes(ethUtil.toUnsigned(rSig).toString('hex'), 64)
-  const sStr = padWithZeroes(ethUtil.toUnsigned(sSig).toString('hex'), 64)
-  const vStr = ethUtil.stripHexPrefix(ethUtil.intToHex(vSig))
-  return ethUtil.addHexPrefix(rStr.concat(sStr, vStr)).toString('hex')
-}
-
-function padWithZeroes (number, length) {
-  var myString = '' + number
-  while (myString.length < length) {
-    myString = '0' + myString
-  }
-  return myString
-}
diff --git a/app/scripts/lib/sig-util.js b/app/scripts/lib/sig-util.js
new file mode 100644
index 000000000..f8748f535
--- /dev/null
+++ b/app/scripts/lib/sig-util.js
@@ -0,0 +1,23 @@
+const ethUtil = require('ethereumjs-util')
+
+module.exports = {
+
+  concatSig: function (v, r, s) {
+    const rSig = ethUtil.fromSigned(r)
+    const sSig = ethUtil.fromSigned(s)
+    const vSig = ethUtil.bufferToInt(v)
+    const rStr = padWithZeroes(ethUtil.toUnsigned(rSig).toString('hex'), 64)
+    const sStr = padWithZeroes(ethUtil.toUnsigned(sSig).toString('hex'), 64)
+    const vStr = ethUtil.stripHexPrefix(ethUtil.intToHex(vSig))
+    return ethUtil.addHexPrefix(rStr.concat(sStr, vStr)).toString('hex')
+  },
+
+}
+
+function padWithZeroes (number, length) {
+  var myString = '' + number
+  while (myString.length < length) {
+    myString = '0' + myString
+  }
+  return myString
+}
-- 
cgit 


From 44aa1be2778a1647c9a607fd02c61bf93704d92d Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Fri, 21 Oct 2016 12:11:54 -0700
Subject: Create basic keyring-controller unit test file

---
 app/scripts/keyring-controller.js | 19 +++++++------------
 app/scripts/lib/encryptor.js      |  9 +++++++++
 2 files changed, 16 insertions(+), 12 deletions(-)

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 8192ed790..5cf2542cc 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -17,6 +17,7 @@ module.exports = class KeyringController extends EventEmitter {
     super()
     this.configManager = opts.configManager
     this.ethStore = opts.ethStore
+    this.encryptor = encryptor
     this.keyrings = []
     this.identities = {} // Essentially a name hash
   }
@@ -46,11 +47,11 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   createNewVault(password, entropy, cb) {
-    const salt = generateSalt()
+    const salt = this.encryptor.generateSalt()
     this.configManager.setSalt(salt)
     this.loadKey(password)
     .then((key) => {
-      return encryptor.encryptWithKey(key, [])
+      return this.encryptor.encryptWithKey(key, [])
     })
     .then((encryptedString) => {
       this.configManager.setVault(encryptedString)
@@ -75,8 +76,8 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   loadKey(password) {
-    const salt = this.configManager.getSalt() || generateSalt()
-    return encryptor.keyFromPassword(password + salt)
+    const salt = this.configManager.getSalt() || this.encryptor.generateSalt()
+    return this.encryptor.keyFromPassword(password + salt)
     .then((key) => {
       this.key = key
       return key
@@ -134,7 +135,7 @@ module.exports = class KeyringController extends EventEmitter {
         data: k.serialize(),
       }
     })
-    return encryptor.encryptWithKey(this.key, serialized)
+    return this.encryptor.encryptWithKey(this.key, serialized)
     .then((encryptedString) => {
       this.configManager.setVault(encryptedString)
       return true
@@ -146,7 +147,7 @@ module.exports = class KeyringController extends EventEmitter {
 
   unlockKeyrings(key) {
     const encryptedVault = this.configManager.getVault()
-    return encryptor.decryptWithKey(key, encryptedVault)
+    return this.encryptor.decryptWithKey(key, encryptedVault)
     .then((vault) => {
       this.keyrings = vault.map(this.restoreKeyring.bind(this, 0))
       return this.keyrings
@@ -278,9 +279,3 @@ module.exports = class KeyringController extends EventEmitter {
 
 }
 
-function generateSalt (byteCount = 32) {
-  var view = new Uint8Array(byteCount)
-  global.crypto.getRandomValues(view)
-  var b64encoded = btoa(String.fromCharCode.apply(null, view))
-  return b64encoded
-}
diff --git a/app/scripts/lib/encryptor.js b/app/scripts/lib/encryptor.js
index 3d069ab33..832e6d528 100644
--- a/app/scripts/lib/encryptor.js
+++ b/app/scripts/lib/encryptor.js
@@ -22,6 +22,8 @@ module.exports = {
   // Buffer <-> base64 string methods
   encodeBufferToBase64,
   decodeBase64ToBuffer,
+
+  generateSalt,
 }
 
 // Takes a Pojo, returns encrypted text.
@@ -135,3 +137,10 @@ function decodeBase64ToBuffer (base64) {
   }))
   return buf
 }
+
+function generateSalt (byteCount = 32) {
+  var view = new Uint8Array(byteCount)
+  global.crypto.getRandomValues(view)
+  var b64encoded = btoa(String.fromCharCode.apply(null, view))
+  return b64encoded
+}
-- 
cgit 


From 626b52d24a3db05bf4f4e05df53f886615cc9538 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Fri, 21 Oct 2016 13:11:30 -0700
Subject: Fix bug in new KeyringController vault restoring logic.

---
 app/scripts/keyring-controller.js | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 5cf2542cc..807752a94 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -18,6 +18,8 @@ module.exports = class KeyringController extends EventEmitter {
     this.configManager = opts.configManager
     this.ethStore = opts.ethStore
     this.encryptor = encryptor
+    this.keyringTypes = keyringTypes
+
     this.keyrings = []
     this.identities = {} // Essentially a name hash
   }
@@ -37,7 +39,7 @@ module.exports = class KeyringController extends EventEmitter {
       currentFiat: this.configManager.getCurrentFiat(),
       conversionRate: this.configManager.getConversionRate(),
       conversionDate: this.configManager.getConversionDate(),
-      keyringTypes: keyringTypes.map((krt) => krt.type()),
+      keyringTypes: this.keyringTypes.map((krt) => krt.type()),
       identities: this.identities,
     }
   }
@@ -154,7 +156,7 @@ module.exports = class KeyringController extends EventEmitter {
     })
   }
 
-  restoreKeyring(serialized, i) {
+  restoreKeyring(i, serialized) {
     const { type, data } = serialized
     const Keyring = this.getKeyringClassForType(type)
     const keyring = new Keyring()
@@ -168,7 +170,7 @@ module.exports = class KeyringController extends EventEmitter {
   }
 
   getKeyringClassForType(type) {
-    const Keyring = keyringTypes.reduce((res, kr) => {
+    const Keyring = this.keyringTypes.reduce((res, kr) => {
       if (kr.type() === type) {
         return kr
       } else {
-- 
cgit 


From 1ddb8b9aec02e5e38a6eed8eeea1733ee3cd99c0 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Fri, 21 Oct 2016 13:41:33 -0700
Subject: Added tx & msg managing functionality to new KeyringController

---
 app/scripts/keyring-controller.js  | 148 +++++++++++++++++++++++++++++++++++++
 app/scripts/metamask-controller.js |   3 +-
 2 files changed, 150 insertions(+), 1 deletion(-)

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 807752a94..45deb40c8 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -1,9 +1,13 @@
+const async = require('async')
 const EventEmitter = require('events').EventEmitter
 const encryptor = require('./lib/encryptor')
 const messageManager = require('./lib/message-manager')
 const ethUtil = require('ethereumjs-util')
+const ethBinToOps = require('eth-bin-to-ops')
+const EthQuery = require('eth-query')
 const BN = ethUtil.BN
 const Transaction = require('ethereumjs-tx')
+const createId = require('web3-provider-engine/util/random-id')
 
 // Keyrings:
 const SimpleKeyring = require('./keyrings/simple')
@@ -15,6 +19,7 @@ module.exports = class KeyringController extends EventEmitter {
 
   constructor (opts) {
     super()
+    this.web3 = opts.web3
     this.configManager = opts.configManager
     this.ethStore = opts.ethStore
     this.encryptor = encryptor
@@ -22,6 +27,11 @@ module.exports = class KeyringController extends EventEmitter {
 
     this.keyrings = []
     this.identities = {} // Essentially a name hash
+
+    this._unconfTxCbs = {}
+    this._unconfMsgCbs = {}
+
+    this.network = 'loading'
   }
 
   getState() {
@@ -41,6 +51,7 @@ module.exports = class KeyringController extends EventEmitter {
       conversionDate: this.configManager.getConversionDate(),
       keyringTypes: this.keyringTypes.map((krt) => krt.type()),
       identities: this.identities,
+      network: this.network,
     }
   }
 
@@ -193,11 +204,121 @@ module.exports = class KeyringController extends EventEmitter {
     cb(null, address)
   }
 
+  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.network
+    var txData = {
+      id: txId,
+      txParams: txParams,
+      time: time,
+      status: 'unconfirmed',
+      gasMultiplier: configManager.getGasMultiplier() || 1,
+    }
+
+    console.log('addUnconfirmedTransaction:', txData)
+
+    // 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()
     }
@@ -279,5 +400,32 @@ module.exports = class KeyringController extends EventEmitter {
     cb()
   }
 
+  getNetwork(err) {
+    if (err) {
+      this.network = 'loading'
+      this.emit('update')
+    }
+
+    this.web3.version.getNetwork((err, network) => {
+      if (err) {
+        this.network = 'loading'
+        return this.emit('update')
+      }
+      if (global.METAMASK_DEBUG) {
+        console.log('web3.getNetwork returned ' + network)
+      }
+      this.network = network
+      this.emit('update')
+    })
+  }
+
+  addGasBuffer(gasHex) {
+    var gas = new BN(gasHex, 16)
+    var buffer = new BN('100000', 10)
+    var result = gas.add(buffer)
+    return ethUtil.addHexPrefix(result.toString(16))
+  }
+
 }
 
+function noop () {}
diff --git a/app/scripts/metamask-controller.js b/app/scripts/metamask-controller.js
index 96bd42513..c0da7cdaa 100644
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@@ -182,7 +182,8 @@ module.exports = class MetamaskController {
     this.configManager.subscribe(function (state) {
       storeSetFromObj(publicConfigStore, configToPublic(state))
     })
-    this.keyringController.on('update', function (state) {
+    this.keyringController.on('update', () => {
+      const state = this.keyringController.getState()
       storeSetFromObj(publicConfigStore, keyringControllerToPublic(state))
       this.sendUpdate()
     })
-- 
cgit 


From 518ff399fbf17bc747d956bbb64ca76f6bbd4057 Mon Sep 17 00:00:00 2001
From: Dan Finlay <dan@danfinlay.com>
Date: Fri, 21 Oct 2016 14:11:04 -0700
Subject: Fix loading indication

---
 app/scripts/keyring-controller.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/scripts')

diff --git a/app/scripts/keyring-controller.js b/app/scripts/keyring-controller.js
index 45deb40c8..28c920d22 100644
--- a/app/scripts/keyring-controller.js
+++ b/app/scripts/keyring-controller.js
@@ -31,7 +31,7 @@ module.exports = class KeyringController extends EventEmitter {
     this._unconfTxCbs = {}
     this._unconfMsgCbs = {}
 
-    this.network = 'loading'
+    this.network = null
   }
 
   getState() {
-- 
cgit