Merge branch 'master' into mascara-deploy

31 files changed, 1401 insertions, 536 deletions

diff --git a/app/scripts/lib/account-tracker.js b/app/scripts/lib/account-tracker.js
new file mode 100644
index 000000000..8c3dd8c71
--- /dev/null
+++ b/app/scripts/lib/account-tracker.js
@@ -0,0 +1,125 @@
+/* Account Tracker
+ *
+ * This module is responsible for tracking any number of accounts
+ * and caching their current balances & transaction counts.
+ *
+ * It also tracks transaction hashes, and checks their inclusion status
+ * on each new block.
+ */
+
+const async = require('async')
+const EthQuery = require('eth-query')
+const ObservableStore = require('obs-store')
+const EventEmitter = require('events').EventEmitter
+function noop () {}
+
+
+class AccountTracker extends EventEmitter {
+
+  constructor (opts = {}) {
+    super()
+
+    const initState = {
+      accounts: {},
+      currentBlockGasLimit: '',
+    }
+    this.store = new ObservableStore(initState)
+
+    this._provider = opts.provider
+    this._query = new EthQuery(this._provider)
+    this._blockTracker = opts.blockTracker
+    // subscribe to latest block
+    this._blockTracker.on('block', this._updateForBlock.bind(this))
+    // blockTracker.currentBlock may be null
+    this._currentBlockNumber = this._blockTracker.currentBlock
+  }
+
+  //
+  // public
+  //
+
+  syncWithAddresses (addresses) {
+    const accounts = this.store.getState().accounts
+    const locals = Object.keys(accounts)
+
+    const toAdd = []
+    addresses.forEach((upstream) => {
+      if (!locals.includes(upstream)) {
+        toAdd.push(upstream)
+      }
+    })
+
+    const toRemove = []
+    locals.forEach((local) => {
+      if (!addresses.includes(local)) {
+        toRemove.push(local)
+      }
+    })
+
+    toAdd.forEach(upstream => this.addAccount(upstream))
+    toRemove.forEach(local => this.removeAccount(local))
+    this._updateAccounts()
+  }
+
+  addAccount (address) {
+    const accounts = this.store.getState().accounts
+    accounts[address] = {}
+    this.store.updateState({ accounts })
+    if (!this._currentBlockNumber) return
+    this._updateAccount(address)
+  }
+
+  removeAccount (address) {
+    const accounts = this.store.getState().accounts
+    delete accounts[address]
+    this.store.updateState({ accounts })
+  }
+
+  //
+  // private
+  //
+
+  _updateForBlock (block) {
+    this._currentBlockNumber = block.number
+    const currentBlockGasLimit = block.gasLimit
+
+    this.store.updateState({ currentBlockGasLimit })
+
+    async.parallel([
+      this._updateAccounts.bind(this),
+    ], (err) => {
+      if (err) return console.error(err)
+      this.emit('block', this.store.getState())
+    })
+  }
+
+  _updateAccounts (cb = noop) {
+    const accounts = this.store.getState().accounts
+    const addresses = Object.keys(accounts)
+    async.each(addresses, this._updateAccount.bind(this), cb)
+  }
+
+  _updateAccount (address, cb = noop) {
+    this._getAccount(address, (err, result) => {
+      if (err) return cb(err)
+      result.address = address
+      const accounts = this.store.getState().accounts
+      // only populate if the entry is still present
+      if (accounts[address]) {
+        accounts[address] = result
+        this.store.updateState({ accounts })
+      }
+      cb(null, result)
+    })
+  }
+
+  _getAccount (address, cb = noop) {
+    const query = this._query
+    async.parallel({
+      balance: query.getBalance.bind(query, address),
+    }, cb)
+  }
+
+}
+
+module.exports = AccountTracker
diff --git a/app/scripts/lib/auto-faucet.js b/app/scripts/lib/auto-faucet.js
deleted file mode 100644
index 38d54ba5e..000000000
--- a/app/scripts/lib/auto-faucet.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const uri = 'https://faucet.metamask.io/'
-const METAMASK_DEBUG = 'GULP_METAMASK_DEBUG'
-const env = process.env.METAMASK_ENV
-
-module.exports = function (address) {
-  // Don't faucet in development or test
-  if (METAMASK_DEBUG === true || env === 'test') return
-  global.log.info('auto-fauceting:', address)
-  const data = address
-  const headers = new Headers()
-  headers.append('Content-type', 'application/rawdata')
-  fetch(uri, {
-    method: 'POST',
-    headers,
-    body: data,
-  })
-  .catch((err) => {
-    console.error(err)
-  })
-}
diff --git a/app/scripts/lib/auto-reload.js b/app/scripts/lib/auto-reload.js
index 1302df35f..cce31c3d2 100644
--- a/app/scripts/lib/auto-reload.js
+++ b/app/scripts/lib/auto-reload.js
@@ -1,30 +1,58 @@
-const once = require('once')
-const ensnare = require('ensnare')
-
 module.exports = setupDappAutoReload
 
-function setupDappAutoReload (web3) {
+function setupDappAutoReload (web3, observable) {
   // export web3 as a global, checking for usage
-  var pageIsUsingWeb3 = false
-  var resetWasRequested = false
-  global.web3 = ensnare(web3, once(function () {
-    // if web3 usage happened after a reset request, trigger reset late
-    if (resetWasRequested) return triggerReset()
-    // mark web3 as used
-    pageIsUsingWeb3 = true
-    // reset web3 reference
-    global.web3 = web3
-  }))
-
-  return handleResetRequest
-
-  function handleResetRequest () {
-    resetWasRequested = true
-    // ignore if web3 was not used
-    if (!pageIsUsingWeb3) return
-    // reload after short timeout
-    setTimeout(triggerReset, 500)
-  }
+  let hasBeenWarned = false
+  let reloadInProgress = false
+  let lastTimeUsed
+  let lastSeenNetwork
+
+  global.web3 = new Proxy(web3, {
+    get: (_web3, key) => {
+      // show warning once on web3 access
+      if (!hasBeenWarned && key !== 'currentProvider') {
+        console.warn('MetaMask: web3 will be deprecated in the near future in favor of the ethereumProvider \nhttps://github.com/MetaMask/faq/blob/master/detecting_metamask.md#web3-deprecation')
+        hasBeenWarned = true
+      }
+      // get the time of use
+      lastTimeUsed = Date.now()
+      // return value normally
+      return _web3[key]
+    },
+    set: (_web3, key, value) => {
+      // set value normally
+      _web3[key] = value
+    },
+  })
+
+  observable.subscribe(function (state) {
+    // if reload in progress, no need to check reload logic
+    if (reloadInProgress) return
+
+    const currentNetwork = state.networkVersion
+
+    // set the initial network
+    if (!lastSeenNetwork) {
+      lastSeenNetwork = currentNetwork
+      return
+    }
+
+    // skip reload logic if web3 not used
+    if (!lastTimeUsed) return
+
+    // if network did not change, exit
+    if (currentNetwork === lastSeenNetwork) return
+
+    // initiate page reload
+    reloadInProgress = true
+    const timeSinceUse = Date.now() - lastTimeUsed
+    // if web3 was recently used then delay the reloading of the page
+    if (timeSinceUse > 500) {
+      triggerReset()
+    } else {
+      setTimeout(triggerReset, 500)
+    }
+  })
 }
 
 // reload the page
diff --git a/app/scripts/lib/buy-eth-url.js b/app/scripts/lib/buy-eth-url.js
index 91a1ec322..b9dde3c28 100644
--- a/app/scripts/lib/buy-eth-url.js
+++ b/app/scripts/lib/buy-eth-url.js
@@ -1,6 +1,6 @@
 module.exports = getBuyEthUrl
 
-function getBuyEthUrl({ network, amount, address }){
+function getBuyEthUrl ({ network, amount, address }) {
   let url
   switch (network) {
     case '1':
@@ -11,9 +11,13 @@ function getBuyEthUrl({ network, amount, address }){
       url = 'https://faucet.metamask.io/'
       break
 
+    case '4':
+      url = 'https://www.rinkeby.io/'
+      break
+
     case '42':
       url = 'https://github.com/kovan-testnet/faucet'
       break
   }
   return url
-}
\ No newline at end of file
+}
diff --git a/app/scripts/lib/config-manager.js b/app/scripts/lib/config-manager.js
index e31cb45ed..34b603b96 100644
--- a/app/scripts/lib/config-manager.js
+++ b/app/scripts/lib/config-manager.js
@@ -1,11 +1,12 @@
-const MetamaskConfig = require('../config.js')
 const ethUtil = require('ethereumjs-util')
 const normalize = require('eth-sig-util').normalize
+const MetamaskConfig = require('../config.js')
+
 
-const TESTNET_RPC = MetamaskConfig.network.testnet
 const MAINNET_RPC = MetamaskConfig.network.mainnet
-const MORDEN_RPC = MetamaskConfig.network.morden
+const ROPSTEN_RPC = MetamaskConfig.network.ropsten
 const KOVAN_RPC = MetamaskConfig.network.kovan
+const RINKEBY_RPC = MetamaskConfig.network.rinkeby
 
 /* The config-manager is a convenience object
  * wrapping a pojo-migrator.
@@ -33,36 +34,6 @@ ConfigManager.prototype.getConfig = function () {
   return data.config
 }
 
-ConfigManager.prototype.setRpcTarget = function (rpcUrl) {
-  var config = this.getConfig()
-  config.provider = {
-    type: 'rpc',
-    rpcTarget: rpcUrl,
-  }
-  this.setConfig(config)
-}
-
-ConfigManager.prototype.setProviderType = function (type) {
-  var config = this.getConfig()
-  config.provider = {
-    type: type,
-  }
-  this.setConfig(config)
-}
-
-ConfigManager.prototype.useEtherscanProvider = function () {
-  var config = this.getConfig()
-  config.provider = {
-    type: 'etherscan',
-  }
-  this.setConfig(config)
-}
-
-ConfigManager.prototype.getProvider = function () {
-  var config = this.getConfig()
-  return config.provider
-}
-
 ConfigManager.prototype.setData = function (data) {
   this.store.putState(data)
 }
@@ -71,6 +42,17 @@ ConfigManager.prototype.getData = function () {
   return this.store.getState()
 }
 
+ConfigManager.prototype.setPasswordForgotten = function (passwordForgottenState) {
+  const data = this.getData()
+  data.forgottenPassword = passwordForgottenState
+  this.setData(data)
+}
+
+ConfigManager.prototype.getPasswordForgotten = function (passwordForgottenState) {
+  const data = this.getData()
+  return data.forgottenPassword
+}
+
 ConfigManager.prototype.setWallet = function (wallet) {
   var data = this.getData()
   data.wallet = wallet
@@ -136,6 +118,35 @@ ConfigManager.prototype.getSeedWords = function () {
   var data = this.getData()
   return data.seedWords
 }
+ConfigManager.prototype.setRpcTarget = function (rpcUrl) {
+  var config = this.getConfig()
+  config.provider = {
+    type: 'rpc',
+    rpcTarget: rpcUrl,
+  }
+  this.setConfig(config)
+}
+
+ConfigManager.prototype.setProviderType = function (type) {
+  var config = this.getConfig()
+  config.provider = {
+    type: type,
+  }
+  this.setConfig(config)
+}
+
+ConfigManager.prototype.useEtherscanProvider = function () {
+  var config = this.getConfig()
+  config.provider = {
+    type: 'etherscan',
+  }
+  this.setConfig(config)
+}
+
+ConfigManager.prototype.getProvider = function () {
+  var config = this.getConfig()
+  return config.provider
+}
 
 ConfigManager.prototype.getCurrentRpcAddress = function () {
   var provider = this.getProvider()
@@ -145,17 +156,17 @@ ConfigManager.prototype.getCurrentRpcAddress = function () {
     case 'mainnet':
       return MAINNET_RPC
 
-    case 'testnet':
-      return TESTNET_RPC
-
-    case 'morden':
-      return MORDEN_RPC
+    case 'ropsten':
+      return ROPSTEN_RPC
 
     case 'kovan':
       return KOVAN_RPC
 
+    case 'rinkeby':
+      return RINKEBY_RPC
+
     default:
-      return provider && provider.rpcTarget ? provider.rpcTarget : TESTNET_RPC
+      return provider && provider.rpcTarget ? provider.rpcTarget : RINKEBY_RPC
   }
 }
 
diff --git a/app/scripts/lib/createLoggerMiddleware.js b/app/scripts/lib/createLoggerMiddleware.js
new file mode 100644
index 000000000..2707cbd9e
--- /dev/null
+++ b/app/scripts/lib/createLoggerMiddleware.js
@@ -0,0 +1,15 @@
+// log rpc activity
+module.exports = createLoggerMiddleware
+
+function createLoggerMiddleware ({ origin }) {
+  return function loggerMiddleware (req, res, next, end) {
+    next((cb) => {
+      if (res.error) {
+        log.error('Error in RPC response:\n', res)
+      }
+      if (req.isMetamaskInternal) return
+      log.info(`RPC (${origin}):`, req, '->', res)
+      cb()
+    })
+  }
+}
diff --git a/app/scripts/lib/createOriginMiddleware.js b/app/scripts/lib/createOriginMiddleware.js
new file mode 100644
index 000000000..f8bdb2dc2
--- /dev/null
+++ b/app/scripts/lib/createOriginMiddleware.js
@@ -0,0 +1,9 @@
+// append dapp origin domain to request
+module.exports = createOriginMiddleware
+
+function createOriginMiddleware ({ origin }) {
+  return function originMiddleware (req, res, next, end) {
+    req.origin = origin
+    next()
+  }
+}
diff --git a/app/scripts/lib/createProviderMiddleware.js b/app/scripts/lib/createProviderMiddleware.js
new file mode 100644
index 000000000..4e667bac2
--- /dev/null
+++ b/app/scripts/lib/createProviderMiddleware.js
@@ -0,0 +1,12 @@
+module.exports = createProviderMiddleware
+
+// forward requests to provider
+function createProviderMiddleware ({ provider }) {
+  return (req, res, next, end) => {
+    provider.sendAsync(req, (err, _res) => {
+      if (err) return end(err)
+      res.result = _res.result
+      end()
+    })
+  }
+}
diff --git a/app/scripts/lib/environment-type.js b/app/scripts/lib/environment-type.js
new file mode 100644
index 000000000..7966926eb
--- /dev/null
+++ b/app/scripts/lib/environment-type.js
@@ -0,0 +1,10 @@
+module.exports = function environmentType () {
+  const url = window.location.href
+  if (url.match(/popup.html$/)) {
+    return 'popup'
+  } else if (url.match(/home.html$/)) {
+    return 'responsive'
+  } else {
+    return 'notification'
+  }
+}
diff --git a/app/scripts/lib/eth-store.js b/app/scripts/lib/eth-store.js
deleted file mode 100644
index 243253df2..000000000
--- a/app/scripts/lib/eth-store.js
+++ /dev/null
@@ -1,136 +0,0 @@
-/* Ethereum Store
- *
- * This module is responsible for tracking any number of accounts
- * and caching their current balances & transaction counts.
- *
- * It also tracks transaction hashes, and checks their inclusion status
- * on each new block.
- */
-
-const async = require('async')
-const EthQuery = require('eth-query')
-const ObservableStore = require('obs-store')
-function noop() {}
-
-
-class EthereumStore extends ObservableStore {
-
-  constructor (opts = {}) {
-    super({
-      accounts: {},
-      transactions: {},
-      currentBlockNumber: '0',
-      currentBlockHash: '',
-    })
-    this._provider = opts.provider
-    this._query = new EthQuery(this._provider)
-    this._blockTracker = opts.blockTracker
-    // subscribe to latest block
-    this._blockTracker.on('block', this._updateForBlock.bind(this))
-    // blockTracker.currentBlock may be null
-    this._currentBlockNumber = this._blockTracker.currentBlock
-  }
-
-  //
-  // public
-  //
-
-  addAccount (address) {
-    const accounts = this.getState().accounts
-    accounts[address] = {}
-    this.updateState({ accounts })
-    if (!this._currentBlockNumber) return
-    this._updateAccount(address)
-  }
-
-  removeAccount (address) {
-    const accounts = this.getState().accounts
-    delete accounts[address]
-    this.updateState({ accounts })
-  }
-
-  addTransaction (txHash) {
-    const transactions = this.getState().transactions
-    transactions[txHash] = {}
-    this.updateState({ transactions })
-    if (!this._currentBlockNumber) return
-    this._updateTransaction(this._currentBlockNumber, txHash, noop)
-  }
-
-  removeTransaction (txHash) {
-    const transactions = this.getState().transactions
-    delete transactions[txHash]
-    this.updateState({ transactions })
-  }
-
-
-  //
-  // private
-  //
-
-  _updateForBlock (block) {
-    const blockNumber = '0x' + block.number.toString('hex')
-    this._currentBlockNumber = blockNumber
-    this.updateState({ currentBlockNumber: parseInt(blockNumber) })
-    this.updateState({ currentBlockHash: `0x${block.hash.toString('hex')}`})
-    async.parallel([
-      this._updateAccounts.bind(this),
-      this._updateTransactions.bind(this, blockNumber),
-    ], (err) => {
-      if (err) return console.error(err)
-      this.emit('block', this.getState())
-    })
-  }
-
-  _updateAccounts (cb = noop) {
-    const accounts = this.getState().accounts
-    const addresses = Object.keys(accounts)
-    async.each(addresses, this._updateAccount.bind(this), cb)
-  }
-
-  _updateAccount (address, cb = noop) {
-    const accounts = this.getState().accounts
-    this._getAccount(address, (err, result) => {
-      if (err) return cb(err)
-      result.address = address
-      // only populate if the entry is still present
-      if (accounts[address]) {
-        accounts[address] = result
-        this.updateState({ accounts })
-      }
-      cb(null, result)
-    })
-  }
-
-  _updateTransactions (block, cb = noop) {
-    const transactions = this.getState().transactions
-    const txHashes = Object.keys(transactions)
-    async.each(txHashes, this._updateTransaction.bind(this, block), cb)
-  }
-
-  _updateTransaction (block, txHash, cb = noop) {
-    // would use the block here to determine how many confirmations the tx has
-    const transactions = this.getState().transactions
-    this._query.getTransaction(txHash, (err, result) => {
-      if (err) return cb(err)
-      // only populate if the entry is still present
-      if (transactions[txHash]) {
-        transactions[txHash] = result
-        this.updateState({ transactions })
-      }
-      cb(null, result)
-    })
-  }
-
-  _getAccount (address, cb = noop) {
-    const query = this._query
-    async.parallel({
-      balance: query.getBalance.bind(query, address),
-      nonce: query.getTransactionCount.bind(query, address),
-      code: query.getCode.bind(query, address),
-    }, cb)
-  }
-
-}
-
-module.exports = EthereumStore
diff --git a/app/scripts/lib/events-proxy.js b/app/scripts/lib/events-proxy.js
new file mode 100644
index 000000000..c0a490b05
--- /dev/null
+++ b/app/scripts/lib/events-proxy.js
@@ -0,0 +1,31 @@
+module.exports = function createEventEmitterProxy (eventEmitter, listeners) {
+  let target = eventEmitter
+  const eventHandlers = listeners || {}
+  const proxy = new Proxy({}, {
+    get: (obj, name) => {
+      // intercept listeners
+      if (name === 'on') return addListener
+      if (name === 'setTarget') return setTarget
+      if (name === 'proxyEventHandlers') return eventHandlers
+      return target[name]
+    },
+    set: (obj, name, value) => {
+      target[name] = value
+      return true
+    },
+  })
+  function setTarget (eventEmitter) {
+    target = eventEmitter
+    // migrate listeners
+    Object.keys(eventHandlers).forEach((name) => {
+      eventHandlers[name].forEach((handler) => target.on(name, handler))
+    })
+  }
+  function addListener (name, handler) {
+    if (!eventHandlers[name]) eventHandlers[name] = []
+    eventHandlers[name].push(handler)
+    target.on(name, handler)
+  }
+  if (listeners) proxy.setTarget(eventEmitter)
+  return proxy
+}
diff --git a/app/scripts/lib/inpage-provider.js b/app/scripts/lib/inpage-provider.js
index 92936de2f..99cc5d2cf 100644
--- a/app/scripts/lib/inpage-provider.js
+++ b/app/scripts/lib/inpage-provider.js
@@ -1,8 +1,10 @@
-const pipe = require('pump')
-const StreamProvider = require('web3-stream-provider')
+const pump = require('pump')
+const RpcEngine = require('json-rpc-engine')
+const createIdRemapMiddleware = require('json-rpc-engine/src/idRemapMiddleware')
+const createStreamMiddleware = require('json-rpc-middleware-stream')
 const LocalStorageStore = require('obs-store')
-const ObjectMultiplex = require('./obj-multiplex')
-const createRandomId = require('./random-id')
+const asStream = require('obs-store/lib/asStream')
+const ObjectMultiplex = require('obj-multiplex')
 
 module.exports = MetamaskInpageProvider
 
@@ -10,56 +12,50 @@ function MetamaskInpageProvider (connectionStream) {
   const self = this
 
   // setup connectionStream multiplexing
-  var multiStream = self.multiStream = ObjectMultiplex()
-  pipe(
+  const mux = self.mux = new ObjectMultiplex()
+  pump(
     connectionStream,
-    multiStream,
+    mux,
     connectionStream,
     (err) => logStreamDisconnectWarning('MetaMask', err)
   )
 
   // subscribe to metamask public config (one-way)
   self.publicConfigStore = new LocalStorageStore({ storageKey: 'MetaMask-Config' })
-  pipe(
-    multiStream.createStream('publicConfig'),
-    self.publicConfigStore,
+
+  pump(
+    mux.createStream('publicConfig'),
+    asStream(self.publicConfigStore),
     (err) => logStreamDisconnectWarning('MetaMask PublicConfigStore', err)
   )
 
+  // ignore phishing warning message (handled elsewhere)
+  mux.ignoreStream('phishing')
+
   // connect to async provider
-  const asyncProvider = self.asyncProvider = new StreamProvider()
-  pipe(
-    asyncProvider,
-    multiStream.createStream('provider'),
-    asyncProvider,
+  const streamMiddleware = createStreamMiddleware()
+  pump(
+    streamMiddleware.stream,
+    mux.createStream('provider'),
+    streamMiddleware.stream,
     (err) => logStreamDisconnectWarning('MetaMask RpcProvider', err)
   )
 
-  self.idMap = {}
-  // handle sendAsync requests via asyncProvider
-  self.sendAsync = function (payload, cb) {
-    // rewrite request ids
-    var request = eachJsonMessage(payload, (message) => {
-      var newId = createRandomId()
-      self.idMap[newId] = message.id
-      message.id = newId
-      return message
-    })
-    // forward to asyncProvider
-    asyncProvider.sendAsync(request, function (err, res) {
-      if (err) return cb(err)
-      // transform messages to original ids
-      eachJsonMessage(res, (message) => {
-        var oldId = self.idMap[message.id]
-        delete self.idMap[message.id]
-        message.id = oldId
-        return message
-      })
-      cb(null, res)
-    })
-  }
+  // handle sendAsync requests via dapp-side rpc engine
+  const rpcEngine = new RpcEngine()
+  rpcEngine.push(createIdRemapMiddleware())
+  rpcEngine.push(streamMiddleware)
+  self.rpcEngine = rpcEngine
+}
+
+// handle sendAsync requests via asyncProvider
+// also remap ids inbound and outbound
+MetamaskInpageProvider.prototype.sendAsync = function (payload, cb) {
+  const self = this
+  self.rpcEngine.handle(payload, cb)
 }
 
+
 MetamaskInpageProvider.prototype.send = function (payload) {
   const self = this
 
@@ -76,7 +72,7 @@ MetamaskInpageProvider.prototype.send = function (payload) {
     case 'eth_coinbase':
       // read from localStorage
       selectedAddress = self.publicConfigStore.getState().selectedAddress
-      result = selectedAddress
+      result = selectedAddress || null
       break
 
     case 'eth_uninstallFilter':
@@ -85,8 +81,8 @@ MetamaskInpageProvider.prototype.send = function (payload) {
       break
 
     case 'net_version':
-      let networkVersion = self.publicConfigStore.getState().networkVersion
-      result = networkVersion
+      const networkVersion = self.publicConfigStore.getState().networkVersion
+      result = networkVersion || null
       break
 
     // throw not-supported Error
@@ -105,10 +101,6 @@ MetamaskInpageProvider.prototype.send = function (payload) {
   }
 }
 
-MetamaskInpageProvider.prototype.sendAsync = function () {
-  throw new Error('MetamaskInpageProvider - sendAsync not overwritten')
-}
-
 MetamaskInpageProvider.prototype.isConnected = function () {
   return true
 }
@@ -117,15 +109,7 @@ MetamaskInpageProvider.prototype.isMetaMask = true
 
 // util
 
-function eachJsonMessage (payload, transformFn) {
-  if (Array.isArray(payload)) {
-    return payload.map(transformFn)
-  } else {
-    return transformFn(payload)
-  }
-}
-
-function logStreamDisconnectWarning(remoteLabel, err){
+function logStreamDisconnectWarning (remoteLabel, err) {
   let warningMsg = `MetamaskInpageProvider - lost connection to ${remoteLabel}`
   if (err) warningMsg += '\n' + err.stack
   console.warn(warningMsg)
diff --git a/app/scripts/lib/is-popup-or-notification.js b/app/scripts/lib/is-popup-or-notification.js
index 693fa8751..e2999411f 100644
--- a/app/scripts/lib/is-popup-or-notification.js
+++ b/app/scripts/lib/is-popup-or-notification.js
@@ -1,6 +1,9 @@
 module.exports = function isPopupOrNotification () {
   const url = window.location.href
-  if (url.match(/popup.html$/)) {
+  // if (url.match(/popup.html$/) || url.match(/home.html$/)) {
+  // Below regexes needed for feature toggles (e.g. see line ~340 in ui/app/app.js)
+  // Revert below regexes to above commented out regexes before merge to master
+  if (url.match(/popup.html(?:\?.+)*$/) || url.match(/home.html(?:\?.+)*$/)) {
     return 'popup'
   } else {
     return 'notification'
diff --git a/app/scripts/lib/message-manager.js b/app/scripts/lib/message-manager.js
index 711d5f159..f52e048e0 100644
--- a/app/scripts/lib/message-manager.js
+++ b/app/scripts/lib/message-manager.js
@@ -4,7 +4,7 @@ const ethUtil = require('ethereumjs-util')
 const createId = require('./random-id')
 
 
-module.exports = class MessageManager extends EventEmitter{
+module.exports = class MessageManager extends EventEmitter {
   constructor (opts) {
     super()
     this.memStore = new ObservableStore({
@@ -108,7 +108,7 @@ module.exports = class MessageManager extends EventEmitter{
 
 }
 
-function normalizeMsgData(data) {
+function normalizeMsgData (data) {
   if (data.slice(0, 2) === '0x') {
     // data is already hex
     return data
diff --git a/app/scripts/lib/migrator/index.js b/app/scripts/lib/migrator/index.js
index 312345263..4fd2cae92 100644
--- a/app/scripts/lib/migrator/index.js
+++ b/app/scripts/lib/migrator/index.js
@@ -1,42 +1,35 @@
-const asyncQ = require('async-q')
-
 class Migrator {
 
   constructor (opts = {}) {
-    let migrations = opts.migrations || []
+    const migrations = opts.migrations || []
+    // sort migrations by version
     this.migrations = migrations.sort((a, b) => a.version - b.version)
-    let lastMigration = this.migrations.slice(-1)[0]
+    // grab migration with highest version
+    const lastMigration = this.migrations.slice(-1)[0]
     // use specified defaultVersion or highest migration version
     this.defaultVersion = opts.defaultVersion || (lastMigration && lastMigration.version) || 0
   }
 
   // run all pending migrations on meta in place
-  migrateData (versionedData = this.generateInitialState()) {
-    let remaining = this.migrations.filter(migrationIsPending)
-    
-    return (
-      asyncQ.eachSeries(remaining, (migration) => this.runMigration(versionedData, migration))
-      .then(() => versionedData)
-    )
-
-    // migration is "pending" if hit has a higher
+  async migrateData (versionedData = this.generateInitialState()) {
+    const pendingMigrations = this.migrations.filter(migrationIsPending)
+
+    for (const index in pendingMigrations) {
+      const migration = pendingMigrations[index]
+      versionedData = await migration.migrate(versionedData)
+      if (!versionedData.data) throw new Error('Migrator - migration returned empty data')
+      if (versionedData.version !== undefined && versionedData.meta.version !== migration.version) throw new Error('Migrator - Migration did not update version number correctly')
+    }
+
+    return versionedData
+
+    // migration is "pending" if it has a higher
     // version number than currentVersion
-    function migrationIsPending(migration) {
+    function migrationIsPending (migration) {
       return migration.version > versionedData.meta.version
     }
   }
 
-  runMigration(versionedData, migration) {
-    return (
-      migration.migrate(versionedData)
-      .then((versionedData) => {
-        if (!versionedData.data) return Promise.reject(new Error('Migrator - Migration returned empty data'))
-        if (migration.version !== undefined && versionedData.meta.version !== migration.version) return Promise.reject(new Error('Migrator - Migration did not update version number correctly'))
-        return Promise.resolve(versionedData)
-      })
-    )
-  }
-
   generateInitialState (initState) {
     return {
       meta: {
diff --git a/app/scripts/lib/nodeify.js b/app/scripts/lib/nodeify.js
index 51d89a8fb..9b595d93c 100644
--- a/app/scripts/lib/nodeify.js
+++ b/app/scripts/lib/nodeify.js
@@ -1,24 +1,18 @@
-module.exports = function (promiseFn) {
-  return function () {
-    var args = []
-    for (var i = 0; i < arguments.length - 1; i++) {
-      args.push(arguments[i])
-    }
-    var cb = arguments[arguments.length - 1]
-
-    const nodeified = promiseFn.apply(this, args)
+const promiseToCallback = require('promise-to-callback')
+const noop = function () {}
 
-    if (!nodeified) {
-      const methodName = String(promiseFn).split('(')[0]
-      throw new Error(`The ${methodName} did not return a Promise, but was nodeified.`)
+module.exports = function nodeify (fn, context) {
+  return function () {
+    const args = [].slice.call(arguments)
+    const lastArg = args[args.length - 1]
+    const lastArgIsCallback = typeof lastArg === 'function'
+    let callback
+    if (lastArgIsCallback) {
+      callback = lastArg
+      args.pop()
+    } else {
+      callback = noop
     }
-    nodeified.then(function (result) {
-      cb(null, result)
-    })
-    .catch(function (reason) {
-      cb(reason)
-    })
-
-    return nodeified
+    promiseToCallback(fn.apply(context, args))(callback)
   }
 }
diff --git a/app/scripts/lib/nonce-tracker.js b/app/scripts/lib/nonce-tracker.js
new file mode 100644
index 000000000..ed9dd3f11
--- /dev/null
+++ b/app/scripts/lib/nonce-tracker.js
@@ -0,0 +1,149 @@
+const EthQuery = require('ethjs-query')
+const assert = require('assert')
+const Mutex = require('await-semaphore').Mutex
+
+class NonceTracker {
+
+  constructor ({ provider, getPendingTransactions, getConfirmedTransactions }) {
+    this.provider = provider
+    this.ethQuery = new EthQuery(provider)
+    this.getPendingTransactions = getPendingTransactions
+    this.getConfirmedTransactions = getConfirmedTransactions
+    this.lockMap = {}
+  }
+
+  async getGlobalLock () {
+    const globalMutex = this._lookupMutex('global')
+    // await global mutex free
+    const releaseLock = await globalMutex.acquire()
+    return { releaseLock }
+  }
+
+  // releaseLock must be called
+  // releaseLock must be called after adding signed tx to pending transactions (or discarding)
+  async getNonceLock (address) {
+    // await global mutex free
+    await this._globalMutexFree()
+    // await lock free, then take lock
+    const releaseLock = await this._takeMutex(address)
+    // evaluate multiple nextNonce strategies
+    const nonceDetails = {}
+    const networkNonceResult = await this._getNetworkNextNonce(address)
+    const highestLocallyConfirmed = this._getHighestLocallyConfirmed(address)
+    const nextNetworkNonce = networkNonceResult.nonce
+    const highestLocalNonce = highestLocallyConfirmed
+    const highestSuggested = Math.max(nextNetworkNonce, highestLocalNonce)
+
+    const pendingTxs = this.getPendingTransactions(address)
+    const localNonceResult = this._getHighestContinuousFrom(pendingTxs, highestSuggested) || 0
+
+    nonceDetails.params = {
+      highestLocalNonce,
+      highestSuggested,
+      nextNetworkNonce,
+    }
+    nonceDetails.local = localNonceResult
+    nonceDetails.network = networkNonceResult
+
+    const nextNonce = Math.max(networkNonceResult.nonce, localNonceResult.nonce)
+    assert(Number.isInteger(nextNonce), `nonce-tracker - nextNonce is not an integer - got: (${typeof nextNonce}) "${nextNonce}"`)
+
+    // return nonce and release cb
+    return { nextNonce, nonceDetails, releaseLock }
+  }
+
+  async _getCurrentBlock () {
+    const blockTracker = this._getBlockTracker()
+    const currentBlock = blockTracker.getCurrentBlock()
+    if (currentBlock) return currentBlock
+    return await new Promise((reject, resolve) => {
+      blockTracker.once('latest', resolve)
+    })
+  }
+
+  async _globalMutexFree () {
+    const globalMutex = this._lookupMutex('global')
+    const release = await globalMutex.acquire()
+    release()
+  }
+
+  async _takeMutex (lockId) {
+    const mutex = this._lookupMutex(lockId)
+    const releaseLock = await mutex.acquire()
+    return releaseLock
+  }
+
+  _lookupMutex (lockId) {
+    let mutex = this.lockMap[lockId]
+    if (!mutex) {
+      mutex = new Mutex()
+      this.lockMap[lockId] = mutex
+    }
+    return mutex
+  }
+
+  async _getNetworkNextNonce (address) {
+    // calculate next nonce
+    // we need to make sure our base count
+    // and pending count are from the same block
+    const currentBlock = await this._getCurrentBlock()
+    const blockNumber = currentBlock.blockNumber
+    const baseCountBN = await this.ethQuery.getTransactionCount(address, blockNumber || 'latest')
+    const baseCount = baseCountBN.toNumber()
+    assert(Number.isInteger(baseCount), `nonce-tracker - baseCount is not an integer - got: (${typeof baseCount}) "${baseCount}"`)
+    const nonceDetails = { blockNumber, baseCount }
+    return { name: 'network', nonce: baseCount, details: nonceDetails }
+  }
+
+  _getHighestLocallyConfirmed (address) {
+    const confirmedTransactions = this.getConfirmedTransactions(address)
+    const highest = this._getHighestNonce(confirmedTransactions)
+    return Number.isInteger(highest) ? highest + 1 : 0
+  }
+
+  _reduceTxListToUniqueNonces (txList) {
+    const reducedTxList = txList.reduce((reducedList, txMeta, index) => {
+      if (!index) return [txMeta]
+      const nonceMatches = txList.filter((txData) => {
+        return txMeta.txParams.nonce === txData.txParams.nonce
+      })
+      if (nonceMatches.length > 1) return reducedList
+      reducedList.push(txMeta)
+      return reducedList
+    }, [])
+    return reducedTxList
+  }
+
+  _getHighestNonce (txList) {
+    const nonces = txList.map((txMeta) => {
+      const nonce = txMeta.txParams.nonce
+      assert(typeof nonce, 'string', 'nonces should be hex strings')
+      return parseInt(nonce, 16)
+    })
+    const highestNonce = Math.max.apply(null, nonces)
+    return highestNonce
+  }
+
+  _getHighestContinuousFrom (txList, startPoint) {
+    const nonces = txList.map((txMeta) => {
+      const nonce = txMeta.txParams.nonce
+      assert(typeof nonce, 'string', 'nonces should be hex strings')
+      return parseInt(nonce, 16)
+    })
+
+    let highest = startPoint
+    while (nonces.includes(highest)) {
+      highest++
+    }
+
+    return { name: 'local', nonce: highest, details: { startPoint, highest } }
+  }
+
+  // this is a hotfix for the fact that the blockTracker will
+  // change when the network changes
+  _getBlockTracker () {
+    return this.provider._blockTracker
+  }
+}
+
+module.exports = NonceTracker
diff --git a/app/scripts/lib/notification-manager.js b/app/scripts/lib/notification-manager.js
index 55e5b8dd2..adaf60c65 100644
--- a/app/scripts/lib/notification-manager.js
+++ b/app/scripts/lib/notification-manager.js
@@ -1,5 +1,5 @@
 const extension = require('extensionizer')
-const height = 520
+const height = 620
 const width = 360
 
 
@@ -24,9 +24,6 @@ class NotificationManager {
           width,
           height,
         })
-        .catch((reason) => {
-          log.error('failed to create poupup', reason)
-        })
       }
     })
   }
@@ -71,4 +68,4 @@ class NotificationManager {
 
 }
 
-module.exports = NotificationManager
\ No newline at end of file
+module.exports = NotificationManager
diff --git a/app/scripts/lib/obj-multiplex.js b/app/scripts/lib/obj-multiplex.js
deleted file mode 100644
index bd114c394..000000000
--- a/app/scripts/lib/obj-multiplex.js
+++ /dev/null
@@ -1,44 +0,0 @@
-const through = require('through2')
-
-module.exports = ObjectMultiplex
-
-function ObjectMultiplex (opts) {
-  opts = opts || {}
-  // create multiplexer
-  var mx = through.obj(function (chunk, enc, cb) {
-    var name = chunk.name
-    var data = chunk.data
-    var substream = mx.streams[name]
-    if (!substream) {
-      console.warn(`orphaned data for stream "${name}"`)
-    } else {
-      if (substream.push) substream.push(data)
-    }
-    return cb()
-  })
-  mx.streams = {}
-  // create substreams
-  mx.createStream = function (name) {
-    var substream = mx.streams[name] = through.obj(function (chunk, enc, cb) {
-      mx.push({
-        name: name,
-        data: chunk,
-      })
-      return cb()
-    })
-    mx.on('end', function () {
-      return substream.emit('end')
-    })
-    if (opts.error) {
-      mx.on('error', function () {
-        return substream.emit('error')
-      })
-    }
-    return substream
-  }
-  // ignore streams (dont display orphaned data warning)
-  mx.ignoreStream = function (name) {
-    mx.streams[name] = true
-  }
-  return mx
-}
diff --git a/app/scripts/lib/pending-balance-calculator.js b/app/scripts/lib/pending-balance-calculator.js
new file mode 100644
index 000000000..6ae526463
--- /dev/null
+++ b/app/scripts/lib/pending-balance-calculator.js
@@ -0,0 +1,51 @@
+const BN = require('ethereumjs-util').BN
+const normalize = require('eth-sig-util').normalize
+
+class PendingBalanceCalculator {
+
+  // Must be initialized with two functions:
+  // getBalance => Returns a promise of a BN of the current balance in Wei
+  // getPendingTransactions => Returns an array of TxMeta Objects,
+  // which have txParams properties, which include value, gasPrice, and gas,
+  // all in a base=16 hex format.
+  constructor ({ getBalance, getPendingTransactions }) {
+    this.getPendingTransactions = getPendingTransactions
+    this.getNetworkBalance = getBalance
+  }
+
+  async getBalance () {
+    const results = await Promise.all([
+      this.getNetworkBalance(),
+      this.getPendingTransactions(),
+    ])
+
+    const [ balance, pending ] = results
+    if (!balance) return undefined
+
+    const pendingValue = pending.reduce((total, tx) => {
+      return total.add(this.calculateMaxCost(tx))
+    }, new BN(0))
+
+    return `0x${balance.sub(pendingValue).toString(16)}`
+  }
+
+  calculateMaxCost (tx) {
+    const txValue = tx.txParams.value
+    const value = this.hexToBn(txValue)
+    const gasPrice = this.hexToBn(tx.txParams.gasPrice)
+
+    const gas = tx.txParams.gas
+    const gasLimit = tx.txParams.gasLimit
+    const gasLimitBn = this.hexToBn(gas || gasLimit)
+
+    const gasCost = gasPrice.mul(gasLimitBn)
+    return value.add(gasCost)
+  }
+
+  hexToBn (hex) {
+    return new BN(normalize(hex).substring(2), 16)
+  }
+
+}
+
+module.exports = PendingBalanceCalculator
diff --git a/app/scripts/lib/pending-tx-tracker.js b/app/scripts/lib/pending-tx-tracker.js
new file mode 100644
index 000000000..e8869e6b8
--- /dev/null
+++ b/app/scripts/lib/pending-tx-tracker.js
@@ -0,0 +1,189 @@
+const EventEmitter = require('events')
+const EthQuery = require('ethjs-query')
+/*
+
+  Utility class for tracking the transactions as they
+  go from a pending state to a confirmed (mined in a block) state
+
+  As well as continues broadcast while in the pending state
+
+                ~config is not optional~
+  requires a: {
+    provider: //,
+    nonceTracker: //see nonce tracker,
+    getPendingTransactions: //() a function for getting an array of transactions,
+    publishTransaction: //(rawTx) a async function for publishing raw transactions,
+  }
+
+*/
+
+module.exports = class PendingTransactionTracker extends EventEmitter {
+  constructor (config) {
+    super()
+    this.query = new EthQuery(config.provider)
+    this.nonceTracker = config.nonceTracker
+    // default is one day
+    this.getPendingTransactions = config.getPendingTransactions
+    this.getCompletedTransactions = config.getCompletedTransactions
+    this.publishTransaction = config.publishTransaction
+    this._checkPendingTxs()
+  }
+
+  //  checks if a signed tx is in a block and
+  // if included sets the tx status as 'confirmed'
+  checkForTxInBlock (block) {
+    const signedTxList = this.getPendingTransactions()
+    if (!signedTxList.length) return
+    signedTxList.forEach((txMeta) => {
+      const txHash = txMeta.hash
+      const txId = txMeta.id
+
+      if (!txHash) {
+        const noTxHashErr = new Error('We had an error while submitting this transaction, please try again.')
+        noTxHashErr.name = 'NoTxHashError'
+        this.emit('tx:failed', txId, noTxHashErr)
+        return
+      }
+
+
+      block.transactions.forEach((tx) => {
+        if (tx.hash === txHash) this.emit('tx:confirmed', txId)
+      })
+    })
+  }
+
+  queryPendingTxs ({ oldBlock, newBlock }) {
+    // check pending transactions on start
+    if (!oldBlock) {
+      this._checkPendingTxs()
+      return
+    }
+    // if we synced by more than one block, check for missed pending transactions
+    const diff = Number.parseInt(newBlock.number, 16) - Number.parseInt(oldBlock.number, 16)
+    if (diff > 1) this._checkPendingTxs()
+  }
+
+
+  resubmitPendingTxs (block) {
+    const pending = this.getPendingTransactions()
+    // only try resubmitting if their are transactions to resubmit
+    if (!pending.length) return
+    pending.forEach((txMeta) => this._resubmitTx(txMeta, block.number).catch((err) => {
+      /*
+      Dont marked as failed if the error is a "known" transaction warning
+      "there is already a transaction with the same sender-nonce
+      but higher/same gas price"
+
+      Also don't mark as failed if it has ever been broadcast successfully.
+      A successful broadcast means it may still be mined.
+      */
+      const errorMessage = err.message.toLowerCase()
+      const isKnownTx = (
+        // geth
+        errorMessage.includes('replacement transaction underpriced') ||
+        errorMessage.includes('known transaction') ||
+        // parity
+        errorMessage.includes('gas price too low to replace') ||
+        errorMessage.includes('transaction with the same hash was already imported') ||
+        // other
+        errorMessage.includes('gateway timeout') ||
+        errorMessage.includes('nonce too low')
+      )
+      // ignore resubmit warnings, return early
+      if (isKnownTx) return
+      // encountered real error - transition to error state
+      txMeta.warning = {
+        error: errorMessage,
+        message: 'There was an error when resubmitting this transaction.',
+      }
+      this.emit('tx:warning', txMeta, err)
+    }))
+  }
+
+  async _resubmitTx (txMeta, latestBlockNumber) {
+    if (!txMeta.firstRetryBlockNumber) {
+      this.emit('tx:block-update', txMeta, latestBlockNumber)
+    }
+
+    const firstRetryBlockNumber = txMeta.firstRetryBlockNumber || latestBlockNumber
+    const txBlockDistance = Number.parseInt(latestBlockNumber, 16) - Number.parseInt(firstRetryBlockNumber, 16)
+
+    const retryCount = txMeta.retryCount || 0
+
+    // Exponential backoff to limit retries at publishing
+    if (txBlockDistance <= Math.pow(2, retryCount) - 1) return
+
+    // Only auto-submit already-signed txs:
+    if (!('rawTx' in txMeta)) return
+
+    const rawTx = txMeta.rawTx
+    const txHash = await this.publishTransaction(rawTx)
+
+    // Increment successful tries:
+    this.emit('tx:retry', txMeta)
+    return txHash
+  }
+
+  async _checkPendingTx (txMeta) {
+    const txHash = txMeta.hash
+    const txId = txMeta.id
+
+    // extra check in case there was an uncaught error during the
+    // signature and submission process
+    if (!txHash) {
+      const noTxHashErr = new Error('We had an error while submitting this transaction, please try again.')
+      noTxHashErr.name = 'NoTxHashError'
+      this.emit('tx:failed', txId, noTxHashErr)
+      return
+    }
+
+    // If another tx with the same nonce is mined, set as failed.
+    const taken = await this._checkIfNonceIsTaken(txMeta)
+    if (taken) {
+      const nonceTakenErr = new Error('Another transaction with this nonce has been mined.')
+      nonceTakenErr.name = 'NonceTakenErr'
+      return this.emit('tx:failed', txId, nonceTakenErr)
+    }
+
+    // get latest transaction status
+    let txParams
+    try {
+      txParams = await this.query.getTransactionByHash(txHash)
+      if (!txParams) return
+      if (txParams.blockNumber) {
+        this.emit('tx:confirmed', txId)
+      }
+    } catch (err) {
+      txMeta.warning = {
+        error: err.message,
+        message: 'There was a problem loading this transaction.',
+      }
+      this.emit('tx:warning', txMeta, err)
+    }
+  }
+
+  // checks the network for signed txs and
+  // if confirmed sets the tx status as 'confirmed'
+  async _checkPendingTxs () {
+    const signedTxList = this.getPendingTransactions()
+    // in order to keep the nonceTracker accurate we block it while updating pending transactions
+    const nonceGlobalLock = await this.nonceTracker.getGlobalLock()
+    try {
+      await Promise.all(signedTxList.map((txMeta) => this._checkPendingTx(txMeta)))
+    } catch (err) {
+      console.error('PendingTransactionWatcher - Error updating pending transactions')
+      console.error(err)
+    }
+    nonceGlobalLock.releaseLock()
+  }
+
+  async _checkIfNonceIsTaken (txMeta) {
+    const address = txMeta.txParams.from
+    const completed = this.getCompletedTransactions(address)
+    const sameNonce = completed.filter((otherMeta) => {
+      return otherMeta.txParams.nonce === txMeta.txParams.nonce
+    })
+    return sameNonce.length > 0
+  }
+
+}
diff --git a/app/scripts/lib/personal-message-manager.js b/app/scripts/lib/personal-message-manager.js
index bbc978446..6602f5aa8 100644
--- a/app/scripts/lib/personal-message-manager.js
+++ b/app/scripts/lib/personal-message-manager.js
@@ -5,7 +5,7 @@ const createId = require('./random-id')
 const hexRe = /^[0-9A-Fa-f]+$/g
 
 
-module.exports = class PersonalMessageManager extends EventEmitter{
+module.exports = class PersonalMessageManager extends EventEmitter {
   constructor (opts) {
     super()
     this.memStore = new ObservableStore({
@@ -108,7 +108,7 @@ module.exports = class PersonalMessageManager extends EventEmitter{
     this.emit('updateBadge')
   }
 
-  normalizeMsgData(data) {
+  normalizeMsgData (data) {
     try {
       const stripped = ethUtil.stripHexPrefix(data)
       if (stripped.match(hexRe)) {
diff --git a/app/scripts/lib/port-stream.js b/app/scripts/lib/port-stream.js
index 607a9c9ed..a9716fb00 100644
--- a/app/scripts/lib/port-stream.js
+++ b/app/scripts/lib/port-stream.js
@@ -1,5 +1,6 @@
 const Duplex = require('readable-stream').Duplex
 const inherits = require('util').inherits
+const noop = function () {}
 
 module.exports = PortDuplexStream
 
@@ -20,20 +21,14 @@ PortDuplexStream.prototype._onMessage = function (msg) {
   if (Buffer.isBuffer(msg)) {
     delete msg._isBuffer
     var data = new Buffer(msg)
-    // console.log('PortDuplexStream - saw message as buffer', data)
     this.push(data)
   } else {
-    // console.log('PortDuplexStream - saw message', msg)
     this.push(msg)
   }
 }
 
 PortDuplexStream.prototype._onDisconnect = function () {
-  try {
-    this.push(null)
-  } catch (err) {
-    this.emit('error', err)
-  }
+  this.destroy()
 }
 
 // stream plumbing
@@ -45,19 +40,12 @@ PortDuplexStream.prototype._write = function (msg, encoding, cb) {
     if (Buffer.isBuffer(msg)) {
       var data = msg.toJSON()
       data._isBuffer = true
-      // console.log('PortDuplexStream - sent message as buffer', data)
       this._port.postMessage(data)
     } else {
-      // console.log('PortDuplexStream - sent message', msg)
       this._port.postMessage(msg)
     }
   } catch (err) {
-    // console.error(err)
     return cb(new Error('PortDuplexStream - disconnected'))
   }
   cb()
 }
-
-// util
-
-function noop () {}
diff --git a/app/scripts/lib/setupMetamaskMeshMetrics.js b/app/scripts/lib/setupMetamaskMeshMetrics.js
new file mode 100644
index 000000000..40343f017
--- /dev/null
+++ b/app/scripts/lib/setupMetamaskMeshMetrics.js
@@ -0,0 +1,9 @@
+
+module.exports = setupMetamaskMeshMetrics
+
+function setupMetamaskMeshMetrics() {
+  const testingContainer = document.createElement('iframe')
+  testingContainer.src = 'https://metamask.github.io/mesh-testing/'
+  console.log('Injecting MetaMask Mesh testing client')
+  document.head.appendChild(testingContainer)
+}
diff --git a/app/scripts/lib/stream-utils.js b/app/scripts/lib/stream-utils.js
index ba79990cc..8bb0b4f3c 100644
--- a/app/scripts/lib/stream-utils.js
+++ b/app/scripts/lib/stream-utils.js
@@ -1,6 +1,6 @@
 const Through = require('through2')
-const endOfStream = require('end-of-stream')
-const ObjectMultiplex = require('./obj-multiplex')
+const ObjectMultiplex = require('obj-multiplex')
+const pump = require('pump')
 
 module.exports = {
   jsonParseStream: jsonParseStream,
@@ -23,14 +23,14 @@ function jsonStringifyStream () {
 }
 
 function setupMultiplex (connectionStream) {
-  var mx = ObjectMultiplex()
-  connectionStream.pipe(mx).pipe(connectionStream)
-  endOfStream(mx, function (err) {
-    if (err) console.error(err)
-  })
-  endOfStream(connectionStream, function (err) {
-    if (err) console.error(err)
-    mx.destroy()
-  })
-  return mx
+  const mux = new ObjectMultiplex()
+  pump(
+    connectionStream,
+    mux,
+    connectionStream,
+    (err) => {
+      if (err) console.error(err)
+    }
+  )
+  return mux
 }
diff --git a/app/scripts/lib/tx-gas-utils.js b/app/scripts/lib/tx-gas-utils.js
new file mode 100644
index 000000000..6f6ff7852
--- /dev/null
+++ b/app/scripts/lib/tx-gas-utils.js
@@ -0,0 +1,125 @@
+const EthQuery = require('ethjs-query')
+const {
+  hexToBn,
+  BnMultiplyByFraction,
+  bnToHex,
+} = require('./util')
+const addHexPrefix = require('ethereumjs-util').addHexPrefix
+const SIMPLE_GAS_COST = '0x5208' // Hex for 21000, cost of a simple send.
+
+/*
+tx-utils are utility methods for Transaction manager
+its passed ethquery
+and used to do things like calculate gas of a tx.
+*/
+
+module.exports = class TxGasUtil {
+
+  constructor (provider) {
+    this.query = new EthQuery(provider)
+  }
+
+  async analyzeGasUsage (txMeta) {
+    const block = await this.query.getBlockByNumber('latest', true)
+    let estimatedGasHex
+    try {
+      estimatedGasHex = await this.estimateTxGas(txMeta, block.gasLimit)
+    } catch (err) {
+      const simulationFailed = (
+        err.message.includes('Transaction execution error.') ||
+        err.message.includes('gas required exceeds allowance or always failing transaction')
+      )
+      if (simulationFailed) {
+        txMeta.simulationFails = true
+        return txMeta
+      }
+    }
+    this.setTxGas(txMeta, block.gasLimit, estimatedGasHex)
+    return txMeta
+  }
+
+  async estimateTxGas (txMeta, blockGasLimitHex) {
+    const txParams = txMeta.txParams
+
+    // check if gasLimit is already specified
+    txMeta.gasLimitSpecified = Boolean(txParams.gas)
+
+    // if it is, use that value
+    if (txMeta.gasLimitSpecified) {
+      return txParams.gas
+    }
+
+    // if recipient has no code, gas is 21k max:
+    const recipient = txParams.to
+    const hasRecipient = Boolean(recipient)
+    const code = await this.query.getCode(recipient)
+    if (hasRecipient && (!code || code === '0x')) {
+      txParams.gas = SIMPLE_GAS_COST
+      txMeta.simpleSend = true // Prevents buffer addition
+      return SIMPLE_GAS_COST
+    }
+
+    // if not, fall back to block gasLimit
+    const blockGasLimitBN = hexToBn(blockGasLimitHex)
+    const saferGasLimitBN = BnMultiplyByFraction(blockGasLimitBN, 19, 20)
+    txParams.gas = bnToHex(saferGasLimitBN)
+
+    // run tx
+    return await this.query.estimateGas(txParams)
+  }
+
+  setTxGas (txMeta, blockGasLimitHex, estimatedGasHex) {
+    txMeta.estimatedGas = addHexPrefix(estimatedGasHex)
+    const txParams = txMeta.txParams
+
+    // if gasLimit was specified and doesnt OOG,
+    // use original specified amount
+    if (txMeta.gasLimitSpecified || txMeta.simpleSend) {
+      txMeta.estimatedGas = txParams.gas
+      return
+    }
+    // if gasLimit not originally specified,
+    // try adding an additional gas buffer to our estimation for safety
+    const recommendedGasHex = this.addGasBuffer(txMeta.estimatedGas, blockGasLimitHex)
+    txParams.gas = recommendedGasHex
+    return
+  }
+
+  addGasBuffer (initialGasLimitHex, blockGasLimitHex) {
+    const initialGasLimitBn = hexToBn(initialGasLimitHex)
+    const blockGasLimitBn = hexToBn(blockGasLimitHex)
+    const upperGasLimitBn = blockGasLimitBn.muln(0.9)
+    const bufferedGasLimitBn = initialGasLimitBn.muln(1.5)
+
+    // if initialGasLimit is above blockGasLimit, dont modify it
+    if (initialGasLimitBn.gt(upperGasLimitBn)) return bnToHex(initialGasLimitBn)
+    // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
+    if (bufferedGasLimitBn.lt(upperGasLimitBn)) return bnToHex(bufferedGasLimitBn)
+    // otherwise use blockGasLimit
+    return bnToHex(upperGasLimitBn)
+  }
+
+  async validateTxParams (txParams) {
+    this.validateRecipient(txParams)
+    if ('value' in txParams) {
+      const value = txParams.value.toString()
+      if (value.includes('-')) {
+        throw new Error(`Invalid transaction value of ${txParams.value} not a positive number.`)
+      }
+
+      if (value.includes('.')) {
+        throw new Error(`Invalid transaction value of ${txParams.value} number must be in wei`)
+      }
+    }
+  }
+  validateRecipient (txParams) {
+    if (txParams.to === '0x') {
+      if (txParams.data) {
+        delete txParams.to
+      } else {
+        throw new Error('Invalid recipient address')
+      }
+    }
+    return txParams
+  }
+}
diff --git a/app/scripts/lib/tx-state-history-helper.js b/app/scripts/lib/tx-state-history-helper.js
new file mode 100644
index 000000000..94c7b6792
--- /dev/null
+++ b/app/scripts/lib/tx-state-history-helper.js
@@ -0,0 +1,41 @@
+const jsonDiffer = require('fast-json-patch')
+const clone = require('clone')
+
+module.exports = {
+  generateHistoryEntry,
+  replayHistory,
+  snapshotFromTxMeta,
+  migrateFromSnapshotsToDiffs,
+}
+
+
+function migrateFromSnapshotsToDiffs (longHistory) {
+  return (
+    longHistory
+    // convert non-initial history entries into diffs
+    .map((entry, index) => {
+      if (index === 0) return entry
+      return generateHistoryEntry(longHistory[index - 1], entry)
+    })
+  )
+}
+
+function generateHistoryEntry (previousState, newState, note) {
+  const entry = jsonDiffer.compare(previousState, newState)
+  // Add a note to the first op, since it breaks if we append it to the entry
+  if (note && entry[0]) entry[0].note = note
+  return entry
+}
+
+function replayHistory (_shortHistory) {
+  const shortHistory = clone(_shortHistory)
+  return shortHistory.reduce((val, entry) => jsonDiffer.applyPatch(val, entry).newDocument)
+}
+
+function snapshotFromTxMeta (txMeta) {
+  // create txMeta snapshot for history
+  const snapshot = clone(txMeta)
+  // dont include previous history in this snapshot
+  delete snapshot.history
+  return snapshot
+}
diff --git a/app/scripts/lib/tx-state-manager.js b/app/scripts/lib/tx-state-manager.js
new file mode 100644
index 000000000..051efd247
--- /dev/null
+++ b/app/scripts/lib/tx-state-manager.js
@@ -0,0 +1,266 @@
+const extend = require('xtend')
+const EventEmitter = require('events')
+const ObservableStore = require('obs-store')
+const ethUtil = require('ethereumjs-util')
+const txStateHistoryHelper = require('./tx-state-history-helper')
+
+module.exports = class TransactionStateManger extends EventEmitter {
+  constructor ({ initState, txHistoryLimit, getNetwork }) {
+    super()
+
+    this.store = new ObservableStore(
+      extend({
+        transactions: [],
+    }, initState))
+    this.txHistoryLimit = txHistoryLimit
+    this.getNetwork = getNetwork
+  }
+
+  // Returns the number of txs for the current network.
+  getTxCount () {
+    return this.getTxList().length
+  }
+
+  getTxList () {
+    const network = this.getNetwork()
+    const fullTxList = this.getFullTxList()
+    return fullTxList.filter((txMeta) => txMeta.metamaskNetworkId === network)
+  }
+
+  getFullTxList () {
+    return this.store.getState().transactions
+  }
+
+  // Returns the tx list
+  getUnapprovedTxList () {
+    const txList = this.getTxsByMetaData('status', 'unapproved')
+    return txList.reduce((result, tx) => {
+      result[tx.id] = tx
+      return result
+    }, {})
+  }
+
+  getPendingTransactions (address) {
+    const opts = { status: 'submitted' }
+    if (address) opts.from = address
+    return this.getFilteredTxList(opts)
+  }
+
+  getConfirmedTransactions (address) {
+    const opts = { status: 'confirmed' }
+    if (address) opts.from = address
+    return this.getFilteredTxList(opts)
+  }
+
+  addTx (txMeta) {
+    this.once(`${txMeta.id}:signed`, function (txId) {
+      this.removeAllListeners(`${txMeta.id}:rejected`)
+    })
+    this.once(`${txMeta.id}:rejected`, function (txId) {
+      this.removeAllListeners(`${txMeta.id}:signed`)
+    })
+    // initialize history
+    txMeta.history = []
+    // capture initial snapshot of txMeta for history
+    const snapshot = txStateHistoryHelper.snapshotFromTxMeta(txMeta)
+    txMeta.history.push(snapshot)
+
+    const transactions = this.getFullTxList()
+    const txCount = this.getTxCount()
+    const txHistoryLimit = this.txHistoryLimit
+
+    // checks if the length of the tx history is
+    // longer then desired persistence limit
+    // and then if it is removes only confirmed
+    // or rejected tx's.
+    // not tx's that are pending or unapproved
+    if (txCount > txHistoryLimit - 1) {
+      const index = transactions.findIndex((metaTx) => metaTx.status === 'confirmed' || metaTx.status === 'rejected')
+      transactions.splice(index, 1)
+    }
+    transactions.push(txMeta)
+    this._saveTxList(transactions)
+    return txMeta
+  }
+  // gets tx by Id and returns it
+  getTx (txId) {
+    const txMeta = this.getTxsByMetaData('id', txId)[0]
+    return txMeta
+  }
+
+  updateTx (txMeta, note) {
+    if (txMeta.txParams) {
+      Object.keys(txMeta.txParams).forEach((key) => {
+        const value = txMeta.txParams[key]
+        if (typeof value !== 'string') console.error(`${key}: ${value} in txParams is not a string`)
+        if (!ethUtil.isHexPrefixed(value)) console.error('is not hex prefixed, anything on txParams must be hex prefixed')
+      })
+    }
+
+    // create txMeta snapshot for history
+    const currentState = txStateHistoryHelper.snapshotFromTxMeta(txMeta)
+    // recover previous tx state obj
+    const previousState = txStateHistoryHelper.replayHistory(txMeta.history)
+    // generate history entry and add to history
+    const entry = txStateHistoryHelper.generateHistoryEntry(previousState, currentState, note)
+    txMeta.history.push(entry)
+
+    // commit txMeta to state
+    const txId = txMeta.id
+    const txList = this.getFullTxList()
+    const index = txList.findIndex(txData => txData.id === txId)
+    txList[index] = txMeta
+    this._saveTxList(txList)
+  }
+
+
+  // merges txParams obj onto txData.txParams
+  // use extend to ensure that all fields are filled
+  updateTxParams (txId, txParams) {
+    const txMeta = this.getTx(txId)
+    txMeta.txParams = extend(txMeta.txParams, txParams)
+    this.updateTx(txMeta, `txStateManager#updateTxParams`)
+  }
+
+/*
+  Takes an object of fields to search for eg:
+  let thingsToLookFor = {
+    to: '0x0..',
+    from: '0x0..',
+    status: 'signed',
+    err: undefined,
+  }
+  and returns a list of tx with all
+  options matching
+
+  ****************HINT****************
+  | `err: undefined` is like looking |
+  | for a tx with no err             |
+  | so you can also search txs that  |
+  | dont have something as well by   |
+  | setting the value as undefined   |
+  ************************************
+
+  this is for things like filtering a the tx list
+  for only tx's from 1 account
+  or for filltering for all txs from one account
+  and that have been 'confirmed'
+  */
+  getFilteredTxList (opts, initialList) {
+    let filteredTxList = initialList
+    Object.keys(opts).forEach((key) => {
+      filteredTxList = this.getTxsByMetaData(key, opts[key], filteredTxList)
+    })
+    return filteredTxList
+  }
+
+  getTxsByMetaData (key, value, txList = this.getTxList()) {
+    return txList.filter((txMeta) => {
+      if (txMeta.txParams[key]) {
+        return txMeta.txParams[key] === value
+      } else {
+        return txMeta[key] === value
+      }
+    })
+  }
+
+  // STATUS METHODS
+  // statuses:
+  //    - `'unapproved'` the user has not responded
+  //    - `'rejected'` the user has responded no!
+  //    - `'approved'` the user has approved the tx
+  //    - `'signed'` the tx is signed
+  //    - `'submitted'` the tx is sent to a server
+  //    - `'confirmed'` the tx has been included in a block.
+  //    - `'failed'` the tx failed for some reason, included on tx data.
+
+  // get::set status
+
+  // should return the status of the tx.
+  getTxStatus (txId) {
+    const txMeta = this.getTx(txId)
+    return txMeta.status
+  }
+
+  // should update the status of the tx to 'rejected'.
+  setTxStatusRejected (txId) {
+    this._setTxStatus(txId, 'rejected')
+  }
+
+  // should update the status of the tx to 'unapproved'.
+  setTxStatusUnapproved (txId) {
+    this._setTxStatus(txId, 'unapproved')
+  }
+  // should update the status of the tx to 'approved'.
+  setTxStatusApproved (txId) {
+    this._setTxStatus(txId, 'approved')
+  }
+
+  // should update the status of the tx to 'signed'.
+  setTxStatusSigned (txId) {
+    this._setTxStatus(txId, 'signed')
+  }
+
+  // should update the status of the tx to 'submitted'.
+  setTxStatusSubmitted (txId) {
+    this._setTxStatus(txId, 'submitted')
+  }
+
+  // should update the status of the tx to 'confirmed'.
+  setTxStatusConfirmed (txId) {
+    this._setTxStatus(txId, 'confirmed')
+  }
+
+  setTxStatusFailed (txId, err) {
+    const txMeta = this.getTx(txId)
+    txMeta.err = {
+      message: err.toString(),
+      stack: err.stack,
+    }
+    this.updateTx(txMeta)
+    this._setTxStatus(txId, 'failed')
+  }
+
+  wipeTransactions (address) {
+    // network only tx
+    const txs = this.getFullTxList()
+    const network = this.getNetwork()
+
+    // Filter out the ones from the current account and network
+    const otherAccountTxs = txs.filter((txMeta) => !(txMeta.txParams.from === address && txMeta.metamaskNetworkId === network))
+
+    // Update state
+    this._saveTxList(otherAccountTxs)
+  }
+//
+//           PRIVATE METHODS
+//
+
+  //  Should find the tx in the tx list and
+  //  update it.
+  //  should set the status in txData
+  //    - `'unapproved'` the user has not responded
+  //    - `'rejected'` the user has responded no!
+  //    - `'approved'` the user has approved the tx
+  //    - `'signed'` the tx is signed
+  //    - `'submitted'` the tx is sent to a server
+  //    - `'confirmed'` the tx has been included in a block.
+  //    - `'failed'` the tx failed for some reason, included on tx data.
+  _setTxStatus (txId, status) {
+    const txMeta = this.getTx(txId)
+    txMeta.status = status
+    this.emit(`${txMeta.id}:${status}`, txId)
+    this.emit(`tx:status-update`, txId, status)
+    if (['submitted', 'rejected', 'failed'].includes(status)) {
+      this.emit(`${txMeta.id}:finished`, txMeta)
+    }
+    this.updateTx(txMeta, `txStateManager: setting status to ${status}`)
+    this.emit('update:badge')
+  }
+
+  // Saves the new/updated txList.
+  // Function is intended only for internal use
+  _saveTxList (transactions) {
+    this.store.updateState({ transactions })
+  }
+}
diff --git a/app/scripts/lib/tx-utils.js b/app/scripts/lib/tx-utils.js
deleted file mode 100644
index e8e23f8b5..000000000
--- a/app/scripts/lib/tx-utils.js
+++ /dev/null
@@ -1,136 +0,0 @@
-const async = require('async')
-const EthQuery = require('eth-query')
-const ethUtil = require('ethereumjs-util')
-const Transaction = require('ethereumjs-tx')
-const normalize = require('eth-sig-util').normalize
-const BN = ethUtil.BN
-
-/*
-tx-utils are utility methods for Transaction manager
-its passed a provider and that is passed to ethquery
-and used to do things like calculate gas of a tx.
-*/
-
-module.exports = class txProviderUtils {
-
-  constructor (provider) {
-    this.provider = provider
-    this.query = new EthQuery(provider)
-  }
-
-  analyzeGasUsage (txMeta, cb) {
-    var self = this
-    this.query.getBlockByNumber('latest', true, (err, block) => {
-      if (err) return cb(err)
-      async.waterfall([
-        self.estimateTxGas.bind(self, txMeta, block.gasLimit),
-        self.setTxGas.bind(self, txMeta, block.gasLimit),
-      ], cb)
-    })
-  }
-
-  estimateTxGas (txMeta, blockGasLimitHex, cb) {
-    const txParams = txMeta.txParams
-    // check if gasLimit is already specified
-    txMeta.gasLimitSpecified = Boolean(txParams.gas)
-    // if not, fallback to block gasLimit
-    if (!txMeta.gasLimitSpecified) {
-      txParams.gas = blockGasLimitHex
-    }
-    // run tx, see if it will OOG
-    this.query.estimateGas(txParams, cb)
-  }
-
-  setTxGas (txMeta, blockGasLimitHex, estimatedGasHex, cb) {
-    txMeta.estimatedGas = estimatedGasHex
-    const txParams = txMeta.txParams
-
-    // if gasLimit was specified and doesnt OOG,
-    // use original specified amount
-    if (txMeta.gasLimitSpecified) {
-      txMeta.estimatedGas = txParams.gas
-      cb()
-      return
-    }
-    // if gasLimit not originally specified,
-    // try adding an additional gas buffer to our estimation for safety
-    const recommendedGasHex = this.addGasBuffer(txMeta.estimatedGas, blockGasLimitHex)
-    txParams.gas = recommendedGasHex
-    cb()
-    return
-  }
-
-  addGasBuffer (initialGasLimitHex, blockGasLimitHex) {
-    const initialGasLimitBn = hexToBn(initialGasLimitHex)
-    const blockGasLimitBn = hexToBn(blockGasLimitHex)
-    const upperGasLimitBn = blockGasLimitBn.muln(0.9)
-    const bufferedGasLimitBn = initialGasLimitBn.muln(1.5)
-
-    // if initialGasLimit is above blockGasLimit, dont modify it
-    if (initialGasLimitBn.gt(upperGasLimitBn)) return bnToHex(initialGasLimitBn)
-    // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
-    if (bufferedGasLimitBn.lt(upperGasLimitBn)) return bnToHex(bufferedGasLimitBn)
-    // otherwise use blockGasLimit
-    return bnToHex(upperGasLimitBn)
-  }
-
-  fillInTxParams (txParams, cb) {
-    let fromAddress = txParams.from
-    let reqs = {}
-
-    if (isUndef(txParams.gas)) reqs.gas = (cb) => this.query.estimateGas(txParams, cb)
-    if (isUndef(txParams.gasPrice)) reqs.gasPrice = (cb) => this.query.gasPrice(cb)
-    if (isUndef(txParams.nonce)) reqs.nonce = (cb) => this.query.getTransactionCount(fromAddress, 'pending', cb)
-
-    async.parallel(reqs, function(err, result) {
-      if (err) return cb(err)
-      // write results to txParams obj
-      Object.assign(txParams, result)
-      cb()
-    })
-  }
-
-  // builds ethTx from txParams object
-  buildEthTxFromParams (txParams) {
-    // normalize values
-    txParams.to = normalize(txParams.to)
-    txParams.from = normalize(txParams.from)
-    txParams.value = normalize(txParams.value)
-    txParams.data = normalize(txParams.data)
-    txParams.gas = normalize(txParams.gas || txParams.gasLimit)
-    txParams.gasPrice = normalize(txParams.gasPrice)
-    txParams.nonce = normalize(txParams.nonce)
-    // build ethTx
-    log.info(`Prepared tx for signing: ${JSON.stringify(txParams)}`)
-    const ethTx = new Transaction(txParams)
-    return ethTx
-  }
-
-  publishTransaction (rawTx, cb) {
-    this.query.sendRawTransaction(rawTx, cb)
-  }
-
-  validateTxParams (txParams, cb) {
-    if (('value' in txParams) && txParams.value.indexOf('-') === 0) {
-      cb(new Error(`Invalid transaction value of ${txParams.value} not a positive number.`))
-    } else {
-      cb()
-    }
-  }
-
-
-}
-
-// util
-
-function isUndef(value) {
-  return value === undefined
-}
-
-function bnToHex(inputBn) {
-  return ethUtil.addHexPrefix(inputBn.toString(16))
-}
-
-function hexToBn(inputHex) {
-  return new BN(ethUtil.stripHexPrefix(inputHex), 16)
-}
diff --git a/app/scripts/lib/typed-message-manager.js b/app/scripts/lib/typed-message-manager.js
new file mode 100644
index 000000000..8b760790e
--- /dev/null
+++ b/app/scripts/lib/typed-message-manager.js
@@ -0,0 +1,123 @@
+const EventEmitter = require('events')
+const ObservableStore = require('obs-store')
+const createId = require('./random-id')
+const assert = require('assert')
+const sigUtil = require('eth-sig-util')
+
+
+module.exports = class TypedMessageManager extends EventEmitter {
+  constructor (opts) {
+    super()
+    this.memStore = new ObservableStore({
+      unapprovedTypedMessages: {},
+      unapprovedTypedMessagesCount: 0,
+    })
+    this.messages = []
+  }
+
+  get unapprovedTypedMessagesCount () {
+    return Object.keys(this.getUnapprovedMsgs()).length
+  }
+
+  getUnapprovedMsgs () {
+    return this.messages.filter(msg => msg.status === 'unapproved')
+      .reduce((result, msg) => { result[msg.id] = msg; return result }, {})
+  }
+
+  addUnapprovedMessage (msgParams) {
+    this.validateParams(msgParams)
+
+    log.debug(`TypedMessageManager addUnapprovedMessage: ${JSON.stringify(msgParams)}`)
+    // 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: 'unapproved',
+      type: 'eth_signTypedData',
+    }
+    this.addMsg(msgData)
+
+    // signal update
+    this.emit('update')
+    return msgId
+  }
+
+  validateParams (params) {
+    assert.equal(typeof params, 'object', 'Params should ben an object.')
+    assert.ok('data' in params, 'Params must include a data field.')
+    assert.ok('from' in params, 'Params must include a from field.')
+    assert.ok(Array.isArray(params.data), 'Data should be an array.')
+    assert.equal(typeof params.from, 'string', 'From field must be a string.')
+    assert.doesNotThrow(() => {
+      sigUtil.typedSignatureHash(params.data)
+    }, 'Expected EIP712 typed data')
+  }
+
+  addMsg (msg) {
+    this.messages.push(msg)
+    this._saveMsgList()
+  }
+
+  getMsg (msgId) {
+    return this.messages.find(msg => msg.id === msgId)
+  }
+
+  approveMessage (msgParams) {
+    this.setMsgStatusApproved(msgParams.metamaskId)
+    return this.prepMsgForSigning(msgParams)
+  }
+
+  setMsgStatusApproved (msgId) {
+    this._setMsgStatus(msgId, 'approved')
+  }
+
+  setMsgStatusSigned (msgId, rawSig) {
+    const msg = this.getMsg(msgId)
+    msg.rawSig = rawSig
+    this._updateMsg(msg)
+    this._setMsgStatus(msgId, 'signed')
+  }
+
+  prepMsgForSigning (msgParams) {
+    delete msgParams.metamaskId
+    return Promise.resolve(msgParams)
+  }
+
+  rejectMsg (msgId) {
+    this._setMsgStatus(msgId, 'rejected')
+  }
+
+  //
+  // PRIVATE METHODS
+  //
+
+  _setMsgStatus (msgId, status) {
+    const msg = this.getMsg(msgId)
+    if (!msg) throw new Error('TypedMessageManager - Message not found for id: "${msgId}".')
+    msg.status = status
+    this._updateMsg(msg)
+    this.emit(`${msgId}:${status}`, msg)
+    if (status === 'rejected' || status === 'signed') {
+      this.emit(`${msgId}:finished`, msg)
+    }
+  }
+
+  _updateMsg (msg) {
+    const index = this.messages.findIndex((message) => message.id === msg.id)
+    if (index !== -1) {
+      this.messages[index] = msg
+    }
+    this._saveMsgList()
+  }
+
+  _saveMsgList () {
+    const unapprovedTypedMessages = this.getUnapprovedMsgs()
+    const unapprovedTypedMessagesCount = Object.keys(unapprovedTypedMessages).length
+    this.memStore.updateState({ unapprovedTypedMessages, unapprovedTypedMessagesCount })
+    this.emit('updateBadge')
+  }
+
+}
diff --git a/app/scripts/lib/util.js b/app/scripts/lib/util.js
new file mode 100644
index 000000000..6dee9edf0
--- /dev/null
+++ b/app/scripts/lib/util.js
@@ -0,0 +1,44 @@
+const ethUtil = require('ethereumjs-util')
+const assert = require('assert')
+const BN = require('bn.js')
+
+module.exports = {
+  getStack,
+  sufficientBalance,
+  hexToBn,
+  bnToHex,
+  BnMultiplyByFraction,
+}
+
+function getStack () {
+  const stack = new Error('Stack trace generator - not an error').stack
+  return stack
+}
+
+function sufficientBalance (txParams, hexBalance) {
+  // validate hexBalance is a hex string
+  assert.equal(typeof hexBalance, 'string', 'sufficientBalance - hexBalance is not a hex string')
+  assert.equal(hexBalance.slice(0, 2), '0x', 'sufficientBalance - hexBalance is not a hex string')
+
+  const balance = hexToBn(hexBalance)
+  const value = hexToBn(txParams.value)
+  const gasLimit = hexToBn(txParams.gas)
+  const gasPrice = hexToBn(txParams.gasPrice)
+
+  const maxCost = value.add(gasLimit.mul(gasPrice))
+  return balance.gte(maxCost)
+}
+
+function bnToHex (inputBn) {
+  return ethUtil.addHexPrefix(inputBn.toString(16))
+}
+
+function hexToBn (inputHex) {
+  return new BN(ethUtil.stripHexPrefix(inputHex), 16)
+}
+
+function BnMultiplyByFraction (targetBN, numerator, denominator) {
+  const numBN = new BN(numerator)
+  const denomBN = new BN(denominator)
+  return targetBN.mul(numBN).div(denomBN)
+}