fix merge conflicts

2024-12-23 09:52:26 +01:00 · 2018-08-17 12:56:07 -04:00 · 2018-08-17 12:56:07 -04:00 · 992e7f1b5a
commit 992e7f1b5a
parent 51e4a6d335
49 changed files with 1355 additions and 2931 deletions
--- a/.babelrc
+++ b/.babelrc
@ -1,4 +1,4 @@
 {
-  "presets": [["env", { "debug": true }], "react", "stage-0"],
+  "presets": [["env"], "react", "stage-0"],
  "plugins": ["transform-runtime", "transform-async-to-generator", "transform-class-properties"]
 }
--- a/.gitignore
+++ b/.gitignore
@ -9,6 +9,7 @@ package
 # IDEs
 .idea
 .vscode
+.sublime-project

 # VIM
 *.swp
@ -34,6 +35,7 @@ test/bundle.js
 test/test-bundle.js

 test-artifacts
+test-builds

 #ignore css output and sourcemaps
 ui/app/css/output/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -2,6 +2,16 @@

 ## Current Develop Branch

+## 4.9.3 Wed Aug 15 2018
+
+- (#4897)[https://github.com/MetaMask/metamask-extension/pull/4897]: QR code scan for recipient addresses.
+- (#4961)[https://github.com/MetaMask/metamask-extension/pull/4961]: Add a download seed phrase link.
+- (#5060)[https://github.com/MetaMask/metamask-extension/pull/5060]: Fix bug where gas was not updating properly.
+
+## 4.9.2 Mon Aug 09 2018
+
+- [#5020](https://github.com/MetaMask/metamask-extension/pull/5020): Fix bug in migration #28 ( moving tokens to specific accounts )
+
 ## 4.9.1 Mon Aug 09 2018

 - [#4884](https://github.com/MetaMask/metamask-extension/pull/4884): Allow to have tokens per account and network.
--- a/app/manifest.json
+++ b/app/manifest.json
@ -1,7 +1,7 @@
 {
  "name": "__MSG_appName__",
  "short_name": "__MSG_appName__",
-  "version": "4.9.1",
+  "version": "4.9.3",
  "manifest_version": 2,
  "author": "https://metamask.io",
  "description": "__MSG_appDescription__",
--- a/app/scripts/background.js
+++ b/app/scripts/background.js
@ -19,7 +19,7 @@ const PortStream = require('./lib/port-stream.js')
 const createStreamSink = require('./lib/createStreamSink')
 const NotificationManager = require('./lib/notification-manager.js')
 const MetamaskController = require('./metamask-controller')
-const firstTimeState = require('./first-time-state')
+const rawFirstTimeState = require('./first-time-state')
 const setupRaven = require('./lib/setupRaven')
 const reportFailedTxToSentry = require('./lib/reportFailedTxToSentry')
 const setupMetamaskMeshMetrics = require('./lib/setupMetamaskMeshMetrics')
@ -34,6 +34,9 @@ const {
  ENVIRONMENT_TYPE_FULLSCREEN,
 } = require('./lib/enums')

+// METAMASK_TEST_CONFIG is used in e2e tests to set the default network to localhost
+const firstTimeState = Object.assign({}, rawFirstTimeState, global.METAMASK_TEST_CONFIG)
+
 const STORAGE_KEY = 'metamask-config'
 const METAMASK_DEBUG = process.env.METAMASK_DEBUG

--- a/app/scripts/controllers/balance.js
+++ b/app/scripts/controllers/balance.js
@ -80,7 +80,7 @@ class BalanceController {
      }
    })
    this.accountTracker.store.subscribe(update)
-    this.blockTracker.on('block', update)
+    this.blockTracker.on('latest', update)
  }

  /**
--- a/app/scripts/controllers/currency.js
+++ b/app/scripts/controllers/currency.js
@ -1,4 +1,4 @@
-  const ObservableStore = require('obs-store')
+const ObservableStore = require('obs-store')
 const extend = require('xtend')
 const log = require('loglevel')

--- a/app/scripts/controllers/network/createInfuraClient.js
+++ b/app/scripts/controllers/network/createInfuraClient.js
@ -0,0 +1,25 @@
+const mergeMiddleware = require('json-rpc-engine/src/mergeMiddleware')
+const createBlockReEmitMiddleware = require('eth-json-rpc-middleware/block-reemit')
+const createBlockCacheMiddleware = require('eth-json-rpc-middleware/block-cache')
+const createInflightMiddleware = require('eth-json-rpc-middleware/inflight-cache')
+const createBlockTrackerInspectorMiddleware = require('eth-json-rpc-middleware/block-tracker-inspector')
+const providerFromMiddleware = require('eth-json-rpc-middleware/providerFromMiddleware')
+const createInfuraMiddleware = require('eth-json-rpc-infura')
+const BlockTracker = require('eth-block-tracker')
+
+module.exports = createInfuraClient
+
+function createInfuraClient ({ network }) {
+  const infuraMiddleware = createInfuraMiddleware({ network })
+  const blockProvider = providerFromMiddleware(infuraMiddleware)
+  const blockTracker = new BlockTracker({ provider: blockProvider })
+
+  const networkMiddleware = mergeMiddleware([
+    createBlockCacheMiddleware({ blockTracker }),
+    createInflightMiddleware(),
+    createBlockReEmitMiddleware({ blockTracker, provider: blockProvider }),
+    createBlockTrackerInspectorMiddleware({ blockTracker }),
+    infuraMiddleware,
+  ])
+  return { networkMiddleware, blockTracker }
+}
--- a/app/scripts/controllers/network/createJsonRpcClient.js
+++ b/app/scripts/controllers/network/createJsonRpcClient.js
@ -0,0 +1,25 @@
+const mergeMiddleware = require('json-rpc-engine/src/mergeMiddleware')
+const createFetchMiddleware = require('eth-json-rpc-middleware/fetch')
+const createBlockRefMiddleware = require('eth-json-rpc-middleware/block-ref')
+const createBlockCacheMiddleware = require('eth-json-rpc-middleware/block-cache')
+const createInflightMiddleware = require('eth-json-rpc-middleware/inflight-cache')
+const createBlockTrackerInspectorMiddleware = require('eth-json-rpc-middleware/block-tracker-inspector')
+const providerFromMiddleware = require('eth-json-rpc-middleware/providerFromMiddleware')
+const BlockTracker = require('eth-block-tracker')
+
+module.exports = createJsonRpcClient
+
+function createJsonRpcClient ({ rpcUrl }) {
+  const fetchMiddleware = createFetchMiddleware({ rpcUrl })
+  const blockProvider = providerFromMiddleware(fetchMiddleware)
+  const blockTracker = new BlockTracker({ provider: blockProvider })
+
+  const networkMiddleware = mergeMiddleware([
+    createBlockRefMiddleware({ blockTracker }),
+    createBlockCacheMiddleware({ blockTracker }),
+    createInflightMiddleware(),
+    createBlockTrackerInspectorMiddleware({ blockTracker }),
+    fetchMiddleware,
+  ])
+  return { networkMiddleware, blockTracker }
+}
--- a/app/scripts/controllers/network/createLocalhostClient.js
+++ b/app/scripts/controllers/network/createLocalhostClient.js
@ -0,0 +1,21 @@
+const mergeMiddleware = require('json-rpc-engine/src/mergeMiddleware')
+const createFetchMiddleware = require('eth-json-rpc-middleware/fetch')
+const createBlockRefMiddleware = require('eth-json-rpc-middleware/block-ref')
+const createBlockTrackerInspectorMiddleware = require('eth-json-rpc-middleware/block-tracker-inspector')
+const providerFromMiddleware = require('eth-json-rpc-middleware/providerFromMiddleware')
+const BlockTracker = require('eth-block-tracker')
+
+module.exports = createLocalhostClient
+
+function createLocalhostClient () {
+  const fetchMiddleware = createFetchMiddleware({ rpcUrl: 'http://localhost:8545/' })
+  const blockProvider = providerFromMiddleware(fetchMiddleware)
+  const blockTracker = new BlockTracker({ provider: blockProvider, pollingInterval: 1000 })
+
+  const networkMiddleware = mergeMiddleware([
+    createBlockRefMiddleware({ blockTracker }),
+    createBlockTrackerInspectorMiddleware({ blockTracker }),
+    fetchMiddleware,
+  ])
+  return { networkMiddleware, blockTracker }
+}
--- a/app/scripts/controllers/network/createMetamaskMiddleware.js
+++ b/app/scripts/controllers/network/createMetamaskMiddleware.js
@ -0,0 +1,43 @@
+const mergeMiddleware = require('json-rpc-engine/src/mergeMiddleware')
+const createScaffoldMiddleware = require('json-rpc-engine/src/createScaffoldMiddleware')
+const createAsyncMiddleware = require('json-rpc-engine/src/createAsyncMiddleware')
+const createWalletSubprovider = require('eth-json-rpc-middleware/wallet')
+
+module.exports = createMetamaskMiddleware
+
+function createMetamaskMiddleware ({
+  version,
+  getAccounts,
+  processTransaction,
+  processEthSignMessage,
+  processTypedMessage,
+  processPersonalMessage,
+  getPendingNonce,
+}) {
+  const metamaskMiddleware = mergeMiddleware([
+    createScaffoldMiddleware({
+      // staticSubprovider
+      eth_syncing: false,
+      web3_clientVersion: `MetaMask/v${version}`,
+    }),
+    createWalletSubprovider({
+      getAccounts,
+      processTransaction,
+      processEthSignMessage,
+      processTypedMessage,
+      processPersonalMessage,
+    }),
+    createPendingNonceMiddleware({ getPendingNonce }),
+  ])
+  return metamaskMiddleware
+}
+
+function createPendingNonceMiddleware ({ getPendingNonce }) {
+  return createAsyncMiddleware(async (req, res, next) => {
+    if (req.method !== 'eth_getTransactionCount') return next()
+    const address = req.params[0]
+    const blockRef = req.params[1]
+    if (blockRef !== 'pending') return next()
+    req.result = await getPendingNonce(address)
+  })
+}
--- a/app/scripts/controllers/network/network.js
+++ b/app/scripts/controllers/network/network.js
@ -1,15 +1,17 @@
 const assert = require('assert')
 const EventEmitter = require('events')
-const createMetamaskProvider = require('web3-provider-engine/zero.js')
-const SubproviderFromProvider = require('web3-provider-engine/subproviders/provider.js')
-const createInfuraProvider = require('eth-json-rpc-infura/src/createProvider')
 const ObservableStore = require('obs-store')
 const ComposedStore = require('obs-store/lib/composed')
-const extend = require('xtend')
 const EthQuery = require('eth-query')
-const createEventEmitterProxy = require('../../lib/events-proxy.js')
+const JsonRpcEngine = require('json-rpc-engine')
+const providerFromEngine = require('eth-json-rpc-middleware/providerFromEngine')
 const log = require('loglevel')
-const urlUtil = require('url')
+const createMetamaskMiddleware = require('./createMetamaskMiddleware')
+const createInfuraClient = require('./createInfuraClient')
+const createJsonRpcClient = require('./createJsonRpcClient')
+const createLocalhostClient = require('./createLocalhostClient')
+const { createSwappableProxy, createEventEmitterProxy } = require('swappable-obj-proxy')
+
 const {
  ROPSTEN,
  RINKEBY,
@ -17,7 +19,6 @@ const {
  MAINNET,
  LOCALHOST,
 } = require('./enums')
-const LOCALHOST_RPC_URL = 'http://localhost:8545'
 const INFURA_PROVIDER_TYPES = [ROPSTEN, RINKEBY, KOVAN, MAINNET]

 const env = process.env.METAMASK_ENV
@ -39,21 +40,27 @@ module.exports = class NetworkController extends EventEmitter {
    this.providerStore = new ObservableStore(providerConfig)
    this.networkStore = new ObservableStore('loading')
    this.store = new ComposedStore({ provider: this.providerStore, network: this.networkStore })
-    // create event emitter proxy
-    this._proxy = createEventEmitterProxy()
-
    this.on('networkDidChange', this.lookupNetwork)
+    // provider and block tracker
+    this._provider = null
+    this._blockTracker = null
+    // provider and block tracker proxies - because the network changes
+    this._providerProxy = null
+    this._blockTrackerProxy = null
  }

-  initializeProvider (_providerParams) {
-    this._baseProviderParams = _providerParams
+  initializeProvider (providerParams) {
+    this._baseProviderParams = providerParams
    const { type, rpcTarget } = this.providerStore.getState()
    this._configureProvider({ type, rpcTarget })
-    this._proxy.on('block', this._logBlock.bind(this))
-    this._proxy.on('error', this.verifyNetwork.bind(this))
-    this.ethQuery = new EthQuery(this._proxy)
    this.lookupNetwork()
-    return this._proxy
+  }
+
+  // return the proxies so the references will always be good
+  getProviderAndBlockTracker () {
+    const provider = this._providerProxy
+    const blockTracker = this._blockTrackerProxy
+    return { provider, blockTracker }
  }

  verifyNetwork () {
@ -75,10 +82,11 @@ module.exports = class NetworkController extends EventEmitter {

  lookupNetwork () {
    // Prevent firing when provider is not defined.
-    if (!this.ethQuery || !this.ethQuery.sendAsync) {
-      return log.warn('NetworkController - lookupNetwork aborted due to missing ethQuery')
+    if (!this._provider) {
+      return log.warn('NetworkController - lookupNetwork aborted due to missing provider')
    }
-    this.ethQuery.sendAsync({ method: 'net_version' }, (err, network) => {
+    const ethQuery = new EthQuery(this._provider)
+    ethQuery.sendAsync({ method: 'net_version' }, (err, network) => {
      if (err) return this.setNetworkState('loading')
      log.info('web3.getNetwork returned ' + network)
      this.setNetworkState(network)
@ -131,7 +139,7 @@ module.exports = class NetworkController extends EventEmitter {
      this._configureInfuraProvider(opts)
    // other type-based rpc endpoints
    } else if (type === LOCALHOST) {
-      this._configureStandardProvider({ rpcUrl: LOCALHOST_RPC_URL })
+      this._configureLocalhostProvider()
    // url-based rpc endpoints
    } else if (type === 'rpc') {
      this._configureStandardProvider({ rpcUrl: rpcTarget })
@ -141,49 +149,47 @@ module.exports = class NetworkController extends EventEmitter {
  }

  _configureInfuraProvider ({ type }) {
-    log.info('_configureInfuraProvider', type)
-    const infuraProvider = createInfuraProvider({ network: type })
-    const infuraSubprovider = new SubproviderFromProvider(infuraProvider)
-    const providerParams = extend(this._baseProviderParams, {
-      engineParams: {
-        pollingInterval: 8000,
-        blockTrackerProvider: infuraProvider,
-      },
-      dataSubprovider: infuraSubprovider,
-    })
-    const provider = createMetamaskProvider(providerParams)
-    this._setProvider(provider)
+    log.info('NetworkController - configureInfuraProvider', type)
+    const networkClient = createInfuraClient({ network: type })
+    this._setNetworkClient(networkClient)
+  }
+
+  _configureLocalhostProvider () {
+    log.info('NetworkController - configureLocalhostProvider')
+    const networkClient = createLocalhostClient()
+    this._setNetworkClient(networkClient)
  }

  _configureStandardProvider ({ rpcUrl }) {
-    // urlUtil handles malformed urls
-    rpcUrl = urlUtil.parse(rpcUrl).format()
-    const providerParams = extend(this._baseProviderParams, {
-      rpcUrl,
-      engineParams: {
-        pollingInterval: 8000,
-      },
-    })
-    const provider = createMetamaskProvider(providerParams)
-    this._setProvider(provider)
+    log.info('NetworkController - configureStandardProvider', rpcUrl)
+    const networkClient = createJsonRpcClient({ rpcUrl })
+    this._setNetworkClient(networkClient)
  }

-  _setProvider (provider) {
-    // collect old block tracker events
-    const oldProvider = this._provider
-    let blockTrackerHandlers
-    if (oldProvider) {
-      // capture old block handlers
-      blockTrackerHandlers = oldProvider._blockTracker.proxyEventHandlers
-      // tear down
-      oldProvider.removeAllListeners()
-      oldProvider.stop()
+  _setNetworkClient ({ networkMiddleware, blockTracker }) {
+    const metamaskMiddleware = createMetamaskMiddleware(this._baseProviderParams)
+    const engine = new JsonRpcEngine()
+    engine.push(metamaskMiddleware)
+    engine.push(networkMiddleware)
+    const provider = providerFromEngine(engine)
+    this._setProviderAndBlockTracker({ provider, blockTracker })
+  }
+
+  _setProviderAndBlockTracker ({ provider, blockTracker }) {
+    // update or intialize proxies
+    if (this._providerProxy) {
+      this._providerProxy.setTarget(provider)
+    } else {
+      this._providerProxy = createSwappableProxy(provider)
    }
-    // override block tracler
-    provider._blockTracker = createEventEmitterProxy(provider._blockTracker, blockTrackerHandlers)
-    // set as new provider
+    if (this._blockTrackerProxy) {
+      this._blockTrackerProxy.setTarget(blockTracker)
+    } else {
+      this._blockTrackerProxy = createEventEmitterProxy(blockTracker)
+    }
+    // set new provider and blockTracker
    this._provider = provider
-    this._proxy.setTarget(provider)
+    this._blockTracker = blockTracker
  }

  _logBlock (block) {
--- a/app/scripts/controllers/recent-blocks.js
+++ b/app/scripts/controllers/recent-blocks.js
@ -1,14 +1,14 @@
 const ObservableStore = require('obs-store')
 const extend = require('xtend')
-const BN = require('ethereumjs-util').BN
 const EthQuery = require('eth-query')
 const log = require('loglevel')
+const pify = require('pify')

 class RecentBlocksController {

  /**
   * Controller responsible for storing, updating and managing the recent history of blocks. Blocks are back filled
-   * upon the controller's construction and then the list is updated when the given block tracker gets a 'block' event
+   * upon the controller's construction and then the list is updated when the given block tracker gets a 'latest' event
   * (indicating that there is a new block to process).
   *
   * @typedef {Object} RecentBlocksController
@ -16,7 +16,7 @@ class RecentBlocksController {
   * @param {BlockTracker} opts.blockTracker Contains objects necessary for tracking blocks and querying the blockchain
   * @param {BlockTracker} opts.provider The provider used to create a new EthQuery instance.
   * @property {BlockTracker} blockTracker Points to the passed BlockTracker. On RecentBlocksController construction,
-   * listens for 'block' events so that new blocks can be processed and added to storage.
+   * listens for 'latest' events so that new blocks can be processed and added to storage.
   * @property {EthQuery} ethQuery Points to the EthQuery instance created with the passed provider
   * @property {number} historyLength The maximum length of blocks to track
   * @property {object} store Stores the recentBlocks
@ -34,7 +34,13 @@ class RecentBlocksController {
    }, opts.initState)
    this.store = new ObservableStore(initState)

-    this.blockTracker.on('block', this.processBlock.bind(this))
+    this.blockTracker.on('latest', async (newBlockNumberHex) => {
+      try {
+        await this.processBlock(newBlockNumberHex)
+      } catch (err) {
+        log.error(err)
+      }
+    })
    this.backfill()
  }

@ -55,7 +61,11 @@ class RecentBlocksController {
   * @param {object} newBlock The new block to modify and add to the recentBlocks array
   *
   */
-  processBlock (newBlock) {
+  async processBlock (newBlockNumberHex) {
+    const newBlockNumber = Number.parseInt(newBlockNumberHex, 16)
+    const newBlock = await this.getBlockByNumber(newBlockNumber, true)
+    if (!newBlock) return
+
    const block = this.mapTransactionsToPrices(newBlock)

    const state = this.store.getState()
@ -108,9 +118,9 @@ class RecentBlocksController {
  }

  /**
-   * On this.blockTracker's first 'block' event after this RecentBlocksController's instantiation, the store.recentBlocks
+   * On this.blockTracker's first 'latest' event after this RecentBlocksController's instantiation, the store.recentBlocks
   * array is populated with this.historyLength number of blocks. The block number of the this.blockTracker's first
-   * 'block' event is used to iteratively generate all the numbers of the previous blocks, which are obtained by querying
+   * 'latest' event is used to iteratively generate all the numbers of the previous blocks, which are obtained by querying
   * the blockchain. These blocks are backfilled so that the recentBlocks array is ordered from oldest to newest.
   *
   * Each iteration over the block numbers is delayed by 100 milliseconds.
@ -118,18 +128,17 @@ class RecentBlocksController {
   * @returns {Promise<void>} Promises undefined
   */
  async backfill () {
-    this.blockTracker.once('block', async (block) => {
-      const currentBlockNumber = Number.parseInt(block.number, 16)
+    this.blockTracker.once('latest', async (blockNumberHex) => {
+      const currentBlockNumber = Number.parseInt(blockNumberHex, 16)
      const blocksToFetch = Math.min(currentBlockNumber, this.historyLength)
      const prevBlockNumber = currentBlockNumber - 1
      const targetBlockNumbers = Array(blocksToFetch).fill().map((_, index) => prevBlockNumber - index)
      await Promise.all(targetBlockNumbers.map(async (targetBlockNumber) => {
        try {
-          const newBlock = await this.getBlockByNumber(targetBlockNumber)
+          const newBlock = await this.getBlockByNumber(targetBlockNumber, true)
+          if (!newBlock) return

-          if (newBlock) {
-            this.backfillBlock(newBlock)
-          }
+          this.backfillBlock(newBlock)
        } catch (e) {
          log.error(e)
        }
@ -137,18 +146,6 @@ class RecentBlocksController {
    })
  }

-  /**
-   * A helper for this.backfill. Provides an easy way to ensure a 100 millisecond delay using await
-   *
-   * @returns {Promise<void>} Promises undefined
-   *
-   */
-  async wait () {
-    return new Promise((resolve) => {
-      setTimeout(resolve, 100)
-    })
-  }
-
  /**
   * Uses EthQuery to get a block that has a given block number.
   *
@ -157,13 +154,8 @@ class RecentBlocksController {
   *
   */
  async getBlockByNumber (number) {
-    const bn = new BN(number)
-    return new Promise((resolve, reject) => {
-      this.ethQuery.getBlockByNumber('0x' + bn.toString(16), true, (err, block) => {
-        if (err) reject(err)
-        resolve(block)
-      })
-    })
+    const blockNumberHex = '0x' + number.toString(16)
+    return await pify(this.ethQuery.getBlockByNumber).call(this.ethQuery, blockNumberHex, true)
  }

 }
--- a/app/scripts/controllers/transactions/index.js
+++ b/app/scripts/controllers/transactions/index.js
@ -65,6 +65,7 @@ class TransactionController extends EventEmitter {
    this.store = this.txStateManager.store
    this.nonceTracker = new NonceTracker({
      provider: this.provider,
+      blockTracker: this.blockTracker,
      getPendingTransactions: this.txStateManager.getPendingTransactions.bind(this.txStateManager),
      getConfirmedTransactions: this.txStateManager.getConfirmedTransactions.bind(this.txStateManager),
    })
@ -78,13 +79,17 @@ class TransactionController extends EventEmitter {
    })

    this.txStateManager.store.subscribe(() => this.emit('update:badge'))
-    this._setupListners()
+    this._setupListeners()
    // memstore is computed from a few different stores
    this._updateMemstore()
    this.txStateManager.store.subscribe(() => this._updateMemstore())
    this.networkStore.subscribe(() => this._updateMemstore())
    this.preferencesStore.subscribe(() => this._updateMemstore())
+
+    // request state update to finalize initialization
+    this._updatePendingTxsAfterFirstBlock()
  }
+
  /** @returns {number} the chainId*/
  getChainId () {
    const networkState = this.networkStore.getState()
@ -311,6 +316,11 @@ class TransactionController extends EventEmitter {
    this.txStateManager.setTxStatusSubmitted(txId)
  }

+  confirmTransaction (txId) {
+    this.txStateManager.setTxStatusConfirmed(txId)
+    this._markNonceDuplicatesDropped(txId)
+  }
+
  /**
    Convenience method for the ui thats sets the transaction to rejected
    @param txId {number} - the tx's Id
@ -354,6 +364,14 @@ class TransactionController extends EventEmitter {
    this.getFilteredTxList = (opts) => this.txStateManager.getFilteredTxList(opts)
  }

+  // called once on startup
+  async _updatePendingTxsAfterFirstBlock () {
+    // wait for first block so we know we're ready
+    await this.blockTracker.getLatestBlock()
+    // get status update for all pending transactions (for the current network)
+    await this.pendingTxTracker.updatePendingTxs()
+  }
+
  /**
    If transaction controller was rebooted with transactions that are uncompleted
    in steps of the transaction signing or user confirmation process it will either
@ -386,14 +404,14 @@ class TransactionController extends EventEmitter {
    is called in constructor applies the listeners for pendingTxTracker txStateManager
    and blockTracker
  */
-  _setupListners () {
+  _setupListeners () {
    this.txStateManager.on('tx:status-update', this.emit.bind(this, 'tx:status-update'))
+    this._setupBlockTrackerListener()
    this.pendingTxTracker.on('tx:warning', (txMeta) => {
      this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:warning')
    })
-    this.pendingTxTracker.on('tx:confirmed', (txId) => this.txStateManager.setTxStatusConfirmed(txId))
-    this.pendingTxTracker.on('tx:confirmed', (txId) => this._markNonceDuplicatesDropped(txId))
    this.pendingTxTracker.on('tx:failed', this.txStateManager.setTxStatusFailed.bind(this.txStateManager))
+    this.pendingTxTracker.on('tx:confirmed', (txId) => this.confirmTransaction(txId))
    this.pendingTxTracker.on('tx:block-update', (txMeta, latestBlockNumber) => {
      if (!txMeta.firstRetryBlockNumber) {
        txMeta.firstRetryBlockNumber = latestBlockNumber
@ -405,13 +423,6 @@ class TransactionController extends EventEmitter {
      txMeta.retryCount++
      this.txStateManager.updateTx(txMeta, 'transactions/pending-tx-tracker#event: tx:retry')
    })
-
-    this.blockTracker.on('block', this.pendingTxTracker.checkForTxInBlock.bind(this.pendingTxTracker))
-    // this is a little messy but until ethstore has been either
-    // removed or redone this is to guard against the race condition
-    this.blockTracker.on('latest', this.pendingTxTracker.resubmitPendingTxs.bind(this.pendingTxTracker))
-    this.blockTracker.on('sync', this.pendingTxTracker.queryPendingTxs.bind(this.pendingTxTracker))
-
  }

  /**
@ -435,6 +446,40 @@ class TransactionController extends EventEmitter {
    })
  }

+  _setupBlockTrackerListener () {
+    let listenersAreActive = false
+    const latestBlockHandler = this._onLatestBlock.bind(this)
+    const blockTracker = this.blockTracker
+    const txStateManager = this.txStateManager
+
+    txStateManager.on('tx:status-update', updateSubscription)
+    updateSubscription()
+
+    function updateSubscription () {
+      const pendingTxs = txStateManager.getPendingTransactions()
+      if (!listenersAreActive && pendingTxs.length > 0) {
+        blockTracker.on('latest', latestBlockHandler)
+        listenersAreActive = true
+      } else if (listenersAreActive && !pendingTxs.length) {
+        blockTracker.removeListener('latest', latestBlockHandler)
+        listenersAreActive = false
+      }
+    }
+  }
+
+  async _onLatestBlock (blockNumber) {
+    try {
+      await this.pendingTxTracker.updatePendingTxs()
+    } catch (err) {
+      log.error(err)
+    }
+    try {
+      await this.pendingTxTracker.resubmitPendingTxs(blockNumber)
+    } catch (err) {
+      log.error(err)
+    }
+  }
+
  /**
    Updates the memStore in transaction controller
  */
--- a/app/scripts/controllers/transactions/nonce-tracker.js
+++ b/app/scripts/controllers/transactions/nonce-tracker.js
@ -12,8 +12,9 @@ const Mutex = require('await-semaphore').Mutex
 */
 class NonceTracker {

-  constructor ({ provider, getPendingTransactions, getConfirmedTransactions }) {
+  constructor ({ provider, blockTracker, getPendingTransactions, getConfirmedTransactions }) {
    this.provider = provider
+    this.blockTracker = blockTracker
    this.ethQuery = new EthQuery(provider)
    this.getPendingTransactions = getPendingTransactions
    this.getConfirmedTransactions = getConfirmedTransactions
@ -34,7 +35,7 @@ class NonceTracker {
   * @typedef NonceDetails
   * @property {number} highestLocallyConfirmed - A hex string of the highest nonce on a confirmed transaction.
   * @property {number} nextNetworkNonce - The next nonce suggested by the eth_getTransactionCount method.
-   * @property {number} highetSuggested - The maximum between the other two, the number returned.
+   * @property {number} highestSuggested - The maximum between the other two, the number returned.
   */

  /**
@ -80,15 +81,6 @@ class NonceTracker {
    }
  }

-  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 releaseLock = await globalMutex.acquire()
@ -114,9 +106,8 @@ class NonceTracker {
    // 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 blockNumber = await this.blockTracker.getLatestBlock()
+    const baseCountBN = await this.ethQuery.getTransactionCount(address, blockNumber)
    const baseCount = baseCountBN.toNumber()
    assert(Number.isInteger(baseCount), `nonce-tracker - baseCount is not an integer - got: (${typeof baseCount}) "${baseCount}"`)
    const nonceDetails = { blockNumber, baseCount }
@ -165,15 +156,6 @@ class NonceTracker {
    return { name: 'local', nonce: highest, details: { startPoint, highest } }
  }

-  // this is a hotfix for the fact that the blockTracker will
-  // change when the network changes
-
-  /**
-    @returns {Object} the current blockTracker
-  */
-  _getBlockTracker () {
-    return this.provider._blockTracker
-  }
 }

 module.exports = NonceTracker
--- a/app/scripts/controllers/transactions/pending-tx-tracker.js
+++ b/app/scripts/controllers/transactions/pending-tx-tracker.js
@ -1,6 +1,7 @@
 const EventEmitter = require('events')
 const log = require('loglevel')
 const EthQuery = require('ethjs-query')
+
 /**

  Event emitter utility class for tracking the transactions as they<br>
@ -23,55 +24,26 @@ class PendingTransactionTracker extends EventEmitter {
    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()
+    this.confirmTransaction = config.confirmTransaction
  }

  /**
-    checks if a signed tx is in a block and
-    if it is included emits tx status as 'confirmed'
-    @param block {object}, a full block
-    @emits tx:confirmed
-    @emits tx:failed
+    checks the network for signed txs and releases the nonce global lock if it is
  */
-  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)
-      })
-    })
-  }
-
-  /**
-    asks the network for the transaction to see if a block number is included on it
-    if we have skipped/missed blocks
-    @param object - oldBlock newBlock
-  */
-  queryPendingTxs ({ oldBlock, newBlock }) {
-    // check pending transactions on start
-    if (!oldBlock) {
-      this._checkPendingTxs()
-      return
+  async updatePendingTxs () {
+    // in order to keep the nonceTracker accurate we block it while updating pending transactions
+    const nonceGlobalLock = await this.nonceTracker.getGlobalLock()
+    try {
+      const pendingTxs = this.getPendingTransactions()
+      await Promise.all(pendingTxs.map((txMeta) => this._checkPendingTx(txMeta)))
+    } catch (err) {
+      log.error('PendingTransactionTracker - Error updating pending transactions')
+      log.error(err)
    }
-    // 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()
+    nonceGlobalLock.releaseLock()
  }

  /**
@ -79,11 +51,11 @@ class PendingTransactionTracker extends EventEmitter {
    @param block {object} - a block object
    @emits tx:warning
  */
-  resubmitPendingTxs (block) {
+  resubmitPendingTxs (blockNumber) {
    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) => {
+    pending.forEach((txMeta) => this._resubmitTx(txMeta, blockNumber).catch((err) => {
      /*
      Dont marked as failed if the error is a "known" transaction warning
      "there is already a transaction with the same sender-nonce
@ -145,6 +117,7 @@ class PendingTransactionTracker extends EventEmitter {
    this.emit('tx:retry', txMeta)
    return txHash
  }
+
  /**
    Ask the network for the transaction to see if it has been include in a block
    @param txMeta {Object} - the txMeta object
@ -174,9 +147,8 @@ class PendingTransactionTracker extends EventEmitter {
    }

    // get latest transaction status
-    let txParams
    try {
-      txParams = await this.query.getTransactionByHash(txHash)
+      const txParams = await this.query.getTransactionByHash(txHash)
      if (!txParams) return
      if (txParams.blockNumber) {
        this.emit('tx:confirmed', txId)
@ -190,27 +162,13 @@ class PendingTransactionTracker extends EventEmitter {
    }
  }

-  /**
-    checks the network for signed txs and releases the nonce global lock if it is
-  */
-  async _checkPendingTxs () {
-    const signedTxList = this.getPendingTransactions()
-    // in order to keep the nonceTracker accurate we block it while updating pending transactions
-    const { releaseLock } = await this.nonceTracker.getGlobalLock()
-    try {
-      await Promise.all(signedTxList.map((txMeta) => this._checkPendingTx(txMeta)))
-    } catch (err) {
-      log.error('PendingTransactionWatcher - Error updating pending transactions')
-      log.error(err)
-    }
-    releaseLock()
-  }
-
  /**
    checks to see if a confirmed txMeta has the same nonce
    @param txMeta {Object} - txMeta object
    @returns {boolean}
  */
+
+
  async _checkIfNonceIsTaken (txMeta) {
    const address = txMeta.txParams.from
    const completed = this.getCompletedTransactions(address)
--- a/app/scripts/controllers/transactions/tx-gas-utils.js
+++ b/app/scripts/controllers/transactions/tx-gas-utils.js
@ -25,7 +25,7 @@ class TxGasUtil {
    @returns {object} the txMeta object with the gas written to the txParams
  */
  async analyzeGasUsage (txMeta) {
-    const block = await this.query.getBlockByNumber('latest', true)
+    const block = await this.query.getBlockByNumber('latest', false)
    let estimatedGasHex
    try {
      estimatedGasHex = await this.estimateTxGas(txMeta, block.gasLimit)
--- a/app/scripts/lib/account-tracker.js
+++ b/app/scripts/lib/account-tracker.js
@ -7,14 +7,13 @@
 * 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 () {}
+const log = require('loglevel')
+const pify = require('pify')


-class AccountTracker extends EventEmitter {
+class AccountTracker {

  /**
   * This module is responsible for tracking any number of accounts and caching their current balances & transaction
@ -35,8 +34,6 @@ class AccountTracker extends EventEmitter {
   *
   */
  constructor (opts = {}) {
-    super()
-
    const initState = {
      accounts: {},
      currentBlockGasLimit: '',
@ -44,12 +41,12 @@ class AccountTracker extends EventEmitter {
    this.store = new ObservableStore(initState)

    this._provider = opts.provider
-    this._query = new EthQuery(this._provider)
+    this._query = pify(new EthQuery(this._provider))
    this._blockTracker = opts.blockTracker
    // subscribe to latest block
-    this._blockTracker.on('block', this._updateForBlock.bind(this))
+    this._blockTracker.on('latest', this._updateForBlock.bind(this))
    // blockTracker.currentBlock may be null
-    this._currentBlockNumber = this._blockTracker.currentBlock
+    this._currentBlockNumber = this._blockTracker.getCurrentBlock()
  }

  /**
@ -67,49 +64,57 @@ class AccountTracker extends EventEmitter {
    const accounts = this.store.getState().accounts
    const locals = Object.keys(accounts)

-    const toAdd = []
+    const accountsToAdd = []
    addresses.forEach((upstream) => {
      if (!locals.includes(upstream)) {
-        toAdd.push(upstream)
+        accountsToAdd.push(upstream)
      }
    })

-    const toRemove = []
+    const accountsToRemove = []
    locals.forEach((local) => {
      if (!addresses.includes(local)) {
-        toRemove.push(local)
+        accountsToRemove.push(local)
      }
    })

-    toAdd.forEach(upstream => this.addAccount(upstream))
-    toRemove.forEach(local => this.removeAccount(local))
-    this._updateAccounts()
+    this.addAccounts(accountsToAdd)
+    this.removeAccount(accountsToRemove)
  }

  /**
-   * Adds a new address to this AccountTracker's accounts object, which points to an empty object. This object will be
+   * Adds new addresses to track the balances of
   * given a balance as long this._currentBlockNumber is defined.
   *
-   * @param {string} address A hex address of a new account to store in this AccountTracker's accounts object
+   * @param {array} addresses An array of hex addresses of new accounts to track
   *
   */
-  addAccount (address) {
+  addAccounts (addresses) {
    const accounts = this.store.getState().accounts
-    accounts[address] = {}
+    // add initial state for addresses
+    addresses.forEach(address => {
+      accounts[address] = {}
+    })
+    // save accounts state
    this.store.updateState({ accounts })
+    // fetch balances for the accounts if there is block number ready
    if (!this._currentBlockNumber) return
-    this._updateAccount(address)
+    addresses.forEach(address => this._updateAccount(address))
  }

  /**
-   * Removes an account from this AccountTracker's accounts object
+   * Removes accounts from being tracked
   *
-   * @param {string} address A hex address of a the account to remove
+   * @param {array} an array of hex addresses to stop tracking
   *
   */
-  removeAccount (address) {
+  removeAccount (addresses) {
    const accounts = this.store.getState().accounts
-    delete accounts[address]
+    // remove each state object
+    addresses.forEach(address => {
+      delete accounts[address]
+    })
+    // save accounts state
    this.store.updateState({ accounts })
  }

@ -118,71 +123,56 @@ class AccountTracker extends EventEmitter {
   * via EthQuery
   *
   * @private
-   * @param {object} block Data about the block that contains the data to update to.
+   * @param {number} blockNumber the block number to update to.
   * @fires 'block' The updated state, if all account updates are successful
   *
   */
-  _updateForBlock (block) {
-    this._currentBlockNumber = block.number
-    const currentBlockGasLimit = block.gasLimit
+  async _updateForBlock (blockNumber) {
+    this._currentBlockNumber = blockNumber

+    // block gasLimit polling shouldn't be in account-tracker shouldn't be here...
+    const currentBlock = await this._query.getBlockByNumber(blockNumber, false)
+    if (!currentBlock) return
+    const currentBlockGasLimit = currentBlock.gasLimit
    this.store.updateState({ currentBlockGasLimit })

-    async.parallel([
-      this._updateAccounts.bind(this),
-    ], (err) => {
-      if (err) return console.error(err)
-      this.emit('block', this.store.getState())
-    })
+    try {
+      await this._updateAccounts()
+    } catch (err) {
+      log.error(err)
+    }
  }

  /**
   * Calls this._updateAccount for each account in this.store
   *
-   * @param {Function} cb A callback to pass to this._updateAccount, called after each account is successfully updated
+   * @returns {Promise} after all account balances updated
   *
   */
-  _updateAccounts (cb = noop) {
+  async _updateAccounts () {
    const accounts = this.store.getState().accounts
    const addresses = Object.keys(accounts)
-    async.each(addresses, this._updateAccount.bind(this), cb)
+    await Promise.all(addresses.map(this._updateAccount.bind(this)))
  }

  /**
-   * Updates the current balance of an account. Gets an updated balance via this._getAccount.
+   * Updates the current balance of an account.
   *
   * @private
   * @param {string} address A hex address of a the account to be updated
-   * @param {Function} cb A callback to call once the account at address is successfully update
+   * @returns {Promise} after the account balance is updated
   *
   */
-  _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)
-    })
-  }
-
-  /**
-   * Gets the current balance of an account via EthQuery.
-   *
-   * @private
-   * @param {string} address A hex address of a the account to query
-   * @param {Function} cb A callback to call once the account at address is successfully update
-   *
-   */
-  _getAccount (address, cb = noop) {
-    const query = this._query
-    async.parallel({
-      balance: query.getBalance.bind(query, address),
-    }, cb)
+  async _updateAccount (address) {
+    // query balance
+    const balance = await this._query.getBalance(address)
+    const result = { address, balance }
+    // update accounts state
+    const { accounts } = this.store.getState()
+    // only populate if the entry is still present
+    if (!accounts[address]) return
+    accounts[address] = result
+    this.store.updateState({ accounts })
  }

 }
--- a/app/scripts/lib/events-proxy.js
+++ b/app/scripts/lib/events-proxy.js
@ -1,42 +0,0 @@
-/**
- * Returns an EventEmitter that proxies events from the given event emitter
- * @param {any} eventEmitter
- * @param {object} listeners - The listeners to proxy to
- * @returns {any}
- */
-module.exports = function createEventEmitterProxy (eventEmitter, listeners) {
-  let target = eventEmitter
-  const eventHandlers = listeners || {}
-  const proxy = /** @type {any} */ (new Proxy({}, {
-    get: (_, name) => {
-      // intercept listeners
-      if (name === 'on') return addListener
-      if (name === 'setTarget') return setTarget
-      if (name === 'proxyEventHandlers') return eventHandlers
-      return (/** @type {any} */ (target))[name]
-    },
-    set: (_, name, value) => {
-      target[name] = value
-      return true
-    },
-  }))
-  function setTarget (/** @type {EventEmitter} */ eventEmitter) {
-    target = eventEmitter
-    // migrate listeners
-    Object.keys(eventHandlers).forEach((name) => {
-      /** @type {Array<Function>} */ (eventHandlers[name]).forEach((handler) => target.on(name, handler))
-    })
-  }
-  /**
-   * Attaches a function to be called whenever the specified event is emitted
-   * @param {string} name
-   * @param {Function} 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
-}
--- a/app/scripts/lib/message-manager.js
+++ b/app/scripts/lib/message-manager.js
@ -69,10 +69,39 @@ module.exports = class MessageManager extends EventEmitter {
   * new Message to this.messages, and to save the unapproved Messages from that list to this.memStore.
   *
   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object possibly containing the origin
+   * @returns {promise} after signature has been
+   *
+   */
+  addUnapprovedMessageAsync (msgParams, req) {
+    return new Promise((resolve, reject) => {
+      const msgId = this.addUnapprovedMessage(msgParams, req)
+      // await finished
+      this.once(`${msgId}:finished`, (data) => {
+        switch (data.status) {
+          case 'signed':
+            return resolve(data.rawSig)
+          case 'rejected':
+            return reject(new Error('MetaMask Message Signature: User denied message signature.'))
+          default:
+            return reject(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`))
+        }
+      })
+    })
+  }
+
+  /**
+   * Creates a new Message with an 'unapproved' status using the passed msgParams. this.addMsg is called to add the
+   * new Message to this.messages, and to save the unapproved Messages from that list to this.memStore.
+   *
+   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object where the origin may be specificied
   * @returns {number} The id of the newly created message.
   *
   */
-  addUnapprovedMessage (msgParams) {
+  addUnapprovedMessage (msgParams, req) {
+    // add origin from request
+    if (req) msgParams.origin = req.origin
    msgParams.data = normalizeMsgData(msgParams.data)
    // create txData obj with parameters and meta data
    var time = (new Date()).getTime()
--- a/app/scripts/lib/personal-message-manager.js
+++ b/app/scripts/lib/personal-message-manager.js
@ -73,11 +73,43 @@ module.exports = class PersonalMessageManager extends EventEmitter {
   * this.memStore.
   *
   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object possibly containing the origin
+   * @returns {promise} When the message has been signed or rejected
+   *
+   */
+  addUnapprovedMessageAsync (msgParams, req) {
+    return new Promise((resolve, reject) => {
+      if (!msgParams.from) {
+        reject(new Error('MetaMask Message Signature: from field is required.'))
+      }
+      const msgId = this.addUnapprovedMessage(msgParams, req)
+      this.once(`${msgId}:finished`, (data) => {
+        switch (data.status) {
+          case 'signed':
+            return resolve(data.rawSig)
+          case 'rejected':
+            return reject(new Error('MetaMask Message Signature: User denied message signature.'))
+          default:
+            return reject(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`))
+        }
+      })
+    })
+  }
+
+  /**
+   * Creates a new PersonalMessage with an 'unapproved' status using the passed msgParams. this.addMsg is called to add
+   * the new PersonalMessage to this.messages, and to save the unapproved PersonalMessages from that list to
+   * this.memStore.
+   *
+   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object possibly containing the origin
   * @returns {number} The id of the newly created PersonalMessage.
   *
   */
-  addUnapprovedMessage (msgParams) {
+  addUnapprovedMessage (msgParams, req) {
    log.debug(`PersonalMessageManager addUnapprovedMessage: ${JSON.stringify(msgParams)}`)
+    // add origin from request
+    if (req) msgParams.origin = req.origin
    msgParams.data = this.normalizeMsgData(msgParams.data)
    // create txData obj with parameters and meta data
    var time = (new Date()).getTime()
@ -257,4 +289,3 @@ module.exports = class PersonalMessageManager extends EventEmitter {
  }

 }
-
--- a/app/scripts/lib/setupRaven.js
+++ b/app/scripts/lib/setupRaven.js
@ -70,11 +70,11 @@ function simplifyErrorMessages (report) {

 function rewriteErrorMessages (report, rewriteFn) {
  // rewrite top level message
-  if (report.message) report.message = rewriteFn(report.message)
+  if (typeof report.message === 'string') report.message = rewriteFn(report.message)
  // rewrite each exception message
  if (report.exception && report.exception.values) {
    report.exception.values.forEach(item => {
-      item.value = rewriteFn(item.value)
+      if (typeof item.value === 'string') item.value = rewriteFn(item.value)
    })
  }
 }
--- a/app/scripts/lib/typed-message-manager.js
+++ b/app/scripts/lib/typed-message-manager.js
@ -72,11 +72,40 @@ module.exports = class TypedMessageManager extends EventEmitter {
   * this.memStore. Before any of this is done, msgParams are validated
   *
   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object possibly containing the origin
+   * @returns {promise} When the message has been signed or rejected
+   *
+   */
+  addUnapprovedMessageAsync (msgParams, req) {
+    return new Promise((resolve, reject) => {
+      const msgId = this.addUnapprovedMessage(msgParams, req)
+      this.once(`${msgId}:finished`, (data) => {
+        switch (data.status) {
+          case 'signed':
+            return resolve(data.rawSig)
+          case 'rejected':
+            return reject(new Error('MetaMask Message Signature: User denied message signature.'))
+          default:
+            return reject(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`))
+        }
+      })
+    })
+  }
+
+  /**
+   * Creates a new TypedMessage with an 'unapproved' status using the passed msgParams. this.addMsg is called to add
+   * the new TypedMessage to this.messages, and to save the unapproved TypedMessages from that list to
+   * this.memStore. Before any of this is done, msgParams are validated
+   *
+   * @param {Object} msgParams The params for the eth_sign call to be made after the message is approved.
+   * @param {Object} req (optional) The original request object possibly containing the origin
   * @returns {number} The id of the newly created TypedMessage.
   *
   */
-  addUnapprovedMessage (msgParams) {
+  addUnapprovedMessage (msgParams, req) {
    this.validateParams(msgParams)
+    // add origin from request
+    if (req) msgParams.origin = req.origin

    log.debug(`TypedMessageManager addUnapprovedMessage: ${JSON.stringify(msgParams)}`)
    // create txData obj with parameters and meta data
--- a/app/scripts/lib/util.js
+++ b/app/scripts/lib/util.js
@ -127,7 +127,21 @@ function BnMultiplyByFraction (targetBN, numerator, denominator) {
  return targetBN.mul(numBN).div(denomBN)
 }

+function applyListeners (listeners, emitter) {
+  Object.keys(listeners).forEach((key) => {
+    emitter.on(key, listeners[key])
+  })
+}
+
+function removeListeners (listeners, emitter) {
+  Object.keys(listeners).forEach((key) => {
+    emitter.removeListener(key, listeners[key])
+  })
+}
+
 module.exports = {
+  removeListeners,
+  applyListeners,
  getPlatform,
  getStack,
  getEnvironmentType,
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@ -46,7 +46,6 @@ const BN = require('ethereumjs-util').BN
 const GWEI_BN = new BN('1000000000')
 const percentile = require('percentile')
 const seedPhraseVerifier = require('./lib/seed-phrase-verifier')
-const cleanErrorStack = require('./lib/cleanErrorStack')
 const log = require('loglevel')
 const TrezorKeyring = require('eth-trezor-keyring')
 const LedgerBridgeKeyring = require('eth-ledger-bridge-keyring')
@ -108,8 +107,9 @@ module.exports = class MetamaskController extends EventEmitter {
    this.blacklistController.scheduleUpdates()

    // rpc provider
-    this.provider = this.initializeProvider()
-    this.blockTracker = this.provider._blockTracker
+    this.initializeProvider()
+    this.provider = this.networkController.getProviderAndBlockTracker().provider
+    this.blockTracker = this.networkController.getProviderAndBlockTracker().blockTracker

    // token exchange rate tracker
    this.tokenRatesController = new TokenRatesController({
@ -253,28 +253,22 @@ module.exports = class MetamaskController extends EventEmitter {
      static: {
        eth_syncing: false,
        web3_clientVersion: `MetaMask/v${version}`,
-        eth_sendTransaction: (payload, next, end) => {
-          const origin = payload.origin
-          const txParams = payload.params[0]
-          nodeify(this.txController.newUnapprovedTransaction, this.txController)(txParams, { origin }, end)
-        },
      },
      // account mgmt
-      getAccounts: (cb) => {
+      getAccounts: async () => {
        const isUnlocked = this.keyringController.memStore.getState().isUnlocked
-        const result = []
        const selectedAddress = this.preferencesController.getSelectedAddress()
-
        // only show address if account is unlocked
        if (isUnlocked && selectedAddress) {
-          result.push(selectedAddress)
+          return [selectedAddress]
+        } else {
+          return []
        }
-        cb(null, result)
      },
      // tx signing
-      // old style msg signing
-      processMessage: this.newUnsignedMessage.bind(this),
-      // personal_sign msg signing
+      processTransaction: this.newUnapprovedTransaction.bind(this),
+      // msg signing
+      processEthSignMessage: this.newUnsignedMessage.bind(this),
      processPersonalMessage: this.newUnsignedPersonalMessage.bind(this),
      processTypedMessage: this.newUnsignedTypedMessage.bind(this),
    }
@ -791,6 +785,18 @@ module.exports = class MetamaskController extends EventEmitter {
  // ---------------------------------------------------------------------------
  // Identity Management (signature operations)

+  /**
+   * Called when a Dapp suggests a new tx to be signed.
+   * this wrapper needs to exist so we can provide a reference to
+   *  "newUnapprovedTransaction" before "txController" is instantiated
+   *
+   * @param {Object} msgParams - The params passed to eth_sign.
+   * @param {Object} req - (optional) the original request, containing the origin
+   */
+  async newUnapprovedTransaction (txParams, req) {
+    return await this.txController.newUnapprovedTransaction(txParams, req)
+  }
+
  // eth_sign methods:

  /**
@ -802,20 +808,11 @@ module.exports = class MetamaskController extends EventEmitter {
   * @param {Object} msgParams - The params passed to eth_sign.
   * @param {Function} cb = The callback function called with the signature.
   */
-  newUnsignedMessage (msgParams, cb) {
-    const msgId = this.messageManager.addUnapprovedMessage(msgParams)
+  newUnsignedMessage (msgParams, req) {
+    const promise = this.messageManager.addUnapprovedMessageAsync(msgParams, req)
    this.sendUpdate()
    this.opts.showUnconfirmedMessage()
-    this.messageManager.once(`${msgId}:finished`, (data) => {
-      switch (data.status) {
-        case 'signed':
-          return cb(null, data.rawSig)
-        case 'rejected':
-          return cb(cleanErrorStack(new Error('MetaMask Message Signature: User denied message signature.')))
-        default:
-          return cb(cleanErrorStack(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`)))
-      }
-    })
+    return promise
  }

  /**
@ -869,24 +866,11 @@ module.exports = class MetamaskController extends EventEmitter {
   * @param {Function} cb - The callback function called with the signature.
   * Passed back to the requesting Dapp.
   */
-  newUnsignedPersonalMessage (msgParams, cb) {
-    if (!msgParams.from) {
-      return cb(cleanErrorStack(new Error('MetaMask Message Signature: from field is required.')))
-    }
-
-    const msgId = this.personalMessageManager.addUnapprovedMessage(msgParams)
+  async newUnsignedPersonalMessage (msgParams, req) {
+    const promise = this.personalMessageManager.addUnapprovedMessageAsync(msgParams, req)
    this.sendUpdate()
    this.opts.showUnconfirmedMessage()
-    this.personalMessageManager.once(`${msgId}:finished`, (data) => {
-      switch (data.status) {
-        case 'signed':
-          return cb(null, data.rawSig)
-        case 'rejected':
-          return cb(cleanErrorStack(new Error('MetaMask Message Signature: User denied message signature.')))
-        default:
-          return cb(cleanErrorStack(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`)))
-      }
-    })
+    return promise
  }

  /**
@ -935,26 +919,11 @@ module.exports = class MetamaskController extends EventEmitter {
   * @param {Object} msgParams - The params passed to eth_signTypedData.
   * @param {Function} cb - The callback function, called with the signature.
   */
-  newUnsignedTypedMessage (msgParams, cb) {
-    let msgId
-    try {
-      msgId = this.typedMessageManager.addUnapprovedMessage(msgParams)
-      this.sendUpdate()
-      this.opts.showUnconfirmedMessage()
-    } catch (e) {
-      return cb(e)
-    }
-
-    this.typedMessageManager.once(`${msgId}:finished`, (data) => {
-      switch (data.status) {
-        case 'signed':
-          return cb(null, data.rawSig)
-        case 'rejected':
-          return cb(cleanErrorStack(new Error('MetaMask Message Signature: User denied message signature.')))
-        default:
-          return cb(cleanErrorStack(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`)))
-      }
-    })
+  newUnsignedTypedMessage (msgParams, req) {
+    const promise = this.typedMessageManager.addUnapprovedMessageAsync(msgParams, req)
+    this.sendUpdate()
+    this.opts.showUnconfirmedMessage()
+    return promise
  }

  /**
@ -1219,7 +1188,7 @@ module.exports = class MetamaskController extends EventEmitter {
    // create filter polyfill middleware
    const filterMiddleware = createFilterMiddleware({
      provider: this.provider,
-      blockTracker: this.provider._blockTracker,
+      blockTracker: this.blockTracker,
    })

    engine.push(createOriginMiddleware({ origin }))
--- a/docs/developing-on-deps.md
+++ b/docs/developing-on-deps.md
@ -1,10 +1,9 @@
 ### Developing on Dependencies

-To enjoy the live-reloading that `gulp dev` offers while working on the `web3-provider-engine` or other dependencies:
+To enjoy the live-reloading that `gulp dev` offers while working on the dependencies:

 1. Clone the dependency locally.
 2. `npm install` in its folder.
 3. Run `npm link` in its folder.
 4. Run `npm link $DEP_NAME` in this project folder.
 5. Next time you `npm start` it will watch the dependency for changes as well!
-
--- a/docs/porting_to_new_environment.md
+++ b/docs/porting_to_new_environment.md
@ -89,8 +89,6 @@ MetaMask has two kinds of [duplex stream APIs](https://github.com/substack/strea

 If you are making a MetaMask-powered browser for a new platform, one of the trickiest tasks will be injecting the Web3 API into websites that are visited. On WebExtensions, we actually have to pipe data through a total of three JS contexts just to let sites talk to our background process (site -> contentscript -> background).

-To make this as easy as possible, we use one of our favorite internal tools, [web3-provider-engine](https://www.npmjs.com/package/web3-provider-engine) to construct a custom web3 provider object whose source of truth is a stream that we connect to remotely.
-
 To see how we do that, you can refer to the [inpage script](https://github.com/MetaMask/metamask-extension/blob/master/app/scripts/inpage.js) that we inject into every website. There you can see it creates a multiplex stream to the background, and uses it to initialize what we call the [inpage-provider](https://github.com/MetaMask/metamask-extension/blob/master/app/scripts/lib/inpage-provider.js), which you can see stubs a few methods out, but mostly just passes calls to `sendAsync` through the stream it's passed! That's really all the magic that's needed to create a web3-like API in a remote context, once you have a stream to MetaMask available.

 In `inpage.js` you can see we create a `PortStream`, that's just a class we use to wrap WebExtension ports as streams, so we can reuse our favorite stream abstraction over the more irregular API surface of the WebExtension. In a new platform, you will probably need to construct this stream differently. The key is that you need to construct a stream that talks from the site context to the background. Once you have that set up, it works like magic!
--- a/old-ui/app/components/notice.js
+++ b/old-ui/app/components/notice.js
@ -116,12 +116,25 @@ Notice.prototype.render = function () {
  )
 }

+Notice.prototype.setInitialDisclaimerState = function () {
+  if (document.getElementsByClassName('notice-box')[0].clientHeight < 310) {
+    this.setState({disclaimerDisabled: false})
+  }
+}
+
 Notice.prototype.componentDidMount = function () {
  // eslint-disable-next-line react/no-find-dom-node
  var node = findDOMNode(this)
  linker.setupListener(node)
-  if (document.getElementsByClassName('notice-box')[0].clientHeight < 310) {
-    this.setState({disclaimerDisabled: false})
+  this.setInitialDisclaimerState()
+}
+
+Notice.prototype.componentDidUpdate = function (prevProps) {
+  const { notice: { id } = {} } = this.props
+  const { notice: { id: prevNoticeId } = {} } = prevProps
+
+  if (id !== prevNoticeId) {
+    this.setInitialDisclaimerState()
  }
 }

--- a/old-ui/app/info.js
+++ b/old-ui/app/info.js
@ -138,7 +138,6 @@ InfoScreen.prototype.render = function () {
              h('div.fa.fa-envelope', [
                h('a.info', {
                  target: '_blank',
-                  style: { width: '85vw' },
                  href: 'mailto:help@metamask.io?subject=Feedback',
                }, 'Email us!'),
              ]),
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -36,7 +36,7 @@
    "test:mascara:build:locales": "mkdirp dist/chrome && cp -R app/_locales dist/chrome/_locales",
    "test:mascara:build:background": "browserify mascara/src/background.js -o dist/mascara/background.js",
    "test:mascara:build:tests": "browserify test/integration/lib/first-time.js -o dist/mascara/tests.js",
-    "ganache:start": "ganache-cli -m 'phrase upgrade clock rough situate wedding elder clever doctor stamp excess tent'",
+    "ganache:start": "ganache-cli --noVMErrorsOnRPCResponse -m 'phrase upgrade clock rough situate wedding elder clever doctor stamp excess tent'",
    "sentry:publish": "node ./development/sentry-publish.js",
    "lint": "eslint .",
    "lint:fix": "eslint . --fix",
@ -75,7 +75,7 @@
  },
  "dependencies": {
    "@material-ui/core": "1.0.0",
-    "@zxing/library": "^0.7.0",
+    "@zxing/library": "^0.8.0",
    "abi-decoder": "^1.0.9",
    "asmcrypto.js": "0.22.0",
    "async": "^2.5.0",
@ -105,10 +105,13 @@
    "ensnare": "^1.0.0",
    "eslint-plugin-react": "^7.4.0",
    "eth-bin-to-ops": "^1.0.1",
+    "eth-block-tracker": "^4.0.1",
    "eth-contract-metadata": "github:MetaMask/eth-contract-metadata#master",
+    "eth-json-rpc-middleware": "^2.4.0",
+    "eth-keyring-controller": "^3.1.4",
    "eth-ens-namehash": "^2.0.8",
    "eth-hd-keyring": "^1.2.2",
-    "eth-json-rpc-filters": "^1.2.6",
+    "eth-json-rpc-filters": "^2.1.1",
    "eth-json-rpc-infura": "^3.0.0",
    "eth-ledger-bridge-keyring": "^0.1.0",
    "eth-method-registry": "^1.0.0",
@ -146,7 +149,7 @@
    "iframe-stream": "^3.0.0",
    "inject-css": "^0.1.1",
    "jazzicon": "^1.2.0",
-    "json-rpc-engine": "^3.6.1",
+    "json-rpc-engine": "^3.7.3",
    "json-rpc-middleware-stream": "^1.0.1",
    "lodash.debounce": "^4.0.8",
    "lodash.memoize": "^4.1.2",
@ -203,11 +206,11 @@
    "shallow-copy": "0.0.1",
    "sw-controller": "^1.0.3",
    "sw-stream": "^2.0.2",
+    "swappable-obj-proxy": "^1.0.2",
    "textarea-caret": "^3.0.1",
    "valid-url": "^1.0.9",
    "vreme": "^3.0.2",
    "web3": "^0.20.1",
-    "web3-provider-engine": "^14.0.5",
    "web3-stream-provider": "^3.0.1",
    "webrtc-adapter": "^6.3.0",
    "xtend": "^4.0.1"
@ -250,6 +253,7 @@
    "eth-json-rpc-middleware": "^1.6.0",
    "eth-keyring-controller": "^3.3.1",
    "file-loader": "^1.1.11",
+    "fs-extra": "^6.0.1",
    "fs-promise": "^2.0.3",
    "ganache-cli": "^6.1.0",
    "ganache-core": "^2.1.5",
@ -294,6 +298,7 @@
    "open": "0.0.5",
    "path": "^0.12.7",
    "png-file-stream": "^1.0.0",
+    "prepend-file": "^1.3.1",
    "prompt": "^1.0.0",
    "proxyquire": "2.0.1",
    "qs": "^6.2.0",
--- a/test/e2e/beta/contract-test/contract.js
+++ b/test/e2e/beta/contract-test/contract.js
@ -38,18 +38,20 @@ const transferTokens = document.getElementById('transferTokens')
 const approveTokens = document.getElementById('approveTokens')

 deployButton.addEventListener('click', async function (event) {
+  document.getElementById('contractStatus').innerHTML = 'Deploying'
+
  var piggybank = await piggybankContract.new(
    {
      from: web3.eth.accounts[0],
      data: '0x608060405234801561001057600080fd5b5033600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000808190555061023b806100686000396000f300608060405260043610610057576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632e1a7d4d1461005c5780638da5cb5b1461009d578063d0e30db0146100f4575b600080fd5b34801561006857600080fd5b5061008760048036038101908080359060200190929190505050610112565b6040518082815260200191505060405180910390f35b3480156100a957600080fd5b506100b26101d0565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6100fc6101f6565b6040518082815260200191505060405180910390f35b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614151561017057600080fd5b8160008082825403925050819055503373ffffffffffffffffffffffffffffffffffffffff166108fc839081150290604051600060405180830381858888f193505050501580156101c5573d6000803e3d6000fd5b506000549050919050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60003460008082825401925050819055506000549050905600a165627a7a72305820f237db3ec816a52589d82512117bc85bc08d3537683ffeff9059108caf3e5d400029',
      gas: '4700000',
    }, function (e, contract) {
-      console.log(e, contract)
+      if (e) {
+        throw e
+      }
      if (typeof contract.address !== 'undefined') {
        console.log('Contract mined! address: ' + contract.address + ' transactionHash: ' + contract.transactionHash)

-        console.log(`contract`, contract)
-
        document.getElementById('contractStatus').innerHTML = 'Deployed'

        depositButton.addEventListener('click', function (event) {
--- a/test/e2e/beta/contract-test/index.html
+++ b/test/e2e/beta/contract-test/index.html
@ -11,7 +11,7 @@
      <button id="withdrawButton">Withdraw</button>
    </div>
    <div id="contractStatus" style="display: flex; font-size: 1rem;">
-      Not yet deployed
+      Not clicked
    </div>
  </div>
  <div style="display: flex; flex-flow: column;">
--- a/test/e2e/beta/from-import-beta-ui.spec.js
+++ b/test/e2e/beta/from-import-beta-ui.spec.js
@ -89,7 +89,14 @@ describe('Using MetaMask with an existing account', function () {
        await driver.wait(until.stalenessOf(overlay))
      } catch (e) {}

-      const button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      let button
+      try {
+        button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      } catch (e) {
+        await loadExtension(driver, extensionId)
+        await delay(largeDelayMs)
+        button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      }
      await button.click()
      await delay(regularDelayMs)

--- a/test/e2e/beta/helpers.js
+++ b/test/e2e/beta/helpers.js
@ -2,8 +2,8 @@ const fs = require('fs')
 const mkdirp = require('mkdirp')
 const pify = require('pify')
 const assert = require('assert')
-const {until} = require('selenium-webdriver')
 const { delay } = require('../func')
+const { until } = require('selenium-webdriver')

 module.exports = {
  assertElementNotPresent,
@ -122,12 +122,14 @@ async function closeAllWindowHandlesExcept (driver, exceptions, windowHandles) {
 }

 async function assertElementNotPresent (webdriver, driver, by) {
+  let dataTab
  try {
-    const dataTab = await findElement(driver, by, 4000)
-    if (dataTab) {
-      assert(false, 'Data tab should not be present')
-    }
+    dataTab = await findElement(driver, by, 4000)
  } catch (err) {
-    assert(err instanceof webdriver.error.NoSuchElementError)
+    console.log(err)
+    assert(err instanceof webdriver.error.NoSuchElementError || err instanceof webdriver.error.TimeoutError)
+  }
+  if (dataTab) {
+    assert(false, 'Data tab should not be present')
  }
 }
--- a/test/e2e/beta/metamask-beta-ui.spec.js
+++ b/test/e2e/beta/metamask-beta-ui.spec.js
@ -88,7 +88,14 @@ describe('MetaMask', function () {
        await driver.wait(until.stalenessOf(overlay))
      } catch (e) {}

-      const button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      let button
+      try {
+        button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      } catch (e) {
+        await loadExtension(driver, extensionId)
+        await delay(largeDelayMs)
+        button = await findElement(driver, By.xpath("//button[contains(text(), 'Try it now')]"))
+      }
      await button.click()
      await delay(regularDelayMs)

@ -345,8 +352,8 @@ describe('MetaMask', function () {
      const passwordInputs = await driver.findElements(By.css('input'))
      await delay(regularDelayMs)

-      passwordInputs[0].sendKeys('correct horse battery staple')
-      passwordInputs[1].sendKeys('correct horse battery staple')
+      await passwordInputs[0].sendKeys('correct horse battery staple')
+      await passwordInputs[1].sendKeys('correct horse battery staple')
      await driver.findElement(By.css('.first-time-flow__button')).click()
      await delay(regularDelayMs)
    })
@ -438,7 +445,7 @@ describe('MetaMask', function () {
      await driver.switchTo().window(windowHandles[2])
      await delay(regularDelayMs)

-      assertElementNotPresent(webdriver, driver, By.xpath(`//li[contains(text(), 'Data')]`))
+      await assertElementNotPresent(webdriver, driver, By.xpath(`//li[contains(text(), 'Data')]`))

      const confirmButton = await findElement(driver, By.xpath(`//button[contains(text(), 'Confirm')]`), 10000)
      await confirmButton.click()
@ -453,6 +460,11 @@ describe('MetaMask', function () {
      const transactions = await findElements(driver, By.css('.tx-list-item'))
      assert.equal(transactions.length, 2)

+      await findElement(driver, By.xpath(`//span[contains(text(), 'Submitted')]`))
+
+      const txStatuses = await findElements(driver, By.css('.tx-list-status'))
+      await driver.wait(until.elementTextMatches(txStatuses[0], /Confirmed/))
+
      const txValues = await findElement(driver, By.css('.tx-list-value'))
      await driver.wait(until.elementTextMatches(txValues, /3\sETH/), 10000)
    })
@ -503,6 +515,8 @@ describe('MetaMask', function () {
      await confirmButton.click()
      await delay(regularDelayMs)

+      await findElement(driver, By.xpath(`//span[contains(text(), 'Submitted')]`))
+
      const txStatuses = await findElements(driver, By.css('.tx-list-status'))
      await driver.wait(until.elementTextMatches(txStatuses[0], /Confirmed/))

@ -511,19 +525,28 @@ describe('MetaMask', function () {
      await delay(regularDelayMs)
    })

+    it('confirms a deploy contract transaction in the popup', async () => {
+      const windowHandles = await driver.getAllWindowHandles()
+      const popup = windowHandles[2]
+      await driver.switchTo().window(popup)
+      const confirmButton = await findElement(driver, By.xpath(`//button[contains(text(), 'Confirm')]`))
+      await confirmButton.click()
+      await delay(regularDelayMs)
+    })
+
    it('calls and confirms a contract method where ETH is sent', async () => {
      await driver.switchTo().window(dapp)
      await delay(regularDelayMs)

-      let contractStatus = await driver.findElement(By.css('#contractStatus'))
-      await driver.wait(until.elementTextMatches(contractStatus, /Deployed/))
+      let contractStatus = await findElement(driver, By.css('#contractStatus'))
+      await driver.wait(until.elementTextMatches(contractStatus, /Deployed/), 15000)

      const depositButton = await findElement(driver, By.css('#depositButton'))
      await depositButton.click()
      await delay(largeDelayMs)

-      contractStatus = await driver.findElement(By.css('#contractStatus'))
-      await driver.wait(until.elementTextMatches(contractStatus, /Deposit\sinitiated/))
+      contractStatus = await findElement(driver, By.css('#contractStatus'))
+      await driver.wait(until.elementTextMatches(contractStatus, /Deposit\sinitiated/), 10000)

      await driver.switchTo().window(extension)
      await delay(largeDelayMs)
@ -539,8 +562,8 @@ describe('MetaMask', function () {
      await configureGas.click()
      await delay(regularDelayMs)

-      const gasModal = await driver.findElement(By.css('span .modal'))
-      await driver.wait(until.elementLocated(By.css('.customize-gas__title')))
+      const gasModal = await findElement(driver, By.css('span .modal'))
+      await driver.wait(until.elementLocated(By.css('.customize-gas__title')), 10000)

      const [gasPriceInput, gasLimitInput] = await findElements(driver, By.css('.customize-gas-input'))
      await gasPriceInput.clear()
@ -612,20 +635,21 @@ describe('MetaMask', function () {

  describe('Add a custom token from a dapp', () => {
    it('creates a new token', async () => {
-      const windowHandles = await driver.getAllWindowHandles()
+      let windowHandles = await driver.getAllWindowHandles()
      const extension = windowHandles[0]
      const dapp = windowHandles[1]
      await delay(regularDelayMs * 2)

      await driver.switchTo().window(dapp)
-      await delay(regularDelayMs)
+      await delay(regularDelayMs * 2)

      const createToken = await findElement(driver, By.xpath(`//button[contains(text(), 'Create Token')]`))
      await createToken.click()
-      await delay(regularDelayMs)
+      await delay(largeDelayMs)

-      await driver.switchTo().window(extension)
-      await loadExtension(driver, extensionId)
+      windowHandles = await driver.getAllWindowHandles()
+      const popup = windowHandles[2]
+      await driver.switchTo().window(popup)
      await delay(regularDelayMs)

      const confirmButton = await findElement(driver, By.xpath(`//button[contains(text(), 'Confirm')]`))
@ -1000,4 +1024,4 @@ describe('MetaMask', function () {
      await delay(regularDelayMs)
    })
  })
-})
+})
--- a/test/e2e/func.js
+++ b/test/e2e/func.js
@ -1,14 +1,19 @@
 require('chromedriver')
 require('geckodriver')
-const fs = require('fs')
+const fs = require('fs-extra')
 const os = require('os')
 const path = require('path')
+const pify = require('pify')
+const prependFile = pify(require('prepend-file'))
 const webdriver = require('selenium-webdriver')
 const Command = require('selenium-webdriver/lib/command').Command
 const By = webdriver.By

 module.exports = {
  delay,
+  createModifiedTestBuild,
+  setupBrowserAndExtension,
+  verboseReportOnFailure,
  buildChromeWebDriver,
  buildFirefoxWebdriver,
  installWebExt,
@ -20,6 +25,37 @@ function delay (time) {
  return new Promise(resolve => setTimeout(resolve, time))
 }

+async function createModifiedTestBuild ({ browser, srcPath }) {
+  // copy build to test-builds directory
+  const extPath = path.resolve(`test-builds/${browser}`)
+  await fs.ensureDir(extPath)
+  await fs.copy(srcPath, extPath)
+  // inject METAMASK_TEST_CONFIG setting default test network
+  const config = { NetworkController: { provider: { type: 'localhost' } } }
+  await prependFile(`${extPath}/background.js`, `window.METAMASK_TEST_CONFIG=${JSON.stringify(config)};\n`)
+  return { extPath }
+}
+
+async function setupBrowserAndExtension ({ browser, extPath }) {
+  let driver, extensionId, extensionUri
+
+  if (browser === 'chrome') {
+    driver = buildChromeWebDriver(extPath)
+    extensionId = await getExtensionIdChrome(driver)
+    extensionUri = `chrome-extension://${extensionId}/home.html`
+  } else if (browser === 'firefox') {
+    driver = buildFirefoxWebdriver()
+    await installWebExt(driver, extPath)
+    await delay(700)
+    extensionId = await getExtensionIdFirefox(driver)
+    extensionUri = `moz-extension://${extensionId}/home.html`
+  } else {
+    throw new Error(`Unknown Browser "${browser}"`)
+  }
+
+  return { driver, extensionId, extensionUri }
+}
+
 function buildChromeWebDriver (extPath) {
  const tmpProfile = fs.mkdtempSync(path.join(os.tmpdir(), 'mm-chrome-profile'))
  return new webdriver.Builder()
@ -61,3 +97,13 @@ async function installWebExt (driver, extension) {

  return await driver.schedule(cmd, 'installWebExt(' + extension + ')')
 }
+
+async function verboseReportOnFailure ({ browser, driver, title }) {
+  const artifactDir = `./test-artifacts/${browser}/${title}`
+  const filepathBase = `${artifactDir}/test-failure`
+  await fs.ensureDir(artifactDir)
+  const screenshot = await driver.takeScreenshot()
+  await fs.writeFile(`${filepathBase}-screenshot.png`, screenshot, { encoding: 'base64' })
+  const htmlSource = await driver.getPageSource()
+  await fs.writeFile(`${filepathBase}-dom.html`, htmlSource)
+}
--- a/test/e2e/metamask.spec.js
+++ b/test/e2e/metamask.spec.js
@ -1,49 +1,41 @@
-const fs = require('fs')
-const mkdirp = require('mkdirp')
 const path = require('path')
 const assert = require('assert')
-const pify = require('pify')
-const webdriver = require('selenium-webdriver')
-const { By, Key, until } = webdriver
-const { delay, buildChromeWebDriver, buildFirefoxWebdriver, installWebExt, getExtensionIdChrome, getExtensionIdFirefox } = require('./func')
+const { By, Key, until } = require('selenium-webdriver')
+const { delay, createModifiedTestBuild, setupBrowserAndExtension, verboseReportOnFailure } = require('./func')

 describe('Metamask popup page', function () {
-  let driver, accountAddress, tokenAddress, extensionId
+  const browser = process.env.SELENIUM_BROWSER
+  let driver, accountAddress, tokenAddress, extensionUri

  this.timeout(0)

  before(async function () {
-    if (process.env.SELENIUM_BROWSER === 'chrome') {
-      const extPath = path.resolve('dist/chrome')
-      driver = buildChromeWebDriver(extPath)
-      extensionId = await getExtensionIdChrome(driver)
-      await driver.get(`chrome-extension://${extensionId}/popup.html`)
+    const srcPath = path.resolve(`dist/${browser}`)
+    const { extPath } = await createModifiedTestBuild({ browser, srcPath })
+    const installResult = await setupBrowserAndExtension({ browser, extPath })
+    driver = installResult.driver
+    extensionUri = installResult.extensionUri

-    } else if (process.env.SELENIUM_BROWSER === 'firefox') {
-      const extPath = path.resolve('dist/firefox')
-      driver = buildFirefoxWebdriver()
-      await installWebExt(driver, extPath)
-      await delay(700)
-      extensionId = await getExtensionIdFirefox(driver)
-      await driver.get(`moz-extension://${extensionId}/popup.html`)
-    }
+    await driver.get(extensionUri)
+    await delay(300)
  })

  afterEach(async function () {
    // logs command not supported in firefox
    // https://github.com/SeleniumHQ/selenium/issues/2910
-    if (process.env.SELENIUM_BROWSER === 'chrome') {
+    if (browser === 'chrome') {
      // check for console errors
      const errors = await checkBrowserForConsoleErrors()
      if (errors.length) {
        const errorReports = errors.map(err => err.message)
        const errorMessage = `Errors found in browser console:\n${errorReports.join('\n')}`
-        this.test.error(new Error(errorMessage))
+        console.error(new Error(errorMessage))
+
      }
    }
    // gather extra data if test failed
    if (this.currentTest.state === 'failed') {
-      await verboseReportOnFailure(this.currentTest)
+      await verboseReportOnFailure({ browser, driver, title: this.currentTest.title })
    }
  })

@ -54,7 +46,6 @@ describe('Metamask popup page', function () {
  describe('Setup', function () {

    it('switches to Chrome extensions list', async function () {
-      await delay(300)
      const windowHandles = await driver.getAllWindowHandles()
      await driver.switchTo().window(windowHandles[0])
    })
@ -98,6 +89,7 @@ describe('Metamask popup page', function () {
    it('allows the button to be clicked when scrolled to the bottom of TOU', async () => {
      const button = await driver.findElement(By.css('#app-content > div > div.app-primary.from-right > div > div.flex-column.flex-center.flex-grow > button'))
      await button.click()
+      await delay(300)
    })

    it('shows privacy notice', async () => {
@ -108,7 +100,6 @@ describe('Metamask popup page', function () {
    })

    it('shows phishing notice', async () => {
-      await delay(300)
      const noticeHeader = await driver.findElement(By.css('.terms-header')).getText()
      assert.equal(noticeHeader, 'PHISHING WARNING', 'shows phishing warning')
      const element = await driver.findElement(By.css('.markdown'))
@ -295,11 +286,7 @@ describe('Metamask popup page', function () {
    })

    it('navigates back to MetaMask popup in the tab', async function () {
-      if (process.env.SELENIUM_BROWSER === 'chrome') {
-        await driver.get(`chrome-extension://${extensionId}/popup.html`)
-      } else if (process.env.SELENIUM_BROWSER === 'firefox') {
-        await driver.get(`moz-extension://${extensionId}/popup.html`)
-      }
+      await driver.get(extensionUri)
      await delay(700)
    })
  })
@ -362,21 +349,4 @@ describe('Metamask popup page', function () {
    return matchedErrorObjects
  }

-  async function verboseReportOnFailure (test) {
-    let artifactDir
-    if (process.env.SELENIUM_BROWSER === 'chrome') {
-      artifactDir = `./test-artifacts/chrome/${test.title}`
-    } else if (process.env.SELENIUM_BROWSER === 'firefox') {
-      artifactDir = `./test-artifacts/firefox/${test.title}`
-    }
-    const filepathBase = `${artifactDir}/test-failure`
-    await pify(mkdirp)(artifactDir)
-    // capture screenshot
-    const screenshot = await driver.takeScreenshot()
-    await pify(fs.writeFile)(`${filepathBase}-screenshot.png`, screenshot, { encoding: 'base64' })
-    // capture dom source
-    const htmlSource = await driver.getPageSource()
-    await pify(fs.writeFile)(`${filepathBase}-dom.html`, htmlSource)
-  }
-
 })
--- a/test/helper.js
+++ b/test/helper.js
@ -1,10 +1,21 @@
+const Ganache = require('ganache-core')
+const nock = require('nock')
 import Enzyme from 'enzyme'
 import Adapter from 'enzyme-adapter-react-15'

+nock.disableNetConnect()
+nock.enableNetConnect('localhost')
+
 Enzyme.configure({ adapter: new Adapter() })
 // disallow promises from swallowing errors
 enableFailureOnUnhandledPromiseRejection()

+// ganache server
+const server = Ganache.server()
+server.listen(8545, () => {
+  console.log('Ganache Testrpc is running on "http://localhost:8545"')
+})
+
 // logging util
 var log = require('loglevel')
 log.setDefaultLevel(5)
@ -14,6 +25,9 @@ global.log = log
 // polyfills
 //

+// fetch
+global.fetch = require('isomorphic-fetch')
+
 // dom
 require('jsdom-global')()

--- a/test/lib/createTxMeta.js
+++ b/test/lib/createTxMeta.js
@ -0,0 +1,16 @@
+const txStateHistoryHelper = require('../../app/scripts/controllers/transactions/lib/tx-state-history-helper')
+
+module.exports = createTxMeta
+
+function createTxMeta (partialMeta) {
+  const txMeta = Object.assign({
+    status: 'unapproved',
+    txParams: {},
+  }, partialMeta)
+  // initialize history
+  txMeta.history = []
+  // capture initial snapshot of txMeta for history
+  const snapshot = txStateHistoryHelper.snapshotFromTxMeta(txMeta)
+  txMeta.history.push(snapshot)
+  return txMeta
+}
--- a/test/unit/app/controllers/currency-controller-test.js
+++ b/test/unit/app/controllers/currency-controller-test.js
@ -1,6 +1,3 @@
-// polyfill fetch
-global.fetch = global.fetch || require('isomorphic-fetch')
-
 const assert = require('assert')
 const nock = require('nock')
 const CurrencyController = require('../../../../app/scripts/controllers/currency')
--- a/test/unit/app/controllers/detect-tokens-test.js
+++ b/test/unit/app/controllers/detect-tokens-test.js
@ -1,4 +1,5 @@
 const assert = require('assert')
+const nock = require('nock')
 const sinon = require('sinon')
 const ObservableStore = require('obs-store')
 const DetectTokensController = require('../../../../app/scripts/controllers/detect-tokens')
@ -6,15 +7,34 @@ const NetworkController = require('../../../../app/scripts/controllers/network/n
 const PreferencesController = require('../../../../app/scripts/controllers/preferences')

 describe('DetectTokensController', () => {
-    const sandbox = sinon.createSandbox()
-    let clock, keyringMemStore, network, preferences
-    beforeEach(async () => {
-      keyringMemStore = new ObservableStore({ isUnlocked: false})
-      network = new NetworkController({ provider: { type: 'mainnet' }})
-      preferences = new PreferencesController({ network })
-    })
-      after(() => {
-        sandbox.restore()
+  const sandbox = sinon.createSandbox()
+  let clock, keyringMemStore, network, preferences, controller
+
+  const noop = () => {}
+
+  const networkControllerProviderConfig = {
+    getAccounts: noop,
+  }
+
+  beforeEach(async () => {
+
+
+    nock('https://api.infura.io')
+      .get(/.*/)
+      .reply(200)
+
+    keyringMemStore = new ObservableStore({ isUnlocked: false})
+    network = new NetworkController()
+    preferences = new PreferencesController({ network })
+    controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
+
+    network.initializeProvider(networkControllerProviderConfig)
+
+  })
+
+  after(() => {
+    sandbox.restore()
+    nock.cleanAll()
  })

  it('should poll on correct interval', async () => {
@ -26,7 +46,10 @@ describe('DetectTokensController', () => {

  it('should be called on every polling period', async () => {
    clock = sandbox.useFakeTimers()
+    const network = new NetworkController()
+    network.initializeProvider(networkControllerProviderConfig)
    network.setProviderType('mainnet')
+    const preferences = new PreferencesController({ network })
    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.isUnlocked = true
@ -44,8 +67,6 @@ describe('DetectTokensController', () => {
  })

  it('should not check tokens while in test network', async () => {
-    network.setProviderType('rinkeby')
-    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.isUnlocked = true

@ -58,7 +79,6 @@ describe('DetectTokensController', () => {
  })

  it('should only check and add tokens while in main network', async () => {
-    network.setProviderType('mainnet')
    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.isUnlocked = true
@ -75,7 +95,6 @@ describe('DetectTokensController', () => {
  })

  it('should not detect same token while in main network', async () => {
-    network.setProviderType('mainnet')
    preferences.addToken('0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', 'J8T', 8)
    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
@ -93,8 +112,6 @@ describe('DetectTokensController', () => {
  })

  it('should trigger detect new tokens when change address', async () => {
-    network.setProviderType('mainnet')
-    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.isUnlocked = true
    var stub = sandbox.stub(controller, 'detectNewTokens')
@ -103,8 +120,6 @@ describe('DetectTokensController', () => {
  })

  it('should trigger detect new tokens when submit password', async () => {
-    network.setProviderType('mainnet')
-    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.selectedAddress = '0x0'
    var stub = sandbox.stub(controller, 'detectNewTokens')
@ -113,8 +128,6 @@ describe('DetectTokensController', () => {
  })

  it('should not trigger detect new tokens when not open or not unlocked', async () => {
-    network.setProviderType('mainnet')
-    const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
    controller.isOpen = true
    controller.isUnlocked = false
    var stub = sandbox.stub(controller, 'detectTokenBalance')
@ -125,4 +138,4 @@ describe('DetectTokensController', () => {
    clock.tick(180000)
    sandbox.assert.notCalled(stub)
  })
-})
+})
--- a/test/unit/app/controllers/metamask-controller-test.js
+++ b/test/unit/app/controllers/metamask-controller-test.js
@ -3,9 +3,10 @@ const sinon = require('sinon')
 const clone = require('clone')
 const nock = require('nock')
 const createThoughStream = require('through2').obj
-const MetaMaskController = require('../../../../app/scripts/metamask-controller')
 const blacklistJSON = require('eth-phishing-detect/src/config')
-const firstTimeState = require('../../../../app/scripts/first-time-state')
+const MetaMaskController = require('../../../../app/scripts/metamask-controller')
+const firstTimeState = require('../../../unit/localhostState')
+const createTxMeta = require('../../../lib/createTxMeta')

 const currentNetworkId = 42
 const DEFAULT_LABEL = 'Account 1'
@ -13,6 +14,7 @@ const TEST_SEED = 'debris dizzy just program just float decrease vacant alarm re
 const TEST_ADDRESS = '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'
 const TEST_SEED_ALT = 'setup olympic issue mobile velvet surge alcohol burger horse view reopen gentle'
 const TEST_ADDRESS_ALT = '0xc42edfcc21ed14dda456aa0756c153f7985d8813'
+const CUSTOM_RPC_URL = 'http://localhost:8545'

 describe('MetaMaskController', function () {
  let metamaskController
@ -360,29 +362,19 @@ describe('MetaMaskController', function () {
  })

  describe('#setCustomRpc', function () {
-    const customRPC = 'https://custom.rpc/'
    let rpcTarget

    beforeEach(function () {
-
-      nock('https://custom.rpc')
-      .post('/')
-      .reply(200)
-
-      rpcTarget = metamaskController.setCustomRpc(customRPC)
-    })
-
-    afterEach(function () {
-      nock.cleanAll()
+      rpcTarget = metamaskController.setCustomRpc(CUSTOM_RPC_URL)
    })

    it('returns custom RPC that when called', async function () {
-      assert.equal(await rpcTarget, customRPC)
+      assert.equal(await rpcTarget, CUSTOM_RPC_URL)
    })

    it('changes the network controller rpc', function () {
      const networkControllerState = metamaskController.networkController.store.getState()
-      assert.equal(networkControllerState.provider.rpcTarget, customRPC)
+      assert.equal(networkControllerState.provider.rpcTarget, CUSTOM_RPC_URL)
    })
  })

@ -487,9 +479,10 @@ describe('MetaMaskController', function () {
      getNetworkstub.returns(42)

      metamaskController.txController.txStateManager._saveTxList([
-        { id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'} },
-        { id: 2, status: 'rejected', metamaskNetworkId: 32, txParams: {} },
-        { id: 3, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {from: '0xB09d8505E1F4EF1CeA089D47094f5DD3464083d4'} },
+        createTxMeta({ id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'} }),
+        createTxMeta({ id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'} }),
+        createTxMeta({ id: 2, status: 'rejected', metamaskNetworkId: 32 }),
+        createTxMeta({ id: 3, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {from: '0xB09d8505E1F4EF1CeA089D47094f5DD3464083d4'} }),
      ])
    })

@ -566,14 +559,14 @@ describe('MetaMaskController', function () {

  })

-  describe('#newUnsignedMessage', function () {
+  describe('#newUnsignedMessage', () => {

    let msgParams, metamaskMsgs, messages, msgId

    const address = '0xc42edfcc21ed14dda456aa0756c153f7985d8813'
    const data = '0x43727970746f6b697474696573'

-    beforeEach(async function () {
+    beforeEach(async () => {

      await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED_ALT)

@ -582,7 +575,10 @@ describe('MetaMaskController', function () {
        'data': data,
      }

-      metamaskController.newUnsignedMessage(msgParams, noop)
+      const promise = metamaskController.newUnsignedMessage(msgParams)
+      // handle the promise so it doesn't throw an unhandledRejection
+      promise.then(noop).catch(noop)
+
      metamaskMsgs = metamaskController.messageManager.getUnapprovedMsgs()
      messages = metamaskController.messageManager.messages
      msgId = Object.keys(metamaskMsgs)[0]
@ -622,13 +618,16 @@ describe('MetaMaskController', function () {

  describe('#newUnsignedPersonalMessage', function () {

-    it('errors with no from in msgParams', function () {
+    it('errors with no from in msgParams', async () => {
      const msgParams = {
        'data': data,
      }
-      metamaskController.newUnsignedPersonalMessage(msgParams, function (error) {
+      try {
+        await metamaskController.newUnsignedPersonalMessage(msgParams)
+        assert.fail('should have thrown')
+      } catch (error) {
        assert.equal(error.message, 'MetaMask Message Signature: from field is required.')
-      })
+      }
    })

    let msgParams, metamaskPersonalMsgs, personalMessages, msgId
@ -645,7 +644,10 @@ describe('MetaMaskController', function () {
        'data': data,
      }

-      metamaskController.newUnsignedPersonalMessage(msgParams, noop)
+      const promise = metamaskController.newUnsignedPersonalMessage(msgParams)
+      // handle the promise so it doesn't throw an unhandledRejection
+      promise.then(noop).catch(noop)
+
      metamaskPersonalMsgs = metamaskController.personalMessageManager.getUnapprovedMsgs()
      personalMessages = metamaskController.personalMessageManager.messages
      msgId = Object.keys(metamaskPersonalMsgs)[0]
@ -684,22 +686,27 @@ describe('MetaMaskController', function () {
  describe('#setupUntrustedCommunication', function () {
    let streamTest

-    const phishingUrl = 'decentral.market'
+    const phishingUrl = 'myethereumwalletntw.com'

    afterEach(function () {
      streamTest.end()
    })

-    it('sets up phishing stream for untrusted communication ', async function () {
+    it('sets up phishing stream for untrusted communication ', async () => {
      await metamaskController.blacklistController.updatePhishingList()
+      console.log(blacklistJSON.blacklist.includes(phishingUrl))
+
+      const { promise, resolve } = deferredPromise()

      streamTest = createThoughStream((chunk, enc, cb) => {
-        assert.equal(chunk.name, 'phishing')
+        if (chunk.name !== 'phishing') return cb()
        assert.equal(chunk.data.hostname, phishingUrl)
-         cb()
-        })
-      // console.log(streamTest)
-       metamaskController.setupUntrustedCommunication(streamTest, phishingUrl)
+        resolve()
+        cb()
+      })
+      metamaskController.setupUntrustedCommunication(streamTest, phishingUrl)
+
+      await promise
    })
  })

@ -746,3 +753,9 @@ describe('MetaMaskController', function () {
  })

 })
+
+function deferredPromise () {
+  let resolve
+  const promise = new Promise(_resolve => { resolve = _resolve })
+  return { promise, resolve }
+}
--- a/test/unit/app/controllers/network-contoller-test.js
+++ b/test/unit/app/controllers/network-contoller-test.js
@ -32,9 +32,10 @@ describe('# Network Controller', function () {
    describe('#provider', function () {
      it('provider should be updatable without reassignment', function () {
        networkController.initializeProvider(networkControllerProviderConfig)
-        const proxy = networkController._proxy
-        proxy.setTarget({ test: true, on: () => {} })
-        assert.ok(proxy.test)
+        const providerProxy = networkController.getProviderAndBlockTracker().provider
+        assert.equal(providerProxy.test, undefined)
+        providerProxy.setTarget({ test: true })
+        assert.equal(providerProxy.test, true)
      })
    })
    describe('#getNetworkState', function () {
--- a/test/unit/app/controllers/transactions/nonce-tracker-test.js
+++ b/test/unit/app/controllers/transactions/nonce-tracker-test.js
@ -224,14 +224,15 @@ function generateNonceTrackerWith (pending, confirmed, providerStub = '0x0') {
  providerResultStub.result = providerStub
  const provider = {
    sendAsync: (_, cb) => { cb(undefined, providerResultStub) },
-    _blockTracker: {
-      getCurrentBlock: () => '0x11b568',
-    },
+  }
+  const blockTracker = {
+    getCurrentBlock: () => '0x11b568',
+    getLatestBlock: async () => '0x11b568',
  }
  return new NonceTracker({
    provider,
+    blockTracker,
    getPendingTransactions,
    getConfirmedTransactions,
  })
 }
-
--- a/test/unit/app/controllers/transactions/pending-tx-test.js
+++ b/test/unit/app/controllers/transactions/pending-tx-test.js
@ -9,6 +9,7 @@ describe('PendingTransactionTracker', function () {
  let pendingTxTracker, txMeta, txMetaNoHash, providerResultStub,
  provider, txMeta3, txList, knownErrors
  this.timeout(10000)
+
  beforeEach(function () {
    txMeta = {
      id: 1,
@ -40,7 +41,10 @@ describe('PendingTransactionTracker', function () {
      getPendingTransactions: () => { return [] },
      getCompletedTransactions: () => { return [] },
      publishTransaction: () => {},
+      confirmTransaction: () => {},
    })
+
+    pendingTxTracker._getBlock = (blockNumber) => { return {number: blockNumber, transactions: []} }
  })

  describe('_checkPendingTx state management', function () {
@ -92,58 +96,6 @@ describe('PendingTransactionTracker', function () {
    })
  })

-  describe('#checkForTxInBlock', function () {
-    it('should return if no pending transactions', function () {
-      // throw a type error if it trys to do anything on the block
-      // thus failing the test
-      const block = Proxy.revocable({}, {}).revoke()
-      pendingTxTracker.checkForTxInBlock(block)
-    })
-    it('should emit \'tx:failed\' if the txMeta does not have a hash', function (done) {
-      const block = Proxy.revocable({}, {}).revoke()
-      pendingTxTracker.getPendingTransactions = () => [txMetaNoHash]
-      pendingTxTracker.once('tx:failed', (txId, err) => {
-        assert(txId, txMetaNoHash.id, 'should pass txId')
-        done()
-      })
-      pendingTxTracker.checkForTxInBlock(block)
-    })
-    it('should emit \'txConfirmed\' if the tx is in the block', function (done) {
-      const block = { transactions: [txMeta]}
-      pendingTxTracker.getPendingTransactions = () => [txMeta]
-      pendingTxTracker.once('tx:confirmed', (txId) => {
-        assert(txId, txMeta.id, 'should pass txId')
-        done()
-      })
-      pendingTxTracker.once('tx:failed', (_, err) => { done(err) })
-      pendingTxTracker.checkForTxInBlock(block)
-    })
-  })
-  describe('#queryPendingTxs', function () {
-    it('should call #_checkPendingTxs if their is no oldBlock', function (done) {
-      let oldBlock
-      const newBlock = { number: '0x01' }
-      pendingTxTracker._checkPendingTxs = done
-      pendingTxTracker.queryPendingTxs({ oldBlock, newBlock })
-    })
-    it('should call #_checkPendingTxs if oldBlock and the newBlock have a diff of greater then 1', function (done) {
-      const oldBlock = { number: '0x01' }
-      const newBlock = { number: '0x03' }
-      pendingTxTracker._checkPendingTxs = done
-      pendingTxTracker.queryPendingTxs({ oldBlock, newBlock })
-    })
-    it('should not call #_checkPendingTxs if oldBlock and the newBlock have a diff of 1 or less', function (done) {
-      const oldBlock = { number: '0x1' }
-      const newBlock = { number: '0x2' }
-      pendingTxTracker._checkPendingTxs = () => {
-        const err = new Error('should not call #_checkPendingTxs if oldBlock and the newBlock have a diff of 1 or less')
-        done(err)
-      }
-      pendingTxTracker.queryPendingTxs({ oldBlock, newBlock })
-      done()
-    })
-  })
-
  describe('#_checkPendingTx', function () {
    it('should emit \'tx:failed\' if the txMeta does not have a hash', function (done) {
      pendingTxTracker.once('tx:failed', (txId, err) => {
@ -157,16 +109,6 @@ describe('PendingTransactionTracker', function () {
      providerResultStub.eth_getTransactionByHash = null
      pendingTxTracker._checkPendingTx(txMeta)
    })
-
-    it('should emit \'txConfirmed\'', function (done) {
-      providerResultStub.eth_getTransactionByHash = {blockNumber: '0x01'}
-      pendingTxTracker.once('tx:confirmed', (txId) => {
-        assert(txId, txMeta.id, 'should pass txId')
-        done()
-      })
-      pendingTxTracker.once('tx:failed', (_, err) => { done(err) })
-      pendingTxTracker._checkPendingTx(txMeta)
-    })
  })

  describe('#_checkPendingTxs', function () {
@ -180,19 +122,19 @@ describe('PendingTransactionTracker', function () {
      })
    })

-    it('should warp all txMeta\'s in #_checkPendingTx', function (done) {
+    it('should warp all txMeta\'s in #updatePendingTxs', function (done) {
      pendingTxTracker.getPendingTransactions = () => txList
      pendingTxTracker._checkPendingTx = (tx) => { tx.resolve(tx) }
      Promise.all(txList.map((tx) => tx.processed))
      .then((txCompletedList) => done())
      .catch(done)

-      pendingTxTracker._checkPendingTxs()
+      pendingTxTracker.updatePendingTxs()
    })
  })

  describe('#resubmitPendingTxs', function () {
-    const blockStub = { number: '0x0' }
+    const blockNumberStub = '0x0'
    beforeEach(function () {
    const txMeta2 = txMeta3 = txMeta
    txList = [txMeta, txMeta2, txMeta3].map((tx) => {
@ -210,7 +152,7 @@ describe('PendingTransactionTracker', function () {
      Promise.all(txList.map((tx) => tx.processed))
      .then((txCompletedList) => done())
      .catch(done)
-      pendingTxTracker.resubmitPendingTxs(blockStub)
+      pendingTxTracker.resubmitPendingTxs(blockNumberStub)
    })
    it('should not emit \'tx:failed\' if the txMeta throws a known txError', function (done) {
      knownErrors = [
@ -237,7 +179,7 @@ describe('PendingTransactionTracker', function () {
      .then((txCompletedList) => done())
      .catch(done)

-      pendingTxTracker.resubmitPendingTxs(blockStub)
+      pendingTxTracker.resubmitPendingTxs(blockNumberStub)
    })
    it('should emit \'tx:warning\' if it encountered a real error', function (done) {
      pendingTxTracker.once('tx:warning', (txMeta, err) => {
@ -255,7 +197,7 @@ describe('PendingTransactionTracker', function () {
      .then((txCompletedList) => done())
      .catch(done)

-      pendingTxTracker.resubmitPendingTxs(blockStub)
+      pendingTxTracker.resubmitPendingTxs(blockNumberStub)
    })
  })
  describe('#_resubmitTx', function () {
--- a/test/unit/app/controllers/transactions/tx-controller-test.js
+++ b/test/unit/app/controllers/transactions/tx-controller-test.js
@ -1,4 +1,5 @@
 const assert = require('assert')
+const EventEmitter = require('events')
 const ethUtil = require('ethereumjs-util')
 const EthTx = require('ethereumjs-tx')
 const ObservableStore = require('obs-store')
@ -22,12 +23,14 @@ describe('Transaction Controller', function () {
    }
    provider = createTestProviderTools({ scaffold: providerResultStub }).provider
    fromAccount = getTestAccounts()[0]
-
+    const blockTrackerStub = new EventEmitter()
+    blockTrackerStub.getCurrentBlock = noop
+    blockTrackerStub.getLatestBlock = noop
    txController = new TransactionController({
      provider,
      networkStore: new ObservableStore(currentNetworkId),
      txHistoryLimit: 10,
-      blockTracker: { getCurrentBlock: noop, on: noop, once: noop },
+      blockTracker: blockTrackerStub,
      signTransaction: (ethTx) => new Promise((resolve) => {
        ethTx.sign(fromAccount.key)
        resolve()
@ -49,9 +52,9 @@ describe('Transaction Controller', function () {
  describe('#getUnapprovedTxCount', function () {
    it('should return the number of unapproved txs', function () {
      txController.txStateManager._saveTxList([
-        { id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {} },
-        { id: 2, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {} },
-        { id: 3, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {} },
+        { id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
+        { id: 2, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
+        { id: 3, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
      ])
      const unapprovedTxCount = txController.getUnapprovedTxCount()
      assert.equal(unapprovedTxCount, 3, 'should be 3')
@ -61,9 +64,9 @@ describe('Transaction Controller', function () {
  describe('#getPendingTxCount', function () {
    it('should return the number of pending txs', function () {
      txController.txStateManager._saveTxList([
-        { id: 1, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {} },
-        { id: 2, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {} },
-        { id: 3, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {} },
+        { id: 1, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
+        { id: 2, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
+        { id: 3, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: {}, history: [] },
      ])
      const pendingTxCount = txController.getPendingTxCount()
      assert.equal(pendingTxCount, 3, 'should be 3')
@ -79,15 +82,15 @@ describe('Transaction Controller', function () {
        'to': '0xc684832530fcbddae4b4230a47e991ddcec2831d',
      }
      txController.txStateManager._saveTxList([
-        {id: 0, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 1, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 2, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 3, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 4, status: 'rejected', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 5, status: 'approved', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 6, status: 'signed', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 7, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams},
-        {id: 8, status: 'failed', metamaskNetworkId: currentNetworkId, txParams},
+        {id: 0, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 1, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 2, status: 'confirmed', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 3, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 4, status: 'rejected', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 5, status: 'approved', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 6, status: 'signed', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 7, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams, history: [] },
+        {id: 8, status: 'failed', metamaskNetworkId: currentNetworkId, txParams, history: [] },
      ])
    })

@ -201,24 +204,22 @@ describe('Transaction Controller', function () {
  })

  describe('#addTxGasDefaults', function () {
-    it('should add the tx defaults if their are none', function (done) {
+    it('should add the tx defaults if their are none', async () => {
      const txMeta = {
-        'txParams': {
-          'from': '0xc684832530fcbddae4b4230a47e991ddcec2831d',
-          'to': '0xc684832530fcbddae4b4230a47e991ddcec2831d',
+        txParams: {
+          from: '0xc684832530fcbddae4b4230a47e991ddcec2831d',
+          to: '0xc684832530fcbddae4b4230a47e991ddcec2831d',
        },
+        history: [],
      }
-        providerResultStub.eth_gasPrice = '4a817c800'
-        providerResultStub.eth_getBlockByNumber = { gasLimit: '47b784' }
-        providerResultStub.eth_estimateGas = '5209'
-      txController.addTxGasDefaults(txMeta)
-      .then((txMetaWithDefaults) => {
-        assert(txMetaWithDefaults.txParams.value, '0x0', 'should have added 0x0 as the value')
-        assert(txMetaWithDefaults.txParams.gasPrice, 'should have added the gas price')
-        assert(txMetaWithDefaults.txParams.gas, 'should have added the gas field')
-        done()
-      })
-      .catch(done)
+      providerResultStub.eth_gasPrice = '4a817c800'
+      providerResultStub.eth_getBlockByNumber = { gasLimit: '47b784' }
+      providerResultStub.eth_estimateGas = '5209'
+
+      const txMetaWithDefaults = await txController.addTxGasDefaults(txMeta)
+      assert(txMetaWithDefaults.txParams.value, '0x0', 'should have added 0x0 as the value')
+      assert(txMetaWithDefaults.txParams.gasPrice, 'should have added the gas price')
+      assert(txMetaWithDefaults.txParams.gas, 'should have added the gas field')
    })
  })

@ -381,8 +382,9 @@ describe('Transaction Controller', function () {
    })

    it('should publish a tx, updates the rawTx when provided a one', async function () {
+      const rawTx = '0x477b2e6553c917af0db0388ae3da62965ff1a184558f61b749d1266b2e6d024c'
      txController.txStateManager.addTx(txMeta)
-      await txController.publishTransaction(txMeta.id)
+      await txController.publishTransaction(txMeta.id, rawTx)
      const publishedTx = txController.txStateManager.getTx(1)
      assert.equal(publishedTx.hash, hash)
      assert.equal(publishedTx.status, 'submitted')
@ -398,7 +400,7 @@ describe('Transaction Controller', function () {
        data: '0x0',
      }
      txController.txStateManager._saveTxList([
-        { id: 1, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams },
+        { id: 1, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams, history: [] },
      ])
      txController.retryTransaction(1)
      .then((txMeta) => {
--- a/test/unit/config-manager-test.js
+++ b/test/unit/config-manager-test.js
@ -1,6 +1,3 @@
-// polyfill fetch
-global.fetch = global.fetch || require('isomorphic-fetch')
-
 const assert = require('assert')
 const configManagerGen = require('../lib/mock-config-manager')

--- a/test/unit/localhostState.js
+++ b/test/unit/localhostState.js
@ -0,0 +1,21 @@
+
+/**
+ * @typedef {Object} FirstTimeState
+ * @property {Object} config Initial configuration parameters
+ * @property {Object} NetworkController Network controller state
+ */
+
+/**
+ * @type {FirstTimeState}
+ */
+const initialState = {
+  config: {},
+    NetworkController: {
+      provider: {
+        type: 'rpc',
+        rpcTarget: 'http://localhost:8545',
+      },
+    },
+}
+
+module.exports = initialState