Merge branch 'develop' into no-inject-ani-gamer

11 files changed, 442 insertions, 45 deletions

diff --git a/app/scripts/background.js b/app/scripts/background.js
index 1479d9f72..7eb7b1255 100644
--- a/app/scripts/background.js
+++ b/app/scripts/background.js
@@ -44,8 +44,8 @@ const notificationManager = new NotificationManager()
 global.METAMASK_NOTIFIER = notificationManager
 
 // setup sentry error reporting
-const release = platform.getVersion()
-const raven = setupRaven({ release })
+const releaseVersion = platform.getVersion()
+const raven = setupRaven({ releaseVersion })
 
 // browser check if it is Edge - https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
 // Internet Explorer 6-11
@@ -53,6 +53,7 @@ const isIE = !!document.documentMode
 // Edge 20+
 const isEdge = !isIE && !!window.StyleMedia
 
+let ipfsHandle
 let popupIsOpen = false
 let notificationIsOpen = false
 const openMetamaskTabsIDs = {}
@@ -158,7 +159,7 @@ async function initialize () {
   const initLangCode = await getFirstPreferredLangCode()
   await setupController(initState, initLangCode)
   log.debug('MetaMask initialization complete.')
-  ipfsContent(initState.NetworkController.provider)
+  ipfsHandle = ipfsContent(initState.NetworkController.provider)
 }
 
 //
@@ -262,6 +263,10 @@ function setupController (initState, initLangCode) {
   })
   global.metamaskController = controller
 
+  controller.networkController.on('networkDidChange', () => {
+    ipfsHandle && ipfsHandle.remove()
+    ipfsHandle = ipfsContent(controller.networkController.providerStore.getState())
+  })
 
   // report failed transactions to Sentry
   controller.txController.on(`tx:status-update`, (txId, status) => {
diff --git a/app/scripts/contentscript.js b/app/scripts/contentscript.js
index f2a2469c9..7b7114c35 100644
--- a/app/scripts/contentscript.js
+++ b/app/scripts/contentscript.js
@@ -179,6 +179,7 @@ function blacklistedDomainCheck () {
     'gravityforms.com',
     'harbourair.com',
     'ani.gamer.com.tw',
+    'blueskybooking.com',
   ]
   var currentUrl = window.location.href
   var currentRegex
diff --git a/app/scripts/controllers/detect-tokens.js b/app/scripts/controllers/detect-tokens.js
new file mode 100644
index 000000000..195ec918a
--- /dev/null
+++ b/app/scripts/controllers/detect-tokens.js
@@ -0,0 +1,130 @@
+const Web3 = require('web3')
+const contracts = require('eth-contract-metadata')
+const { warn } = require('loglevel')
+const { MAINNET } = require('./network/enums')
+// By default, poll every 3 minutes
+const DEFAULT_INTERVAL = 180 * 1000
+const ERC20_ABI = [{'constant': true, 'inputs': [{'name': '_owner', 'type': 'address'}], 'name': 'balanceOf', 'outputs': [{'name': 'balance', 'type': 'uint256'}], 'payable': false, 'type': 'function'}]
+
+/**
+ * A controller that polls for token exchange
+ * rates based on a user's current token list
+ */
+class DetectTokensController {
+  /**
+   * Creates a DetectTokensController
+   *
+   * @param {Object} [config] - Options to configure controller
+   */
+  constructor ({ interval = DEFAULT_INTERVAL, preferences, network, keyringMemStore } = {}) {
+    this.preferences = preferences
+    this.interval = interval
+    this.network = network
+    this.keyringMemStore = keyringMemStore
+  }
+
+  /**
+   * For each token in eth-contract-metada, find check selectedAddress balance.
+   *
+   */
+  async detectNewTokens () {
+    if (!this.isActive) { return }
+    if (this._network.store.getState().provider.type !== MAINNET) { return }
+    this.web3.setProvider(this._network._provider)
+    for (const contractAddress in contracts) {
+      if (contracts[contractAddress].erc20 && !(this.tokenAddresses.includes(contractAddress.toLowerCase()))) {
+        this.detectTokenBalance(contractAddress)
+      }
+    }
+  }
+
+   /**
+   * Find if selectedAddress has tokens with contract in contractAddress.
+   *
+   * @param {string} contractAddress Hex address of the token contract to explore.
+   * @returns {boolean} If balance is detected, token is added.
+   *
+   */
+  async detectTokenBalance (contractAddress) {
+    const ethContract = this.web3.eth.contract(ERC20_ABI).at(contractAddress)
+    ethContract.balanceOf(this.selectedAddress, (error, result) => {
+      if (!error) {
+        if (!result.isZero()) {
+          this._preferences.addToken(contractAddress, contracts[contractAddress].symbol, contracts[contractAddress].decimals)
+        }
+      } else {
+        warn(`MetaMask - DetectTokensController balance fetch failed for ${contractAddress}.`, error)
+      }
+    })
+  }
+
+  /**
+   * Restart token detection polling period and call detectNewTokens
+   * in case of address change or user session initialization.
+   *
+   */
+  restartTokenDetection () {
+    if (!(this.isActive && this.selectedAddress)) { return }
+    this.detectNewTokens()
+    this.interval = DEFAULT_INTERVAL
+  }
+
+  /**
+   * @type {Number}
+   */
+  set interval (interval) {
+    this._handle && clearInterval(this._handle)
+    if (!interval) { return }
+    this._handle = setInterval(() => { this.detectNewTokens() }, interval)
+  }
+
+  /**
+   * In setter when selectedAddress is changed, detectNewTokens and restart polling
+   * @type {Object}
+   */
+  set preferences (preferences) {
+    if (!preferences) { return }
+    this._preferences = preferences
+    preferences.store.subscribe(({ tokens }) => { this.tokenAddresses = tokens.map((obj) => { return obj.address }) })
+    preferences.store.subscribe(({ selectedAddress }) => {
+      if (this.selectedAddress !== selectedAddress) {
+        this.selectedAddress = selectedAddress
+        this.restartTokenDetection()
+      }
+    })
+  }
+
+  /**
+   * @type {Object}
+   */
+  set network (network) {
+    if (!network) { return }
+    this._network = network
+    this.web3 = new Web3(network._provider)
+  }
+
+  /**
+   * In setter when isUnlocked is updated to true, detectNewTokens and restart polling
+   * @type {Object}
+   */
+  set keyringMemStore (keyringMemStore) {
+    if (!keyringMemStore) { return }
+    this._keyringMemStore = keyringMemStore
+    this._keyringMemStore.subscribe(({ isUnlocked }) => {
+      if (this.isUnlocked !== isUnlocked) {
+        this.isUnlocked = isUnlocked
+        if (isUnlocked) { this.restartTokenDetection() }
+      }
+    })
+  }
+
+  /**
+   * Internal isActive state
+   * @type {Object}
+   */
+  get isActive () {
+    return this.isOpen && this.isUnlocked
+  }
+}
+
+module.exports = DetectTokensController
diff --git a/app/scripts/controllers/preferences.js b/app/scripts/controllers/preferences.js
index b314745f5..f6250dc16 100644
--- a/app/scripts/controllers/preferences.js
+++ b/app/scripts/controllers/preferences.js
@@ -86,6 +86,30 @@ class PreferencesController {
   }
 
   /**
+   * Removes an address from state
+   *
+   * @param {string} address A hex address
+   * @returns {string} the address that was removed
+   */
+  removeAddress (address) {
+    const identities = this.store.getState().identities
+    if (!identities[address]) {
+      throw new Error(`${address} can't be deleted cause it was not found`)
+    }
+    delete identities[address]
+    this.store.updateState({ identities })
+
+    // If the selected account is no longer valid,
+    // select an arbitrary other account:
+    if (address === this.getSelectedAddress()) {
+      const selected = Object.keys(identities)[0]
+      this.setSelectedAddress(selected)
+    }
+    return address
+  }
+
+
+  /**
    * Adds addresses to the identities object without removing identities
    *
    * @param {string[]} addresses An array of hex addresses
diff --git a/app/scripts/lib/ipfsContent.js b/app/scripts/lib/ipfsContent.js
index a6b99b2f9..5222151ea 100644
--- a/app/scripts/lib/ipfsContent.js
+++ b/app/scripts/lib/ipfsContent.js
@@ -2,39 +2,43 @@ const extension = require('extensionizer')
 const resolver = require('./resolver.js')
 
 module.exports = function (provider) {
-    extension.webRequest.onBeforeRequest.addListener(details => {
-        const urlhttpreplace = details.url.replace(/\w+?:\/\//, '')
-        const url = urlhttpreplace.replace(/[\\/].*/g, '') // eslint-disable-line no-useless-escape
-        let domainhtml = urlhttpreplace.match(/[\\/].*/g) // eslint-disable-line no-useless-escape
-        let clearTime = null
-        const name = url.replace(/\/$/g, '')
-        if (domainhtml === null) domainhtml = ['']
-        extension.tabs.getSelected(null, tab => {
-            extension.tabs.update(tab.id, { url: 'loading.html' })
+    function ipfsContent (details) {
+      const name = details.url.substring(7, details.url.length - 1)
+      let clearTime = null
+      extension.tabs.getSelected(null, tab => {
+          extension.tabs.update(tab.id, { url: 'loading.html' })
 
-            clearTime = setTimeout(() => {
-                return extension.tabs.update(tab.id, { url: '404.html' })
-            }, 60000)
+          clearTime = setTimeout(() => {
+              return extension.tabs.update(tab.id, { url: '404.html' })
+          }, 60000)
 
-            resolver.resolve(name, provider).then(ipfsHash => {
-                clearTimeout(clearTime)
-                let url = 'https://ipfs.infura.io/ipfs/' + ipfsHash + domainhtml[0]
-                return fetch(url, { method: 'HEAD' }).then(response => response.status).then(statusCode => {
-                    if (statusCode !== 200) return extension.tabs.update(tab.id, { url: '404.html' })
-                    extension.tabs.update(tab.id, { url: url })
-                })
-                .catch(err => {
-                    url = 'https://ipfs.infura.io/ipfs/' + ipfsHash + domainhtml[0]
-                    extension.tabs.update(tab.id, {url: url})
-                    return err
-                })
-            })
-            .catch(err => {
-                clearTimeout(clearTime)
-                const url = err === 'unsupport' ? 'unsupport' : 'error'
-                extension.tabs.update(tab.id, {url: `${url}.html?name=${name}`})
-            })
-        })
-        return { cancel: true }
-    }, {urls: ['*://*.eth/', '*://*.eth/*']})
+          resolver.resolve(name, provider).then(ipfsHash => {
+              clearTimeout(clearTime)
+              let url = 'https://ipfs.infura.io/ipfs/' + ipfsHash
+              return fetch(url, { method: 'HEAD' }).then(response => response.status).then(statusCode => {
+                  if (statusCode !== 200) return extension.tabs.update(tab.id, { url: '404.html' })
+                  extension.tabs.update(tab.id, { url: url })
+              })
+              .catch(err => {
+                  url = 'https://ipfs.infura.io/ipfs/' + ipfsHash
+                  extension.tabs.update(tab.id, {url: url})
+                  return err
+              })
+          })
+          .catch(err => {
+              clearTimeout(clearTime)
+              const url = err === 'unsupport' ? 'unsupport' : 'error'
+              extension.tabs.update(tab.id, {url: `${url}.html?name=${name}`})
+          })
+      })
+      return { cancel: true }
+    }
+
+    extension.webRequest.onBeforeRequest.addListener(ipfsContent, {urls: ['*://*.eth/', '*://*.test/']})
+
+    return {
+      remove () {
+        extension.webRequest.onBeforeRequest.removeListener(ipfsContent)
+      },
+    }
 }
diff --git a/app/scripts/lib/resolver.js b/app/scripts/lib/resolver.js
index 6786929d8..ff0fed161 100644
--- a/app/scripts/lib/resolver.js
+++ b/app/scripts/lib/resolver.js
@@ -60,8 +60,8 @@ function getRegistrar (type) {
 
 module.exports.resolve = function (name, provider) {
   const path = name.split('.')
-  const tld = path[path.length - 1]
-  if (tld === 'eth') {
+  const topLevelDomain = path[path.length - 1]
+  if (topLevelDomain === 'eth' || topLevelDomain === 'test') {
     return ens(name, provider)
   } else {
     return new Promise((resolve, reject) => {
diff --git a/app/scripts/lib/setupRaven.js b/app/scripts/lib/setupRaven.js
index 3f69fb3bb..e657e278f 100644
--- a/app/scripts/lib/setupRaven.js
+++ b/app/scripts/lib/setupRaven.js
@@ -8,8 +8,10 @@ module.exports = setupRaven
 
 // Setup raven / sentry remote error reporting
 function setupRaven (opts) {
-  const { release } = opts
+  const { releaseVersion } = opts
   let ravenTarget
+  // detect brave
+  const isBrave = Boolean(window.chrome.ipcRenderer)
 
   if (METAMASK_DEBUG) {
     console.log('Setting up Sentry Remote Error Reporting: DEV')
@@ -20,9 +22,11 @@ function setupRaven (opts) {
   }
 
   const client = Raven.config(ravenTarget, {
-    release,
+    releaseVersion,
     transport: function (opts) {
+      opts.data.extra.isBrave = isBrave
       const report = opts.data
+
       try {
         // handle error-like non-error exceptions
         rewriteErrorLikeExceptions(report)
diff --git a/app/scripts/lib/util.js b/app/scripts/lib/util.js
index 431d1e59c..51e9036cc 100644
--- a/app/scripts/lib/util.js
+++ b/app/scripts/lib/util.js
@@ -28,7 +28,7 @@ function getStack () {
  *
  */
 const getEnvironmentType = (url = window.location.href) => {
-  if (url.match(/popup.html(?:\?.+)*$/)) {
+  if (url.match(/popup.html(?:#.*)*$/)) {
     return ENVIRONMENT_TYPE_POPUP
   } else if (url.match(/home.html(?:\?.+)*$/) || url.match(/home.html(?:#.*)*$/)) {
     return ENVIRONMENT_TYPE_FULLSCREEN
diff --git a/app/scripts/metamask-controller.js b/app/scripts/metamask-controller.js
index 450113acf..bcc7075c2 100644
--- a/app/scripts/metamask-controller.js
+++ b/app/scripts/metamask-controller.js
@@ -35,6 +35,7 @@ const TypedMessageManager = require('./lib/typed-message-manager')
 const TransactionController = require('./controllers/transactions')
 const BalancesController = require('./controllers/computed-balances')
 const TokenRatesController = require('./controllers/token-rates')
+const DetectTokensController = require('./controllers/detect-tokens')
 const ConfigManager = require('./lib/config-manager')
 const nodeify = require('./lib/nodeify')
 const accountImporter = require('./account-import-strategies')
@@ -47,6 +48,7 @@ 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')
 
 module.exports = class MetamaskController extends EventEmitter {
 
@@ -124,7 +126,9 @@ module.exports = class MetamaskController extends EventEmitter {
     })
 
     // key mgmt
+    const additionalKeyrings = [TrezorKeyring]
     this.keyringController = new KeyringController({
+      keyringTypes: additionalKeyrings,
       initState: initState.KeyringController,
       getNetwork: this.networkController.getNetworkState.bind(this.networkController),
       encryptor: opts.encryptor || undefined,
@@ -144,6 +148,13 @@ module.exports = class MetamaskController extends EventEmitter {
       this.accountTracker.syncWithAddresses(addresses)
     })
 
+    // detect tokens controller
+    this.detectTokensController = new DetectTokensController({
+      preferences: this.preferencesController,
+      network: this.networkController,
+      keyringMemStore: this.keyringController.memStore,
+    })
+
     // address book controller
     this.addressBookController = new AddressBookController({
       initState: initState.AddressBookController,
@@ -164,6 +175,13 @@ module.exports = class MetamaskController extends EventEmitter {
     })
     this.txController.on('newUnapprovedTx', opts.showUnapprovedTx.bind(opts))
 
+    this.txController.on(`tx:status-update`, (txId, status) => {
+      if (status === 'confirmed' || status === 'failed') {
+        const txMeta = this.txController.txStateManager.getTx(txId)
+        this.platform.showTransactionNotification(txMeta)
+      }
+    })
+
     // computed balances (accounting for pending transactions)
     this.balancesController = new BalancesController({
       accountTracker: this.accountTracker,
@@ -351,8 +369,17 @@ module.exports = class MetamaskController extends EventEmitter {
       verifySeedPhrase: nodeify(this.verifySeedPhrase, this),
       clearSeedWordCache: this.clearSeedWordCache.bind(this),
       resetAccount: nodeify(this.resetAccount, this),
+      removeAccount: nodeify(this.removeAccount, this),
       importAccountWithStrategy: nodeify(this.importAccountWithStrategy, this),
 
+      // hardware wallets
+      connectHardware: nodeify(this.connectHardware, this),
+      forgetDevice: nodeify(this.forgetDevice, this),
+      checkHardwareStatus: nodeify(this.checkHardwareStatus, this),
+
+      // TREZOR
+      unlockTrezorAccount: nodeify(this.unlockTrezorAccount, this),
+
       // vault management
       submitPassword: nodeify(this.submitPassword, this),
 
@@ -509,6 +536,127 @@ module.exports = class MetamaskController extends EventEmitter {
   }
 
   //
+  // Hardware
+  //
+
+  /**
+   * Fetch account list from a trezor device.
+   *
+   * @returns [] accounts
+   */
+  async connectHardware (deviceName, page) {
+
+    switch (deviceName) {
+      case 'trezor':
+        const keyringController = this.keyringController
+        const oldAccounts = await keyringController.getAccounts()
+        let keyring = await keyringController.getKeyringsByType(
+          'Trezor Hardware'
+        )[0]
+        if (!keyring) {
+          keyring = await this.keyringController.addNewKeyring('Trezor Hardware')
+        }
+        let accounts = []
+
+        switch (page) {
+            case -1:
+              accounts = await keyring.getPreviousPage()
+              break
+            case 1:
+              accounts = await keyring.getNextPage()
+              break
+            default:
+              accounts = await keyring.getFirstPage()
+        }
+
+        // Merge with existing accounts
+        // and make sure addresses are not repeated
+        const accountsToTrack = [...new Set(oldAccounts.concat(accounts.map(a => a.address.toLowerCase())))]
+        this.accountTracker.syncWithAddresses(accountsToTrack)
+        return accounts
+
+      default:
+        throw new Error('MetamaskController:connectHardware - Unknown device')
+    }
+  }
+
+  /**
+   * Check if the device is unlocked
+   *
+   * @returns {Promise<boolean>}
+   */
+  async checkHardwareStatus (deviceName) {
+
+    switch (deviceName) {
+      case 'trezor':
+        const keyringController = this.keyringController
+        const keyring = await keyringController.getKeyringsByType(
+          'Trezor Hardware'
+        )[0]
+        if (!keyring) {
+          return false
+        }
+        return keyring.isUnlocked()
+      default:
+        throw new Error('MetamaskController:checkHardwareStatus - Unknown device')
+    }
+  }
+
+  /**
+   * Clear
+   *
+   * @returns {Promise<boolean>}
+   */
+  async forgetDevice (deviceName) {
+
+    switch (deviceName) {
+      case 'trezor':
+        const keyringController = this.keyringController
+        const keyring = await keyringController.getKeyringsByType(
+          'Trezor Hardware'
+        )[0]
+        if (!keyring) {
+          throw new Error('MetamaskController:forgetDevice - Trezor Hardware keyring not found')
+        }
+        keyring.forgetDevice()
+        return true
+      default:
+        throw new Error('MetamaskController:forgetDevice - Unknown device')
+    }
+  }
+
+  /**
+   * Imports an account from a trezor device.
+   *
+   * @returns {} keyState
+   */
+  async unlockTrezorAccount (index) {
+    const keyringController = this.keyringController
+    const keyring = await keyringController.getKeyringsByType(
+      'Trezor Hardware'
+    )[0]
+    if (!keyring) {
+      throw new Error('MetamaskController - No Trezor Hardware Keyring found')
+    }
+
+    keyring.setAccountToUnlock(index)
+    const oldAccounts = await keyringController.getAccounts()
+    const keyState = await keyringController.addNewAccount(keyring)
+    const newAccounts = await keyringController.getAccounts()
+    this.preferencesController.setAddresses(newAccounts)
+    newAccounts.forEach(address => {
+      if (!oldAccounts.includes(address)) {
+        this.preferencesController.setAccountLabel(address, `TREZOR #${parseInt(index, 10) + 1}`)
+        this.preferencesController.setSelectedAddress(address)
+      }
+    })
+
+    const { identities } = this.preferencesController.store.getState()
+    return { ...keyState, identities }
+   }
+
+
+  //
   // Account Management
   //
 
@@ -621,6 +769,23 @@ module.exports = class MetamaskController extends EventEmitter {
   }
 
   /**
+   * Removes an account from state / storage.
+   *
+   * @param {string[]} address A hex address
+   *
+   */
+  async removeAccount (address) {
+    // Remove account from the preferences controller
+    this.preferencesController.removeAddress(address)
+    // Remove account from the account tracker controller
+    this.accountTracker.removeAccount(address)
+    // Remove account from the keyring
+    await this.keyringController.removeAccount(address)
+    return address
+  }
+
+
+  /**
    * Imports an account with the specified import strategy.
    * These are defined in app/scripts/account-import-strategies
    * Each strategy represents a different way of serializing an Ethereum key pair.
@@ -1267,10 +1432,12 @@ module.exports = class MetamaskController extends EventEmitter {
   set isClientOpen (open) {
     this._isClientOpen = open
     this.isClientOpenAndUnlocked = this.getState().isUnlocked && open
+    this.detectTokensController.isOpen = open
   }
 
   /**
-   * A method for activating the retrieval of price data, which should only be fetched when the UI is visible.
+   * A method for activating the retrieval of price data and auto detect tokens,
+   * which should only be fetched when the UI is visible.
    * @private
    * @param {boolean} active - True if price data should be getting fetched.
    */
diff --git a/app/scripts/platforms/extension.js b/app/scripts/platforms/extension.js
index f5cc255d1..0803164e8 100644
--- a/app/scripts/platforms/extension.js
+++ b/app/scripts/platforms/extension.js
@@ -1,4 +1,5 @@
 const extension = require('extensionizer')
+const explorerLink = require('etherscan-link').createExplorerLink
 
 class ExtensionPlatform {
 
@@ -13,12 +14,21 @@ class ExtensionPlatform {
     extension.tabs.create({ url })
   }
 
+  closeCurrentWindow () {
+    return extension.windows.getCurrent((windowDetails) => {
+      return extension.windows.remove(windowDetails.id)
+    })
+  }
+
   getVersion () {
     return extension.runtime.getManifest().version
   }
 
-  openExtensionInBrowser () {
-    const extensionURL = extension.runtime.getURL('home.html')
+  openExtensionInBrowser (route = null) {
+    let extensionURL = extension.runtime.getURL('home.html')
+    if (route) {
+      extensionURL += `#${route}`
+    }
     this.openWindow({ url: extensionURL })
   }
 
@@ -31,6 +41,59 @@ class ExtensionPlatform {
       cb(e)
     }
   }
+
+  showTransactionNotification (txMeta) {
+
+    const status = txMeta.status
+    if (status === 'confirmed') {
+      this._showConfirmedTransaction(txMeta)
+    } else if (status === 'failed') {
+      this._showFailedTransaction(txMeta)
+    }
+  }
+
+  _showConfirmedTransaction (txMeta) {
+
+    this._subscribeToNotificationClicked()
+
+    const url = explorerLink(txMeta.hash, parseInt(txMeta.metamaskNetworkId))
+    const nonce = parseInt(txMeta.txParams.nonce, 16)
+
+    const title = 'Confirmed transaction'
+    const message = `Transaction ${nonce} confirmed! View on EtherScan`
+    this._showNotification(title, message, url)
+  }
+
+  _showFailedTransaction (txMeta) {
+
+    const nonce = parseInt(txMeta.txParams.nonce, 16)
+    const title = 'Failed transaction'
+    const message = `Transaction ${nonce} failed! ${txMeta.err.message}`
+    this._showNotification(title, message)
+  }
+
+  _showNotification (title, message, url) {
+    extension.notifications.create(
+      url,
+      {
+      'type': 'basic',
+      'title': title,
+      'iconUrl': extension.extension.getURL('../../images/icon-64.png'),
+      'message': message,
+      })
+  }
+
+  _subscribeToNotificationClicked () {
+    if (!extension.notifications.onClicked.hasListener(this._viewOnEtherScan)) {
+      extension.notifications.onClicked.addListener(this._viewOnEtherScan)
+    }
+  }
+
+  _viewOnEtherScan (txId) {
+    if (txId.startsWith('http://')) {
+      global.metamaskController.platform.openWindow({ url: txId })
+    }
+  }
 }
 
 module.exports = ExtensionPlatform
diff --git a/app/scripts/ui.js b/app/scripts/ui.js
index 9bf97be87..da100f928 100644
--- a/app/scripts/ui.js
+++ b/app/scripts/ui.js
@@ -64,7 +64,6 @@ async function start () {
         css = betaUIState ? NewMetaMaskUiCss() : OldMetaMaskUiCss()
         deleteInjectedCss = injectCss(css)
       }
-      if (state.appState.shouldClose) notificationManager.closePopup()
     })
   })