fix conflicts

author: brunobar79 <brunobar79@gmail.com> 2018-10-17 02:01:54 +0800
committer: brunobar79 <brunobar79@gmail.com> 2018-10-17 02:01:54 +0800
commit: 13820b6cc1801a420f39cdfecd7ccb5309dc597b (patch)
tree: c79832d7077ab03e0afe0c322cb32b204865d8b5 /test
parent: eeecee01540fbad50c4c463a3b1a54142a63f168 (diff)
parent: 07ab613d4c647e3fe554bc06eab8cfb833315a88 (diff)
download: tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.gz
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.bz2
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.lz
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.xz
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.zst
tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.zip
34 files changed, 3609 insertions, 217 deletions
diff --git a/test/data/2-state.json b/test/data/2-state.json
new file mode 100644
index 000000000..d41a403ff
--- /dev/null
+++ b/test/data/2-state.json
@@ -0,0 +1,70 @@
+{ "isInitialized": true,
+  "provider": { "type": "rpc", "rpcTarget": "http://localhost:8545" },
+  "network": "loading",
+  "accounts": {
+    "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc": {
+      "address": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+      "balance": "0x0"
+    },
+    "0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b": {
+      "address": "0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b",
+      "balance": "0x0"
+    }
+  },
+  "currentBlockGasLimit": "",
+  "unapprovedTxs": {},
+  "selectedAddressTxList": [],
+  "computedBalances": {},
+  "unapprovedMsgs": {},
+  "unapprovedMsgCount": 0,
+  "unapprovedPersonalMsgs": {},
+  "unapprovedPersonalMsgCount": 0,
+  "unapprovedTypedMessages": {},
+  "unapprovedTypedMessagesCount": 0,
+  "isUnlocked": true,
+  "keyringTypes": [ "Simple Key Pair", "HD Key Tree" ],
+  "keyrings":[
+    { "type": "HD Key Tree",
+      "accounts": [
+        "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc"
+      ]
+    },
+    {
+      "type": "Simple Key Pair",
+      "accounts": [
+        "0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b"
+      ]
+    }
+    ],
+  "frequentRpcList": [],
+  "currentAccountTab": "history",
+  "tokens": [],
+  "useBlockie": false,
+  "featureFlags": {},
+  "currentLocale": null,
+  "identities": {
+    "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc": {
+      "name": "Account 1",
+      "address": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc"
+    },
+    "0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b": {
+      "name": "Account 2",
+      "address": "0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b"
+    }
+  },
+
+  "lostIdentities": {},
+  "selectedAddress": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+  "recentBlocks": [],
+  "addressBook": [],
+  "currentCurrency": "usd",
+  "conversionRate": 288.45,
+  "conversionDate": 1506444677,
+  "nextUnreadNotice": null,
+  "noActiveNotices": true,
+  "shapeShiftTxList": [],
+  "infuraNetworkStatus": {},
+  "lostAccounts": [],
+  "seedWords": "debris dizzy just program just float decrease vacant alarm reduce speak stadium",
+  "forgottenPassword": null
+}
+\ No newline at end of file
diff --git a/test/data/mock-state.json b/test/data/mock-state.json
new file mode 100644
index 000000000..7e083c60e
--- /dev/null
+++ b/test/data/mock-state.json
@@ -0,0 +1,1251 @@
+{
+  "metamask": {
+    "network": "4",
+    "identities": {
+      "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc": {
+        "address": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+        "name": "Test Account"
+      },
+      "0xc42edfcc21ed14dda456aa0756c153f7985d8813": {
+        "address": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+        "name": "Test Account 2"
+      }
+    },
+    "unapprovedTxs": {
+      "8393540981007587": {
+        "id": 8393540981007587,
+        "time": 1536268017676,
+        "status": "unapproved",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+          "to": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+          "value": "0x0",
+          "gas": "0x5208",
+          "gasPrice": "0x3b9aca00"
+        },
+        "history": [
+          {
+            "id": 8393540981007587,
+            "time": 1536268017676,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+              "to": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+              "value": "0x0",
+              "gas": "0x5208",
+              "gasPrice": "0x3b9aca00"
+            }
+          },
+          [
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false,
+              "timestamp": 1536268017685
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0x5208"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "MetaMask",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1536268017686
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": true,
+        "estimatedGas": "0x5208",
+        "origin": "MetaMask"
+      }
+    },
+    "selectedAddress": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc",
+    "accounts": {
+      "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc": {
+        "balance": "0x0",
+        "address": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc"
+      },
+      "0xc42edfcc21ed14dda456aa0756c153f7985d8813": {
+        "address": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+        "balance": "0x0"
+      }
+    },
+    "tokens": [
+      {
+        "address": "0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d",
+        "symbol": "TEST",
+        "decimals": "0"
+      },
+      {
+        "address": "0xd8f6a2ffb0fc5952d16c9768b71cfd35b6399aa5",
+        "decimals": "8",
+        "symbol": "TEST2"
+      },
+      {
+        "address": "0x617b3f8050a0bd94b6b1da02b4384ee5b4df13f4",
+        "symbol": "META",
+        "decimals": "18"
+      }
+    ],
+    "contractExchangeRates": {
+      "0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d": 0.00039345803819379796,
+      "0xd8f6a2ffb0fc5952d16c9768b71cfd35b6399aa5": 0.00008189274407698049
+    },
+    "currentCurrency": "usd",
+    "conversionRate": 556.12,
+    "addressBook": [
+      {
+        "address": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+        "name": ""
+      }
+    ],
+    "selectedTokenAddress": "0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d",
+    "unapprovedMsgs": {},
+    "unapprovedMsgCount": 0,
+    "unapprovedPersonalMsgs": {},
+    "unapprovedPersonalMsgCount": 0,
+    "unapprovedTypedMessages": {},
+    "unapprovedTypedMessagesCount": 0,
+    "send": {
+      "gasLimit": "0x5208",
+      "gasPrice": "0xee6b2800",
+      "gasTotal": "0x4c65c6294000",
+      "tokenBalance": null,
+      "from": "0xc42edfcc21ed14dda456aa0756c153f7985d8813",
+      "to": "",
+      "amount": "1bc16d674ec80000",
+      "memo": "",
+      "errors": {},
+      "maxModeOn": false,
+      "editingTransactionId": null,
+      "forceGasMin": null,
+      "toNickname": ""
+    },
+    "selectedAddressTxList": [
+      {
+        "id": 3387511061307736,
+        "time": 1528133130531,
+        "status": "confirmed",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+          "value": "0x1bc16d674ec80000",
+          "gas": "0xcf08",
+          "gasPrice": "0x3b9aca00",
+          "nonce": "0xb5"
+        },
+        "history": [
+          {
+            "id": 3387511061307736,
+            "time": 1528133130531,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+              "value": "0x1bc16d674ec80000",
+              "gas": "0xcf08",
+              "gasPrice": "0x3b9aca00"
+            }
+          },
+          [
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false,
+              "timestamp": 1528133130666
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0xcf08"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "MetaMask",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133130667
+            }
+          ],
+          [],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "approved",
+              "note": "txStateManager: setting status to approved",
+              "timestamp": 1528133131716
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/txParams/nonce",
+              "value": "0xb5",
+              "note": "transactions#approveTransaction",
+              "timestamp": 1528133131806
+            },
+            {
+              "op": "add",
+              "path": "/nonceDetails",
+              "value": {
+                "params": {
+                  "highestLocallyConfirmed": 0,
+                  "highestSuggested": 181,
+                  "nextNetworkNonce": 181
+                },
+                "local": {
+                  "name": "local",
+                  "nonce": 181,
+                  "details": {
+                    "startPoint": 181,
+                    "highest": 181
+                  }
+                },
+                "network": {
+                  "name": "network",
+                  "nonce": 181,
+                  "details": {
+                    "baseCount": 181
+                  }
+                }
+              }
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "signed",
+              "note": "transactions#publishTransaction",
+              "timestamp": 1528133131825
+            },
+            {
+              "op": "add",
+              "path": "/rawTx",
+              "value": "0xf86c81b5843b9aca0082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba03f879cd33a31180da38545d0f809822e00ddf35954d8b0ece83bacf22347ce54a06ad050487978e425ca6a014ed55ea8e9a190069863ed96a0eefa88d729ea1eda"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "add",
+              "path": "/hash",
+              "value": "0x516b77569173a04c76fdb6545cf279ebd0c75f5d25d6e4ce019925205f0e3709",
+              "note": "transactions#setTxHash",
+              "timestamp": 1528133131951
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/submittedTime",
+              "value": 1528133131951,
+              "note": "txStateManager - add submitted time stamp",
+              "timestamp": 1528133131952
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "submitted",
+              "note": "txStateManager: setting status to submitted",
+              "timestamp": 1528133131955
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/firstRetryBlockNumber",
+              "value": "0x24af6b",
+              "note": "transactions/pending-tx-tracker#event: tx:block-update",
+              "timestamp": 1528133134414
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "confirmed",
+              "note": "txStateManager: setting status to confirmed",
+              "timestamp": 1528133158516
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": true,
+        "estimatedGas": "0xcf08",
+        "origin": "MetaMask",
+        "nonceDetails": {
+          "params": {
+            "highestLocallyConfirmed": 0,
+            "highestSuggested": 181,
+            "nextNetworkNonce": 181
+          },
+          "local": {
+            "name": "local",
+            "nonce": 181,
+            "details": {
+              "startPoint": 181,
+              "highest": 181
+            }
+          },
+          "network": {
+            "name": "network",
+            "nonce": 181,
+            "details": {
+              "baseCount": 181
+            }
+          }
+        },
+        "rawTx": "0xf86c81b5843b9aca0082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba03f879cd33a31180da38545d0f809822e00ddf35954d8b0ece83bacf22347ce54a06ad050487978e425ca6a014ed55ea8e9a190069863ed96a0eefa88d729ea1eda",
+        "hash": "0x516b77569173a04c76fdb6545cf279ebd0c75f5d25d6e4ce019925205f0e3709",
+        "submittedTime": 1528133131951,
+        "firstRetryBlockNumber": "0x24af6b"
+      },
+      {
+        "id": 3387511061307737,
+        "time": 1528133149983,
+        "status": "confirmed",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+          "value": "0x1bc16d674ec80000",
+          "gas": "0xcf08",
+          "gasPrice": "0x3b9aca00",
+          "nonce": "0xb6"
+        },
+        "history": [
+          {
+            "id": 3387511061307737,
+            "time": 1528133149983,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+              "value": "0x1bc16d674ec80000",
+              "gas": "0xcf08",
+              "gasPrice": "0x3b9aca00"
+            }
+          },
+          [
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false,
+              "timestamp": 1528133150011
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0xcf08"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "MetaMask",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133150013
+            }
+          ],
+          [],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "approved",
+              "note": "txStateManager: setting status to approved",
+              "timestamp": 1528133151102
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/txParams/nonce",
+              "value": "0xb6",
+              "note": "transactions#approveTransaction",
+              "timestamp": 1528133151189
+            },
+            {
+              "op": "add",
+              "path": "/nonceDetails",
+              "value": {
+                "params": {
+                  "highestLocallyConfirmed": 0,
+                  "highestSuggested": 181,
+                  "nextNetworkNonce": 181
+                },
+                "local": {
+                  "name": "local",
+                  "nonce": 182,
+                  "details": {
+                    "startPoint": 181,
+                    "highest": 182
+                  }
+                },
+                "network": {
+                  "name": "network",
+                  "nonce": 181,
+                  "details": {
+                    "baseCount": 181
+                  }
+                }
+              }
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "signed",
+              "note": "transactions#publishTransaction",
+              "timestamp": 1528133151203
+            },
+            {
+              "op": "add",
+              "path": "/rawTx",
+              "value": "0xf86c81b6843b9aca0082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba0692deaabf0d79544d41e7c475ad43760679a4f25d0fee908b1da308db1a291a7a0384db85fc6c843ea25986a0760f3c50ab6504fc559fc71fc7f23f60950eb316d"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "add",
+              "path": "/hash",
+              "value": "0x9271b266d05022cfa841362fae43763ebafcee540d84278b0157ef4a68d4e26f",
+              "note": "transactions#setTxHash",
+              "timestamp": 1528133151342
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/submittedTime",
+              "value": 1528133151347,
+              "note": "txStateManager - add submitted time stamp",
+              "timestamp": 1528133151347
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "submitted",
+              "note": "txStateManager: setting status to submitted",
+              "timestamp": 1528133151368
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/firstRetryBlockNumber",
+              "value": "0x24af6d",
+              "note": "transactions/pending-tx-tracker#event: tx:block-update",
+              "timestamp": 1528133158532
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "confirmed",
+              "note": "txStateManager: setting status to confirmed",
+              "timestamp": 1528133190636
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": true,
+        "estimatedGas": "0xcf08",
+        "origin": "MetaMask",
+        "nonceDetails": {
+          "params": {
+            "highestLocallyConfirmed": 0,
+            "highestSuggested": 181,
+            "nextNetworkNonce": 181
+          },
+          "local": {
+            "name": "local",
+            "nonce": 182,
+            "details": {
+              "startPoint": 181,
+              "highest": 182
+            }
+          },
+          "network": {
+            "name": "network",
+            "nonce": 181,
+            "details": {
+              "baseCount": 181
+            }
+          }
+        },
+        "rawTx": "0xf86c81b6843b9aca0082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba0692deaabf0d79544d41e7c475ad43760679a4f25d0fee908b1da308db1a291a7a0384db85fc6c843ea25986a0760f3c50ab6504fc559fc71fc7f23f60950eb316d",
+        "hash": "0x9271b266d05022cfa841362fae43763ebafcee540d84278b0157ef4a68d4e26f",
+        "submittedTime": 1528133151347,
+        "firstRetryBlockNumber": "0x24af6d"
+      },
+      {
+        "id": 3387511061307738,
+        "time": 1528133180635,
+        "status": "confirmed",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+          "value": "0x1bc16d674ec80000",
+          "gas": "0xcf08",
+          "gasPrice": "0x12a05f200",
+          "nonce": "0xb7"
+        },
+        "history": [
+          {
+            "id": 3387511061307738,
+            "time": 1528133180635,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0x92e659448c48fc926ec942d0da1459260d36bb33",
+              "value": "0x1bc16d674ec80000",
+              "gas": "0xcf08",
+              "gasPrice": "0x12a05f200"
+            }
+          },
+          [
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false,
+              "timestamp": 1528133180720
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0xcf08"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "MetaMask",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133180722
+            }
+          ],
+          [],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "approved",
+              "note": "txStateManager: setting status to approved",
+              "timestamp": 1528133181623
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/txParams/nonce",
+              "value": "0xb7",
+              "note": "transactions#approveTransaction",
+              "timestamp": 1528133181726
+            },
+            {
+              "op": "add",
+              "path": "/nonceDetails",
+              "value": {
+                "params": {
+                  "highestLocallyConfirmed": 182,
+                  "highestSuggested": 182,
+                  "nextNetworkNonce": 182
+                },
+                "local": {
+                  "name": "local",
+                  "nonce": 183,
+                  "details": {
+                    "startPoint": 182,
+                    "highest": 183
+                  }
+                },
+                "network": {
+                  "name": "network",
+                  "nonce": 182,
+                  "details": {
+                    "baseCount": 182
+                  }
+                }
+              }
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "signed",
+              "note": "transactions#publishTransaction",
+              "timestamp": 1528133181749
+            },
+            {
+              "op": "add",
+              "path": "/rawTx",
+              "value": "0xf86d81b785012a05f20082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba086f9846798be6988c39a5cf85f0dbe267e59ca0b96a6a7077e92cba33e10a258a064ffa52ac90c238ce21e6f085283216191b185a1eccd7daae6e2ab66ba26ada0"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "add",
+              "path": "/hash",
+              "value": "0x4e061e977c099735bc9e5203e717f7d9dccb3fcb2f82031a12a3ed326f95d43b",
+              "note": "transactions#setTxHash",
+              "timestamp": 1528133181885
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/submittedTime",
+              "value": 1528133181885,
+              "note": "txStateManager - add submitted time stamp",
+              "timestamp": 1528133181885
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "submitted",
+              "note": "txStateManager: setting status to submitted",
+              "timestamp": 1528133181888
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/firstRetryBlockNumber",
+              "value": "0x24af6f",
+              "note": "transactions/pending-tx-tracker#event: tx:block-update",
+              "timestamp": 1528133190653
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "confirmed",
+              "note": "txStateManager: setting status to confirmed",
+              "timestamp": 1528133222745
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": true,
+        "estimatedGas": "0xcf08",
+        "origin": "MetaMask",
+        "nonceDetails": {
+          "params": {
+            "highestLocallyConfirmed": 182,
+            "highestSuggested": 182,
+            "nextNetworkNonce": 182
+          },
+          "local": {
+            "name": "local",
+            "nonce": 183,
+            "details": {
+              "startPoint": 182,
+              "highest": 183
+            }
+          },
+          "network": {
+            "name": "network",
+            "nonce": 182,
+            "details": {
+              "baseCount": 182
+            }
+          }
+        },
+        "rawTx": "0xf86d81b785012a05f20082cf089492e659448c48fc926ec942d0da1459260d36bb33881bc16d674ec80000802ba086f9846798be6988c39a5cf85f0dbe267e59ca0b96a6a7077e92cba33e10a258a064ffa52ac90c238ce21e6f085283216191b185a1eccd7daae6e2ab66ba26ada0",
+        "hash": "0x4e061e977c099735bc9e5203e717f7d9dccb3fcb2f82031a12a3ed326f95d43b",
+        "submittedTime": 1528133181885,
+        "firstRetryBlockNumber": "0x24af6f"
+      },
+      {
+        "id": 3387511061307739,
+        "time": 1528133223918,
+        "status": "confirmed",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0xfe2149773b3513703e79ad23d05a778a185016ee",
+          "value": "0xaa87bee538000",
+          "data": "0xea94496b000000000000000000000000000000000000000000000000000000000001e1eb000000000000000000000000000000000000000000000000000000000001de33",
+          "gasPrice": "0x3b9aca00",
+          "gas": "0x6169e",
+          "nonce": "0xb8"
+        },
+        "history": [
+          {
+            "id": 3387511061307739,
+            "time": 1528133223918,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0xfe2149773b3513703e79ad23d05a778a185016ee",
+              "value": "0xaa87bee538000",
+              "data": "0xea94496b000000000000000000000000000000000000000000000000000000000001e1eb000000000000000000000000000000000000000000000000000000000001de33",
+              "gasPrice": "0x3b9aca00"
+            }
+          },
+          [
+            {
+              "op": "add",
+              "path": "/txParams/gas",
+              "value": "0x6169e",
+              "timestamp": 1528133225488
+            },
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": false
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "40f14"
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/estimatedGas",
+              "value": "40f14",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133225492
+            },
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "crypko.ai"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "approved",
+              "note": "txStateManager: setting status to approved",
+              "timestamp": 1528133227279
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/txParams/nonce",
+              "value": "0xb8",
+              "note": "transactions#approveTransaction",
+              "timestamp": 1528133227374
+            },
+            {
+              "op": "add",
+              "path": "/nonceDetails",
+              "value": {
+                "params": {
+                  "highestLocallyConfirmed": 184,
+                  "highestSuggested": 184,
+                  "nextNetworkNonce": 184
+                },
+                "local": {
+                  "name": "local",
+                  "nonce": 184,
+                  "details": {
+                    "startPoint": 184,
+                    "highest": 184
+                  }
+                },
+                "network": {
+                  "name": "network",
+                  "nonce": 184,
+                  "details": {
+                    "baseCount": 184
+                  }
+                }
+              }
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "signed",
+              "note": "transactions#publishTransaction",
+              "timestamp": 1528133227405
+            },
+            {
+              "op": "add",
+              "path": "/rawTx",
+              "value": "0xf8b181b8843b9aca008306169e94fe2149773b3513703e79ad23d05a778a185016ee870aa87bee538000b844ea94496b000000000000000000000000000000000000000000000000000000000001e1eb000000000000000000000000000000000000000000000000000000000001de332ca07bb2efbb8529d67606f9f89e7934c594a31d50c7d24a3286c20a2944a3b8c2a9a07b55ebd8aa28728ce0e38dd3b3503b78fccedae80053626d8649c68346c7c49c"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "add",
+              "path": "/hash",
+              "value": "0x466ae7d4b7c270121f0a8d68fbc6c9091ffc4aa976a553a5bfa56a79cf9f63dd",
+              "note": "transactions#setTxHash",
+              "timestamp": 1528133227534
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/submittedTime",
+              "value": 1528133227538,
+              "note": "txStateManager - add submitted time stamp",
+              "timestamp": 1528133227538
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "submitted",
+              "note": "txStateManager: setting status to submitted",
+              "timestamp": 1528133227543
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/firstRetryBlockNumber",
+              "value": "0x24af72",
+              "note": "transactions/pending-tx-tracker#event: tx:block-update",
+              "timestamp": 1528133238980
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "confirmed",
+              "note": "txStateManager: setting status to confirmed",
+              "timestamp": 1528133255035
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": false,
+        "estimatedGas": "40f14",
+        "origin": "crypko.ai",
+        "nonceDetails": {
+          "params": {
+            "highestLocallyConfirmed": 184,
+            "highestSuggested": 184,
+            "nextNetworkNonce": 184
+          },
+          "local": {
+            "name": "local",
+            "nonce": 184,
+            "details": {
+              "startPoint": 184,
+              "highest": 184
+            }
+          },
+          "network": {
+            "name": "network",
+            "nonce": 184,
+            "details": {
+              "baseCount": 184
+            }
+          }
+        },
+        "rawTx": "0xf8b181b8843b9aca008306169e94fe2149773b3513703e79ad23d05a778a185016ee870aa87bee538000b844ea94496b000000000000000000000000000000000000000000000000000000000001e1eb000000000000000000000000000000000000000000000000000000000001de332ca07bb2efbb8529d67606f9f89e7934c594a31d50c7d24a3286c20a2944a3b8c2a9a07b55ebd8aa28728ce0e38dd3b3503b78fccedae80053626d8649c68346c7c49c",
+        "hash": "0x466ae7d4b7c270121f0a8d68fbc6c9091ffc4aa976a553a5bfa56a79cf9f63dd",
+        "submittedTime": 1528133227538,
+        "firstRetryBlockNumber": "0x24af72"
+      },
+      {
+        "id": 3387511061307740,
+        "time": 1528133291381,
+        "status": "confirmed",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d",
+          "value": "0x0",
+          "data": "0xa9059cbb00000000000000000000000092e659448c48fc926ec942d0da1459260d36bb330000000000000000000000000000000000000000000000000000000000000002",
+          "gas": "0xd508",
+          "gasPrice": "0x3b9aca00",
+          "nonce": "0xb9"
+        },
+        "history": [
+          {
+            "id": 3387511061307740,
+            "time": 1528133291381,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d",
+              "value": "0x0",
+              "data": "0xa9059cbb00000000000000000000000092e659448c48fc926ec942d0da1459260d36bb330000000000000000000000000000000000000000000000000000000000000002",
+              "gas": "0xd508",
+              "gasPrice": "0x3b9aca00"
+            }
+          },
+          [
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false,
+              "timestamp": 1528133291486
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0xd508"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "MetaMask",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133291486
+            }
+          ],
+          [],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "approved",
+              "note": "txStateManager: setting status to approved",
+              "timestamp": 1528133293588
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/txParams/nonce",
+              "value": "0xb9",
+              "note": "transactions#approveTransaction",
+              "timestamp": 1528133293706
+            },
+            {
+              "op": "add",
+              "path": "/nonceDetails",
+              "value": {
+                "params": {
+                  "highestLocallyConfirmed": 185,
+                  "highestSuggested": 185,
+                  "nextNetworkNonce": 185
+                },
+                "local": {
+                  "name": "local",
+                  "nonce": 185,
+                  "details": {
+                    "startPoint": 185,
+                    "highest": 185
+                  }
+                },
+                "network": {
+                  "name": "network",
+                  "nonce": 185,
+                  "details": {
+                    "baseCount": 185
+                  }
+                }
+              }
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "signed",
+              "note": "transactions#publishTransaction",
+              "timestamp": 1528133293724
+            },
+            {
+              "op": "add",
+              "path": "/rawTx",
+              "value": "0xf8a981b9843b9aca0082d50894108cf70c7d384c552f42c07c41c0e1e46d77ea0d80b844a9059cbb00000000000000000000000092e659448c48fc926ec942d0da1459260d36bb3300000000000000000000000000000000000000000000000000000000000000022ca04f05310490d3e3a9a159ae25f52cec9afb0a69527d30be832aaae12e64ff056ea075f81a5220bed481e764bab8830c57169c59fe528ca9cf3442f47f7618a9b4a9"
+            }
+          ],
+          [],
+          [
+            {
+              "op": "add",
+              "path": "/hash",
+              "value": "0x3680dc9815cd05b620b6dd0017d949604ca7d92f051d5542fc8a5ecaa876af09",
+              "note": "transactions#setTxHash",
+              "timestamp": 1528133293853
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/submittedTime",
+              "value": 1528133293859,
+              "note": "txStateManager - add submitted time stamp",
+              "timestamp": 1528133293862
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "submitted",
+              "note": "txStateManager: setting status to submitted",
+              "timestamp": 1528133293867
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/firstRetryBlockNumber",
+              "value": "0x24af76",
+              "note": "transactions/pending-tx-tracker#event: tx:block-update",
+              "timestamp": 1528133295200
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "confirmed",
+              "note": "txStateManager: setting status to confirmed",
+              "timestamp": 1528133327522
+            }
+          ]
+        ],
+        "gasPriceSpecified": true,
+        "gasLimitSpecified": true,
+        "estimatedGas": "0xd508",
+        "origin": "MetaMask",
+        "nonceDetails": {
+          "params": {
+            "highestLocallyConfirmed": 185,
+            "highestSuggested": 185,
+            "nextNetworkNonce": 185
+          },
+          "local": {
+            "name": "local",
+            "nonce": 185,
+            "details": {
+              "startPoint": 185,
+              "highest": 185
+            }
+          },
+          "network": {
+            "name": "network",
+            "nonce": 185,
+            "details": {
+              "baseCount": 185
+            }
+          }
+        },
+        "rawTx": "0xf8a981b9843b9aca0082d50894108cf70c7d384c552f42c07c41c0e1e46d77ea0d80b844a9059cbb00000000000000000000000092e659448c48fc926ec942d0da1459260d36bb3300000000000000000000000000000000000000000000000000000000000000022ca04f05310490d3e3a9a159ae25f52cec9afb0a69527d30be832aaae12e64ff056ea075f81a5220bed481e764bab8830c57169c59fe528ca9cf3442f47f7618a9b4a9",
+        "hash": "0x3680dc9815cd05b620b6dd0017d949604ca7d92f051d5542fc8a5ecaa876af09",
+        "submittedTime": 1528133293859,
+        "firstRetryBlockNumber": "0x24af76"
+      },
+      {
+        "id": 3387511061307741,
+        "time": 1528133318440,
+        "status": "rejected",
+        "metamaskNetworkId": "4",
+        "loadingDefaults": false,
+        "txParams": {
+          "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "to": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+          "value": "0x0",
+          "gasPrice": "0x3b9aca00",
+          "gas": "0x5208"
+        },
+        "history": [
+          {
+            "id": 3387511061307741,
+            "time": 1528133318440,
+            "status": "unapproved",
+            "metamaskNetworkId": "4",
+            "loadingDefaults": true,
+            "txParams": {
+              "from": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62",
+              "to": "0x3b222de3aaba8ec9771ca9e9af5d8ed757fb7f62"
+            }
+          },
+          [
+            {
+              "op": "add",
+              "path": "/txParams/value",
+              "value": "0x0",
+              "timestamp": 1528133319641
+            },
+            {
+              "op": "add",
+              "path": "/txParams/gasPrice",
+              "value": "0x3b9aca00"
+            },
+            {
+              "op": "add",
+              "path": "/txParams/gas",
+              "value": "0x5208"
+            },
+            {
+              "op": "replace",
+              "path": "/loadingDefaults",
+              "value": false
+            },
+            {
+              "op": "add",
+              "path": "/gasPriceSpecified",
+              "value": false
+            },
+            {
+              "op": "add",
+              "path": "/gasLimitSpecified",
+              "value": false
+            },
+            {
+              "op": "add",
+              "path": "/simpleSend",
+              "value": true
+            },
+            {
+              "op": "add",
+              "path": "/estimatedGas",
+              "value": "0x5208"
+            }
+          ],
+          [
+            {
+              "op": "add",
+              "path": "/origin",
+              "value": "tmashuang.github.io",
+              "note": "#newUnapprovedTransaction - adding the origin",
+              "timestamp": 1528133319642
+            }
+          ],
+          [
+            {
+              "op": "replace",
+              "path": "/status",
+              "value": "rejected",
+              "note": "txStateManager: setting status to rejected",
+              "timestamp": 1528133320924
+            }
+          ]
+        ],
+        "gasPriceSpecified": false,
+        "gasLimitSpecified": false,
+        "simpleSend": true,
+        "estimatedGas": "0x5208",
+        "origin": "tmashuang.github.io"
+      }
+    ]
+  },
+  "appState": {
+    "gasIsLoading": false,
+    "currentView": {
+      "name": "accountDetail",
+      "detailView": null,
+      "context": "0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc"
+    }
+  }
+}
+\ No newline at end of file
diff --git a/test/e2e/beta/drizzle.spec.js b/test/e2e/beta/drizzle.spec.js
new file mode 100644
index 000000000..ff4b4b74d
--- /dev/null
+++ b/test/e2e/beta/drizzle.spec.js
@@ -0,0 +1,286 @@
+const path = require('path')
+const assert = require('assert')
+const webdriver = require('selenium-webdriver')
+const { By, until } = webdriver
+const {
+  delay,
+  buildChromeWebDriver,
+  buildFirefoxWebdriver,
+  installWebExt,
+  getExtensionIdChrome,
+  getExtensionIdFirefox,
+} = require('../func')
+const {
+  checkBrowserForConsoleErrors,
+  closeAllWindowHandlesExcept,
+  findElement,
+  findElements,
+  loadExtension,
+  openNewPage,
+  verboseReportOnFailure,
+  waitUntilXWindowHandles,
+} = require('./helpers')
+
+describe('MetaMask', function () {
+  let extensionId
+  let driver
+
+  const tinyDelayMs = 200
+  const regularDelayMs = tinyDelayMs * 2
+  const largeDelayMs = regularDelayMs * 2
+
+  this.timeout(0)
+  this.bail(true)
+
+  before(async function () {
+    switch (process.env.SELENIUM_BROWSER) {
+      case 'chrome': {
+        const extPath = path.resolve('dist/chrome')
+        driver = buildChromeWebDriver(extPath)
+        extensionId = await getExtensionIdChrome(driver)
+        await driver.get(`chrome-extension://${extensionId}/popup.html`)
+        break
+      }
+      case '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`)
+      }
+    }
+  })
+
+  afterEach(async function () {
+    if (process.env.SELENIUM_BROWSER === 'chrome') {
+      const errors = await checkBrowserForConsoleErrors(driver)
+      if (errors.length) {
+        const errorReports = errors.map(err => err.message)
+        const errorMessage = `Errors found in browser console:\n${errorReports.join('\n')}`
+        console.error(new Error(errorMessage))
+      }
+    }
+    if (this.currentTest.state === 'failed') {
+      await verboseReportOnFailure(driver, this.currentTest)
+    }
+  })
+
+  after(async function () {
+    await driver.quit()
+  })
+
+
+  describe('New UI setup', async function () {
+    it('switches to first tab', async function () {
+      await delay(tinyDelayMs)
+      const [firstTab] = await driver.getAllWindowHandles()
+      await driver.switchTo().window(firstTab)
+      await delay(regularDelayMs)
+    })
+
+    it('selects the new UI option', async () => {
+      try {
+        const overlay = await findElement(driver, By.css('.full-flex-height'))
+        await driver.wait(until.stalenessOf(overlay))
+      } catch (e) {}
+
+      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)
+
+      // Close all other tabs
+      const [tab0, tab1, tab2] = await driver.getAllWindowHandles()
+      await driver.switchTo().window(tab0)
+      await delay(tinyDelayMs)
+
+      let selectedUrl = await driver.getCurrentUrl()
+      await delay(tinyDelayMs)
+      if (tab0 && selectedUrl.match(/popup.html/)) {
+        await closeAllWindowHandlesExcept(driver, tab0)
+      } else if (tab1) {
+        await driver.switchTo().window(tab1)
+        selectedUrl = await driver.getCurrentUrl()
+        await delay(tinyDelayMs)
+        if (selectedUrl.match(/popup.html/)) {
+          await closeAllWindowHandlesExcept(driver, tab1)
+        } else if (tab2) {
+          await driver.switchTo().window(tab2)
+          selectedUrl = await driver.getCurrentUrl()
+          selectedUrl.match(/popup.html/) && await closeAllWindowHandlesExcept(driver, tab2)
+        }
+      } else {
+        throw new Error('popup.html not found')
+      }
+      await delay(regularDelayMs)
+      const [appTab] = await driver.getAllWindowHandles()
+      await driver.switchTo().window(appTab)
+      await delay(tinyDelayMs)
+
+      await loadExtension(driver, extensionId)
+      await delay(regularDelayMs)
+
+      const continueBtn = await findElement(driver, By.css('.welcome-screen__button'))
+      await continueBtn.click()
+      await delay(regularDelayMs)
+    })
+  })
+
+  describe('Going through the first time flow', () => {
+    it('accepts a secure password', async () => {
+      const passwordBox = await findElement(driver, By.css('.create-password #create-password'))
+      const passwordBoxConfirm = await findElement(driver, By.css('.create-password #confirm-password'))
+      const button = await findElement(driver, By.css('.create-password button'))
+
+      await passwordBox.sendKeys('correct horse battery staple')
+      await passwordBoxConfirm.sendKeys('correct horse battery staple')
+      await button.click()
+      await delay(regularDelayMs)
+    })
+
+    it('clicks through the unique image screen', async () => {
+      const nextScreen = await findElement(driver, By.css('.unique-image button'))
+      await nextScreen.click()
+      await delay(regularDelayMs)
+    })
+
+    it('clicks through the ToS', async () => {
+      // terms of use
+      const canClickThrough = await driver.findElement(By.css('.tou button')).isEnabled()
+      assert.equal(canClickThrough, false, 'disabled continue button')
+      const bottomOfTos = await findElement(driver, By.linkText('Attributions'))
+      await driver.executeScript('arguments[0].scrollIntoView(true)', bottomOfTos)
+      await delay(regularDelayMs)
+      const acceptTos = await findElement(driver, By.css('.tou button'))
+      driver.wait(until.elementIsEnabled(acceptTos))
+      await acceptTos.click()
+      await delay(regularDelayMs)
+    })
+
+    it('clicks through the privacy notice', async () => {
+      // privacy notice
+      const nextScreen = await findElement(driver, By.css('.tou button'))
+      await nextScreen.click()
+      await delay(regularDelayMs)
+    })
+
+    it('clicks through the phishing notice', async () => {
+      // phishing notice
+      const noticeElement = await driver.findElement(By.css('.markdown'))
+      await driver.executeScript('arguments[0].scrollTop = arguments[0].scrollHeight', noticeElement)
+      await delay(regularDelayMs)
+      const nextScreen = await findElement(driver, By.css('.tou button'))
+      await nextScreen.click()
+      await delay(regularDelayMs)
+    })
+
+    let seedPhrase
+
+    it('reveals the seed phrase', async () => {
+      const byRevealButton = By.css('.backup-phrase__secret-blocker .backup-phrase__reveal-button')
+      await driver.wait(until.elementLocated(byRevealButton, 10000))
+      const revealSeedPhraseButton = await findElement(driver, byRevealButton, 10000)
+      await revealSeedPhraseButton.click()
+      await delay(regularDelayMs)
+
+      seedPhrase = await driver.findElement(By.css('.backup-phrase__secret-words')).getText()
+      assert.equal(seedPhrase.split(' ').length, 12)
+      await delay(regularDelayMs)
+
+      const nextScreen = await findElement(driver, By.css('.backup-phrase button'))
+      await nextScreen.click()
+      await delay(regularDelayMs)
+    })
+
+    async function clickWordAndWait (word) {
+      const xpathClass = 'backup-phrase__confirm-seed-option backup-phrase__confirm-seed-option--unselected'
+      const xpath = `//button[@class='${xpathClass}' and contains(text(), '${word}')]`
+      const word0 = await findElement(driver, By.xpath(xpath), 10000)
+
+      await word0.click()
+      await delay(tinyDelayMs)
+    }
+
+    async function retypeSeedPhrase (words, wasReloaded, count = 0) {
+      try {
+        if (wasReloaded) {
+          const byRevealButton = By.css('.backup-phrase__secret-blocker .backup-phrase__reveal-button')
+          await driver.wait(until.elementLocated(byRevealButton, 10000))
+          const revealSeedPhraseButton = await findElement(driver, byRevealButton, 10000)
+          await revealSeedPhraseButton.click()
+          await delay(regularDelayMs)
+
+          const nextScreen = await findElement(driver, By.css('.backup-phrase button'))
+          await nextScreen.click()
+          await delay(regularDelayMs)
+        }
+
+        for (let i = 0; i < 12; i++) {
+          await clickWordAndWait(words[i])
+        }
+      } catch (e) {
+        if (count > 2) {
+          throw e
+        } else {
+          await loadExtension(driver, extensionId)
+          await retypeSeedPhrase(words, true, count + 1)
+        }
+      }
+    }
+
+    it('can retype the seed phrase', async () => {
+      const words = seedPhrase.split(' ')
+
+      await retypeSeedPhrase(words)
+
+      const confirm = await findElement(driver, By.xpath(`//button[contains(text(), 'Confirm')]`))
+      await confirm.click()
+      await delay(regularDelayMs)
+    })
+
+    it('clicks through the deposit modal', async () => {
+      const byBuyModal = By.css('span .modal')
+      const buyModal = await driver.wait(until.elementLocated(byBuyModal))
+      const closeModal = await findElement(driver, By.css('.page-container__header-close'))
+      await closeModal.click()
+      await driver.wait(until.stalenessOf(buyModal))
+      await delay(regularDelayMs)
+    })
+
+    it('switches to localhost', async () => {
+      const networkDropdown = await findElement(driver, By.css('.network-name'))
+      await networkDropdown.click()
+      await delay(regularDelayMs)
+
+      const [localhost] = await findElements(driver, By.xpath(`//span[contains(text(), 'Localhost')]`))
+      await localhost.click()
+      await delay(largeDelayMs * 2)
+    })
+  })
+
+  describe('Drizzle', () => {
+    it('should be able to detect our eth address', async () => {
+      await openNewPage(driver, 'http://127.0.0.1:3000/')
+      await delay(regularDelayMs)
+
+      await waitUntilXWindowHandles(driver, 2)
+      const windowHandles = await driver.getAllWindowHandles()
+      const dapp = windowHandles[1]
+
+      await driver.switchTo().window(dapp)
+      await delay(regularDelayMs)
+
+
+      const addressElement = await findElement(driver, By.css(`.pure-u-1-1 h4`))
+      const addressText = await addressElement.getText()
+      assert(addressText.match(/^0x[a-fA-F0-9]{40}$/))
+    })
+  })
+})
diff --git a/test/e2e/beta/from-import-beta-ui.spec.js b/test/e2e/beta/from-import-beta-ui.spec.js
index 5ee8f0268..bf0733467 100644
--- a/test/e2e/beta/from-import-beta-ui.spec.js
+++ b/test/e2e/beta/from-import-beta-ui.spec.js
@@ -317,7 +317,7 @@ describe('Using MetaMask with an existing account', function () {
       const transactions = await findElements(driver, By.css('.transaction-list-item'))
       assert.equal(transactions.length, 1)
 
-      const txValues = await findElements(driver, By.css('.transaction-list-item__amount--secondary'))
+      const txValues = await findElements(driver, By.css('.transaction-list-item__amount--primary'))
       assert.equal(txValues.length, 1)
       assert.equal(await txValues[0].getText(), '-1 ETH')
     })
diff --git a/test/e2e/beta/helpers.js b/test/e2e/beta/helpers.js
index 73289e526..4055d8155 100644
--- a/test/e2e/beta/helpers.js
+++ b/test/e2e/beta/helpers.js
@@ -126,10 +126,7 @@ async function assertElementNotPresent (webdriver, driver, by) {
   try {
     dataTab = await findElement(driver, by, 4000)
   } catch (err) {
-    console.log(err)
     assert(err instanceof webdriver.error.NoSuchElementError || err instanceof webdriver.error.TimeoutError)
   }
-  if (dataTab) {
-    assert(false, 'Data tab should not be present')
-  }
+  assert.ok(!dataTab, 'Found element that should not be present')
 }
diff --git a/test/e2e/beta/metamask-beta-ui.spec.js b/test/e2e/beta/metamask-beta-ui.spec.js
index c9f759780..8d1ecac0d 100644
--- a/test/e2e/beta/metamask-beta-ui.spec.js
+++ b/test/e2e/beta/metamask-beta-ui.spec.js
@@ -271,6 +271,17 @@ describe('MetaMask', function () {
       await driver.wait(until.stalenessOf(accountModal))
       await delay(regularDelayMs)
     })
+    it('show account details dropdown menu', async () => {
+
+      const {width, height} = await driver.manage().window().getSize()
+      driver.manage().window().setSize(320, 480)
+      await driver.findElement(By.css('div.menu-bar__open-in-browser')).click()
+      const options = await driver.findElements(By.css('div.menu.account-details-dropdown div.menu__item'))
+      assert.equal(options.length, 3) // HD Wallet type does not have to show the Remove Account option
+      await delay(regularDelayMs)
+      driver.manage().window().setSize(width, height)
+
+    })
   })
 
   describe('Log out an log back in', () => {
@@ -408,7 +419,7 @@ describe('MetaMask', function () {
       assert.equal(transactions.length, 1)
 
       if (process.env.SELENIUM_BROWSER !== 'firefox') {
-        const txValues = await findElement(driver, By.css('.transaction-list-item__amount--secondary'))
+        const txValues = await findElement(driver, By.css('.transaction-list-item__amount--primary'))
         await driver.wait(until.elementTextMatches(txValues, /-1\sETH/), 10000)
       }
     })
@@ -450,7 +461,7 @@ describe('MetaMask', function () {
       const transactions = await findElements(driver, By.css('.transaction-list-item'))
       assert.equal(transactions.length, 2)
 
-      const txValues = await findElement(driver, By.css('.transaction-list-item__amount--secondary'))
+      const txValues = await findElement(driver, By.css('.transaction-list-item__amount--primary'))
       await driver.wait(until.elementTextMatches(txValues, /-3\sETH/), 10000)
     })
   })
@@ -528,7 +539,7 @@ describe('MetaMask', function () {
       await delay(largeDelayMs)
 
       await findElements(driver, By.css('.transaction-list-item'))
-      const [txListValue] = await findElements(driver, By.css('.transaction-list-item__amount--secondary'))
+      const [txListValue] = await findElements(driver, By.css('.transaction-list-item__amount--primary'))
       await driver.wait(until.elementTextMatches(txListValue, /-4\sETH/), 10000)
       await txListValue.click()
       await delay(regularDelayMs)
@@ -562,7 +573,7 @@ describe('MetaMask', function () {
         return confirmedTxes.length === 4
       }, 10000)
 
-      const txValues = await findElements(driver, By.css('.transaction-list-item__amount--secondary'))
+      const txValues = await findElements(driver, By.css('.transaction-list-item__amount--primary'))
       await driver.wait(until.elementTextMatches(txValues[0], /-4\sETH/), 10000)
 
       // const txAccounts = await findElements(driver, By.css('.tx-list-account'))
@@ -594,7 +605,7 @@ describe('MetaMask', function () {
         return confirmedTxes.length === 5
       }, 10000)
 
-      const txValues = await findElement(driver, By.css('.transaction-list-item__amount--secondary'))
+      const txValues = await findElement(driver, By.css('.transaction-list-item__amount--primary'))
       await driver.wait(until.elementTextMatches(txValues, /-0\sETH/), 10000)
 
       await closeAllWindowHandlesExcept(driver, [extension, dapp])
@@ -1030,7 +1041,7 @@ describe('MetaMask', function () {
     ]
 
     customRpcUrls.forEach(customRpcUrl => {
-      it('creates custom RPC: ' + customRpcUrl, async () => {
+      it(`creates custom RPC: ${customRpcUrl}`, async () => {
         const networkDropdown = await findElement(driver, By.css('.network-name'))
         await networkDropdown.click()
         await delay(regularDelayMs)
@@ -1043,7 +1054,7 @@ describe('MetaMask', function () {
         await customRpcInput.clear()
         await customRpcInput.sendKeys(customRpcUrl)
 
-        const customRpcSave = await findElement(driver, By.css('.settings__rpc-save-button'))
+        const customRpcSave = await findElement(driver, By.css('.settings-tab__rpc-save-button'))
         await customRpcSave.click()
         await delay(largeDelayMs * 2)
       })
@@ -1059,25 +1070,15 @@ describe('MetaMask', function () {
       await delay(largeDelayMs * 2)
     })
 
-    it('finds 3 recent RPCs in history', async () => {
+    it('finds all recent RPCs in history', async () => {
       const networkDropdown = await findElement(driver, By.css('.network-name'))
       await networkDropdown.click()
       await delay(regularDelayMs)
 
-      // oldest selected RPC is not found
-      await assertElementNotPresent(webdriver, driver, By.xpath(`//span[contains(text(), '${customRpcUrls[0]}')]`))
-
       // only recent 3 are found and in correct order (most recent at the top)
       const customRpcs = await findElements(driver, By.xpath(`//span[contains(text(), 'https://mainnet.infura.io/')]`))
 
-      assert.equal(customRpcs.length, 3)
-
-      for (let i = 0; i < customRpcs.length; i++) {
-        const linkText = await customRpcs[i].getText()
-        const rpcUrl = customRpcUrls[customRpcUrls.length - i - 1]
-
-        assert.notEqual(linkText.indexOf(rpcUrl), -1)
-      }
+      assert.equal(customRpcs.length, customRpcUrls.length)
     })
   })
 })
diff --git a/test/e2e/beta/run-all.sh b/test/e2e/beta/run-all.sh
index cde46a2d3..c51f19fdf 100755
--- a/test/e2e/beta/run-all.sh
+++ b/test/e2e/beta/run-all.sh
@@ -6,5 +6,5 @@ set -o pipefail
 
 export PATH="$PATH:./node_modules/.bin"
 
-shell-parallel -s 'npm run ganache:start -- -b 2' -x 'sleep 5 && static-server test/e2e/beta/contract-test/ --port 8080' -x 'sleep 5 && mocha test/e2e/beta/metamask-beta-ui.spec'
-shell-parallel -s 'npm run ganache:start -- -d -b 2'  -x 'sleep 5 && static-server test/e2e/beta/contract-test/ --port 8080' -x 'sleep 5 && mocha test/e2e/beta/from-import-beta-ui.spec'
+shell-parallel -s 'npm run ganache:start -- -b 2' -x 'sleep 5 && static-server test/e2e/beta/contract-test --port 8080' -x 'sleep 5 && mocha test/e2e/beta/metamask-beta-ui.spec'
+shell-parallel -s 'npm run ganache:start -- -d -b 2'  -x 'sleep 5 && mocha test/e2e/beta/from-import-beta-ui.spec'
diff --git a/test/e2e/beta/run-drizzle.sh b/test/e2e/beta/run-drizzle.sh
new file mode 100755
index 000000000..7bfffd7e6
--- /dev/null
+++ b/test/e2e/beta/run-drizzle.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+set -e
+set -u
+set -o pipefail
+
+export PATH="$PATH:./node_modules/.bin"
+
+npm run ganache:start -- -b 2 >> /dev/null 2>&1 &
+sleep 5
+cd test/e2e/beta/
+rm -rf drizzle-test
+mkdir drizzle-test && cd drizzle-test
+npm install truffle
+truffle unbox drizzle
+echo "Deploying contracts for Drizzle test..."
+truffle compile && truffle migrate
+BROWSER=none npm start >> /dev/null 2>&1 &
+cd ../../../../
+mocha test/e2e/beta/drizzle.spec
diff --git a/test/e2e/metamask.spec.js b/test/e2e/metamask.spec.js
index 38246a044..13af6cb22 100644
--- a/test/e2e/metamask.spec.js
+++ b/test/e2e/metamask.spec.js
@@ -201,17 +201,17 @@ describe('Metamask popup page', function () {
     })
 
     it('balance renders', async function () {
-      await delay(200)
+      await delay(500)
       const balance = await driver.findElement(By.css('#app-content > div > div.app-primary.from-right > div > div > div.flex-row > div.ether-balance.ether-balance-amount > div > div > div:nth-child(1) > div:nth-child(1)'))
       assert.equal(await balance.getText(), '100.000')
       await delay(200)
     })
 
     it('sends transaction', async function () {
-     const sendButton = await driver.findElement(By.css('#app-content > div > div.app-primary.from-right > div > div > div.flex-row > button:nth-child(4)'))
-     assert.equal(await sendButton.getText(), 'SEND')
-     await sendButton.click()
-     await delay(200)
+      const sendButton = await driver.findElement(By.css('#app-content > div > div.app-primary.from-right > div > div > div.flex-row > button:nth-child(4)'))
+      assert.equal(await sendButton.getText(), 'SEND')
+      await sendButton.click()
+      await delay(200)
     })
 
     it('adds recipient address and amount', async function () {
diff --git a/test/integration/lib/confirm-sig-requests.js b/test/integration/lib/confirm-sig-requests.js
index 3539e97be..9c2ad7cf4 100644
--- a/test/integration/lib/confirm-sig-requests.js
+++ b/test/integration/lib/confirm-sig-requests.js
@@ -19,7 +19,7 @@ async function runConfirmSigRequestsTest (assert, done) {
   selectState.val('confirm sig requests')
   reactTriggerChange(selectState[0])
 
-  const pendingRequestItem = $.find('.transaction-list-item')
+  const pendingRequestItem = $.find('.transaction-list-item .transaction-list-item__grid')
 
   if (pendingRequestItem[0]) {
     pendingRequestItem[0].click()
diff --git a/test/integration/lib/send-new-ui.js b/test/integration/lib/send-new-ui.js
index 7f3c114e4..ac1cc2e14 100644
--- a/test/integration/lib/send-new-ui.js
+++ b/test/integration/lib/send-new-ui.js
@@ -94,7 +94,7 @@ async function runSendFlowTest (assert, done) {
   sendToDropdownList.children()[2].click()
 
   const sendToAccountAddress = sendToFieldInput.val()
-  assert.equal(sendToAccountAddress, '0x2f8d4a878cfa04a6e60d46362f5644deab66572d', 'send to dropdown selects the correct address')
+  assert.equal(sendToAccountAddress, '0x2f8D4a878cFA04A6E60D46362f5644DeAb66572D', 'send to dropdown selects the correct address')
 
   const sendAmountField = await queryAsync($, '.send-v2__form-row:eq(2)')
   sendAmountField.find('.currency-display')[0].click()
diff --git a/test/integration/lib/tx-list-items.js b/test/integration/lib/tx-list-items.js
index 7572d1629..ed4f82074 100644
--- a/test/integration/lib/tx-list-items.js
+++ b/test/integration/lib/tx-list-items.js
@@ -32,15 +32,17 @@ async function runTxListItemsTest (assert, done) {
   const txListItems = await queryAsync($, '.transaction-list-item')
   assert.equal(txListItems.length, 8, 'all tx list items are rendered')
 
-  const retryTx = txListItems[1]
-  const retryTxLink = await findAsync($(retryTx), '.transaction-list-item__retry')
-  assert.equal(retryTxLink[0].textContent, 'Taking too long? Increase the gas price on your transaction', 'retryTx has expected link')
+  const retryTxGrid = await findAsync($(txListItems[2]), '.transaction-list-item__grid')
+  retryTxGrid[0].click()
+  const retryTxDetails = await findAsync($, '.transaction-list-item-details')
+  const headerButtons = await findAsync($(retryTxDetails[0]), '.transaction-list-item-details__header-button')
+  assert.equal(headerButtons[0].textContent, 'speed up')
 
   const approvedTx = txListItems[2]
   const approvedTxRenderedStatus = await findAsync($(approvedTx), '.transaction-list-item__status')
   assert.equal(approvedTxRenderedStatus[0].textContent, 'pending', 'approvedTx has correct label')
 
-  const unapprovedMsg = txListItems[3]
+  const unapprovedMsg = txListItems[0]
   const unapprovedMsgDescription = await findAsync($(unapprovedMsg), '.transaction-list-item__action')
   assert.equal(unapprovedMsgDescription[0].textContent, 'Signature Request', 'unapprovedMsg has correct description')
 
diff --git a/test/lib/mock-config-manager.js b/test/lib/mock-config-manager.js
deleted file mode 100644
index 0cc6953bb..000000000
--- a/test/lib/mock-config-manager.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const ObservableStore = require('obs-store')
-const clone = require('clone')
-const ConfigManager = require('../../app/scripts/lib/config-manager')
-const firstTimeState = require('../../app/scripts/first-time-state')
-
-module.exports = function () {
-  const store = new ObservableStore(clone(firstTimeState))
-  return new ConfigManager({ store })
-}
diff --git a/test/lib/mock-encryptor.js b/test/lib/mock-encryptor.js
index 48aa9e52c..852c536c2 100644
--- a/test/lib/mock-encryptor.js
+++ b/test/lib/mock-encryptor.js
@@ -1,5 +1,5 @@
 var mockHex = '0xabcdef0123456789'
-var mockKey = new Buffer(32)
+var mockKey = Buffer.alloc(32)
 let cacheVal
 
 module.exports = {
diff --git a/test/lib/render-helpers.js b/test/lib/render-helpers.js
new file mode 100644
index 000000000..81f0e27aa
--- /dev/null
+++ b/test/lib/render-helpers.js
@@ -0,0 +1,42 @@
+const { shallow, mount } = require('enzyme')
+import { BrowserRouter } from 'react-router-dom'
+import { shape } from 'prop-types'
+
+module.exports = {
+  shallowWithStore,
+  mountWithStore,
+  mountWithRouter,
+}
+
+function shallowWithStore (component, store) {
+  const context = {
+    store,
+  }
+  return shallow(component, {context})
+}
+
+function mountWithStore (component, store) {
+  const context = {
+    store,
+  }
+  return mount(component, {context})
+}
+
+function mountWithRouter (node) {
+
+  // Instantiate router context
+  const router = {
+    history: new BrowserRouter().history,
+    route: {
+      location: {},
+      match: {},
+    },
+  }
+
+  const createContext = () => ({
+    context: { router, t: () => {} },
+    childContextTypes: { router: shape({}), t: () => {} },
+  })
+
+  return mount(node, createContext())
+}
diff --git a/test/lib/shallow-with-store.js b/test/lib/shallow-with-store.js
deleted file mode 100644
index 9df10a3c5..000000000
--- a/test/lib/shallow-with-store.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const { shallow, mount } = require('enzyme')
-
-module.exports = {
-  shallowWithStore,
-  mountWithStore,
-}
-
-function shallowWithStore (component, store) {
-  const context = {
-    store,
-  }
-  return shallow(component, {context})
-}
-
-function mountWithStore (component, store) {
-  const context = {
-    store,
-  }
-  return mount(component, {context})
-}
diff --git a/test/unit/app/cleanErrorStack.spec.js b/test/unit/app/cleanErrorStack.spec.js
new file mode 100644
index 000000000..7a1ab1ed8
--- /dev/null
+++ b/test/unit/app/cleanErrorStack.spec.js
@@ -0,0 +1,33 @@
+const assert = require('assert')
+const cleanErrorStack = require('../../../app/scripts/lib/cleanErrorStack')
+
+describe('Clean Error Stack', () => {
+
+  const testMessage = 'Test Message'
+  const testError = new Error(testMessage)
+  const undefinedErrorName = new Error(testMessage)
+  const blankErrorName = new Error(testMessage)
+  const blankMsgError = new Error()
+
+  beforeEach(() => {
+    undefinedErrorName.name = undefined
+    blankErrorName.name = ''
+  })
+
+  it('tests error with message', () => {
+    assert.equal(cleanErrorStack(testError), 'Error: Test Message')
+  })
+
+  it('tests error with undefined name', () => {
+    assert.equal(cleanErrorStack(undefinedErrorName).toString(), 'Error: Test Message')
+  })
+
+  it('tests error with blank name', () => {
+    assert.equal(cleanErrorStack(blankErrorName).toString(), 'Test Message')
+  })
+
+  it('tests error with blank message', () => {
+    assert.equal(cleanErrorStack(blankMsgError), 'Error')
+  })
+
+})
diff --git a/test/unit/app/controllers/blacklist-controller-test.js b/test/unit/app/controllers/blacklist-controller-test.js
index 085641777..7a14c02cc 100644
--- a/test/unit/app/controllers/blacklist-controller-test.js
+++ b/test/unit/app/controllers/blacklist-controller-test.js
@@ -8,6 +8,16 @@ describe('blacklist controller', function () {
     blacklistController = new BlacklistController()
   })
 
+  describe('whitelistDomain', function () {
+    it('should add hostname to the runtime whitelist', function () {
+      blacklistController.whitelistDomain('foo.com')
+      assert.deepEqual(blacklistController.store.getState().whitelist, ['foo.com'])
+
+      blacklistController.whitelistDomain('bar.com')
+      assert.deepEqual(blacklistController.store.getState().whitelist, ['bar.com', 'foo.com'])
+    })
+  })
+
   describe('checkForPhishing', function () {
     it('should not flag whitelisted values', function () {
       const result = blacklistController.checkForPhishing('www.metamask.io')
@@ -37,5 +47,10 @@ describe('blacklist controller', function () {
       const result = blacklistController.checkForPhishing('zero-faucet.metamask.io')
       assert.equal(result, false)
     })
+    it('should not flag whitelisted domain', function () {
+      blacklistController.whitelistDomain('metamask.com')
+      const result = blacklistController.checkForPhishing('metamask.com')
+      assert.equal(result, false)
+    })
   })
 })
diff --git a/test/unit/app/controllers/detect-tokens-test.js b/test/unit/app/controllers/detect-tokens-test.js
index e5539256e..2acc53e92 100644
--- a/test/unit/app/controllers/detect-tokens-test.js
+++ b/test/unit/app/controllers/detect-tokens-test.js
@@ -138,4 +138,4 @@ describe('DetectTokensController', () => {
     clock.tick(180000)
     sandbox.assert.notCalled(stub)
   })
-})
-\ No newline at end of file
+})
diff --git a/test/unit/app/controllers/metamask-controller-test.js b/test/unit/app/controllers/metamask-controller-test.js
index 85c78fe1e..17be2c028 100644
--- a/test/unit/app/controllers/metamask-controller-test.js
+++ b/test/unit/app/controllers/metamask-controller-test.js
@@ -116,7 +116,7 @@ describe('MetaMaskController', function () {
       }
 
       const gasPrice = metamaskController.getGasPrice()
-      assert.equal(gasPrice, '0x3b9aca00', 'accurately estimates 50th percentile accepted gas price')
+      assert.equal(gasPrice, '0x174876e800', 'accurately estimates 65th percentile accepted gas price')
 
       metamaskController.recentBlocksController = realRecentBlocksController
     })
@@ -584,22 +584,18 @@ describe('MetaMaskController', function () {
   })
 
   describe('#clearSeedWordCache', function () {
+    it('should set seed words to null', function (done) {
+      sandbox.stub(metamaskController.preferencesController, 'setSeedWords')
+      metamaskController.clearSeedWordCache((err) => {
+        if (err) {
+          done(err)
+        }
 
-    it('should have set seed words', function () {
-      metamaskController.configManager.setSeedWords('test words')
-      const getConfigSeed = metamaskController.configManager.getSeedWords()
-      assert.equal(getConfigSeed, 'test words')
-    })
-
-    it('should clear config seed phrase', function () {
-      metamaskController.configManager.setSeedWords('test words')
-      metamaskController.clearSeedWordCache((err, result) => {
-        if (err) console.log(err)
+        assert.ok(metamaskController.preferencesController.setSeedWords.calledOnce)
+        assert.deepEqual(metamaskController.preferencesController.setSeedWords.args, [[null]])
+        done()
       })
-      const getConfigSeed = metamaskController.configManager.getSeedWords()
-      assert.equal(getConfigSeed, null)
     })
-
   })
 
   describe('#setCurrentLocale', function () {
@@ -793,24 +789,24 @@ describe('MetaMaskController', function () {
   describe('#markAccountsFound', function () {
     it('adds lost accounts to config manager data', function () {
       metamaskController.markAccountsFound(noop)
-      const configManagerData = metamaskController.configManager.getData()
-      assert.deepEqual(configManagerData.lostAccounts, [])
+      const state = metamaskController.getState()
+      assert.deepEqual(state.lostAccounts, [])
     })
   })
 
   describe('#markPasswordForgotten', function () {
     it('adds and sets forgottenPassword to config data to true', function () {
       metamaskController.markPasswordForgotten(noop)
-      const configManagerData = metamaskController.configManager.getData()
-      assert.equal(configManagerData.forgottenPassword, true)
+      const state = metamaskController.getState()
+      assert.equal(state.forgottenPassword, true)
     })
   })
 
   describe('#unMarkPasswordForgotten', function () {
     it('adds and sets forgottenPassword to config data to false', function () {
       metamaskController.unMarkPasswordForgotten(noop)
-      const configManagerData = metamaskController.configManager.getData()
-      assert.equal(configManagerData.forgottenPassword, false)
+      const state = metamaskController.getState()
+      assert.equal(state.forgottenPassword, false)
     })
   })
 
diff --git a/test/unit/app/controllers/notice-controller-test.js b/test/unit/app/controllers/notice-controller-test.js
index b3ae75080..834c88f7b 100644
--- a/test/unit/app/controllers/notice-controller-test.js
+++ b/test/unit/app/controllers/notice-controller-test.js
@@ -1,16 +1,11 @@
 const assert = require('assert')
-const configManagerGen = require('../../../lib/mock-config-manager')
 const NoticeController = require('../../../../app/scripts/notice-controller')
 
 describe('notice-controller', function () {
   var noticeController
 
   beforeEach(function () {
-    // simple localStorage polyfill
-    const configManager = configManagerGen()
-    noticeController = new NoticeController({
-      configManager: configManager,
-    })
+    noticeController = new NoticeController()
   })
 
   describe('notices', function () {
diff --git a/test/unit/app/controllers/preferences-controller-test.js b/test/unit/app/controllers/preferences-controller-test.js
index 2c261be90..b5ccf3fb5 100644
--- a/test/unit/app/controllers/preferences-controller-test.js
+++ b/test/unit/app/controllers/preferences-controller-test.js
@@ -449,5 +449,35 @@ describe('preferences controller', function () {
       assert.ok(assetImages[address], `set image correctly`)
     })
   })
+
+  describe('setPasswordForgotten', function () {
+    it('should default to false', function () {
+      const state = preferencesController.store.getState()
+      assert.equal(state.forgottenPassword, false)
+    })
+
+    it('should set the forgottenPassword property in state', function () {
+      assert.equal(preferencesController.store.getState().forgottenPassword, false)
+
+      preferencesController.setPasswordForgotten(true)
+
+      assert.equal(preferencesController.store.getState().forgottenPassword, true)
+    })
+  })
+
+  describe('setSeedWords', function () {
+    it('should default to null', function () {
+      const state = preferencesController.store.getState()
+      assert.equal(state.seedWords, null)
+    })
+
+    it('should set the seedWords property in state', function () {
+      assert.equal(preferencesController.store.getState().seedWords, null)
+
+      preferencesController.setSeedWords('foo bar baz')
+
+      assert.equal(preferencesController.store.getState().seedWords, 'foo bar baz')
+    })
+  })
 })
 
diff --git a/test/unit/app/controllers/transactions/tx-controller-test.js b/test/unit/app/controllers/transactions/tx-controller-test.js
index 5ac813b49..ea58aa560 100644
--- a/test/unit/app/controllers/transactions/tx-controller-test.js
+++ b/test/unit/app/controllers/transactions/tx-controller-test.js
@@ -158,9 +158,19 @@ describe('Transaction Controller', function () {
   })
 
   describe('#addUnapprovedTransaction', function () {
+    const selectedAddress = '0x1678a085c290ebd122dc42cba69373b5953b831d'
+
+    let getSelectedAddress
+    beforeEach(function () {
+      getSelectedAddress = sinon.stub(txController, 'getSelectedAddress').returns(selectedAddress)
+    })
+
+    afterEach(function () {
+      getSelectedAddress.restore()
+    })
 
     it('should add an unapproved transaction and return a valid txMeta', function (done) {
-      txController.addUnapprovedTransaction({ from: '0x1678a085c290ebd122dc42cba69373b5953b831d' })
+      txController.addUnapprovedTransaction({ from: selectedAddress })
       .then((txMeta) => {
         assert(('id' in txMeta), 'should have a id')
         assert(('time' in txMeta), 'should have a time stamp')
@@ -180,25 +190,37 @@ describe('Transaction Controller', function () {
         assert(txMetaFromEmit, 'txMeta is falsey')
         done()
       })
-      txController.addUnapprovedTransaction({ from: '0x1678a085c290ebd122dc42cba69373b5953b831d' })
+      txController.addUnapprovedTransaction({ from: selectedAddress })
       .catch(done)
     })
 
     it('should fail if recipient is public', function (done) {
       txController.networkStore = new ObservableStore(1)
-      txController.addUnapprovedTransaction({ from: '0x1678a085c290ebd122dc42cba69373b5953b831d', to: '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' })
+      txController.addUnapprovedTransaction({ from: selectedAddress, to: '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' })
       .catch((err) => {
         if (err.message === 'Recipient is a public account') done()
         else done(err)
       })
     })
 
+    it('should fail if the from address isn\'t the selected address', function (done) {
+      txController.addUnapprovedTransaction({from: '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2'})
+        .then(function () {
+          assert.fail('transaction should not have been added')
+          done()
+        })
+        .catch(function () {
+          assert.ok('pass')
+          done()
+        })
+    })
+
     it('should not fail if recipient is public but not on mainnet', function (done) {
       txController.once('newUnapprovedTx', (txMetaFromEmit) => {
         assert(txMetaFromEmit, 'txMeta is falsey')
         done()
       })
-      txController.addUnapprovedTransaction({ from: '0x1678a085c290ebd122dc42cba69373b5953b831d', to: '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' })
+      txController.addUnapprovedTransaction({ from: selectedAddress, to: '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' })
       .catch(done)
     })
   })
diff --git a/test/unit/components/balance-component-test.js b/test/unit/components/balance-component-test.js
index 81e6fdf9e..aa9763b72 100644
--- a/test/unit/components/balance-component-test.js
+++ b/test/unit/components/balance-component-test.js
@@ -1,7 +1,7 @@
 const assert = require('assert')
 const h = require('react-hyperscript')
 const { createMockStore } = require('redux-test-utils')
-const { shallowWithStore } = require('../../lib/shallow-with-store')
+const { shallowWithStore } = require('../../lib/render-helpers')
 const BalanceComponent = require('../../../ui/app/components/balance-component')
 const mockState = {
   metamask: {
@@ -42,4 +42,3 @@ describe('BalanceComponent', function () {
   })
 
 })
-
diff --git a/test/unit/components/binary-renderer-test.js b/test/unit/components/binary-renderer-test.js
index 7bf9250cc..e428c26ad 100644
--- a/test/unit/components/binary-renderer-test.js
+++ b/test/unit/components/binary-renderer-test.js
@@ -4,7 +4,7 @@ var BinaryRenderer = require('../../../old-ui/app/components/binary-renderer')
 describe('BinaryRenderer', function () {
   let binaryRenderer
   const message = 'Hello, world!'
-  const buffer = new Buffer(message, 'utf8')
+  const buffer = Buffer.from(message, 'utf8')
   const hex = buffer.toString('hex')
 
   beforeEach(function () {
diff --git a/test/unit/config-manager-test.js b/test/unit/config-manager-test.js
deleted file mode 100644
index df0c549d0..000000000
--- a/test/unit/config-manager-test.js
+++ /dev/null
@@ -1,112 +0,0 @@
-const assert = require('assert')
-const configManagerGen = require('../lib/mock-config-manager')
-
-describe('config-manager', function () {
-  var configManager
-
-  beforeEach(function () {
-    configManager = configManagerGen()
-  })
-
-  describe('#setConfig', function () {
-    it('should set the config key', function () {
-      var testConfig = {
-        provider: {
-          type: 'rpc',
-          rpcTarget: 'foobar',
-        },
-      }
-      configManager.setConfig(testConfig)
-      var result = configManager.getData()
-
-      assert.equal(result.config.provider.type, testConfig.provider.type)
-      assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
-    })
-
-    it('setting wallet should not overwrite config', function () {
-      var testConfig = {
-        provider: {
-          type: 'rpc',
-          rpcTarget: 'foobar',
-        },
-      }
-      configManager.setConfig(testConfig)
-
-      var testWallet = {
-        name: 'this is my fake wallet',
-      }
-      configManager.setWallet(testWallet)
-
-      var result = configManager.getData()
-      assert.equal(result.wallet.name, testWallet.name, 'wallet name is set')
-      assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
-
-      testConfig.provider.type = 'something else!'
-      configManager.setConfig(testConfig)
-
-      result = configManager.getData()
-      assert.equal(result.wallet.name, testWallet.name, 'wallet name is set')
-      assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
-      assert.equal(result.config.provider.type, testConfig.provider.type)
-    })
-  })
-
-  describe('wallet nicknames', function () {
-    it('should return null when no nicknames are saved', function () {
-      var nick = configManager.nicknameForWallet('0x0')
-      assert.equal(nick, null, 'no nickname returned')
-    })
-
-    it('should persist nicknames', function () {
-      var account = '0x0'
-      var nick1 = 'foo'
-      var nick2 = 'bar'
-      configManager.setNicknameForWallet(account, nick1)
-
-      var result1 = configManager.nicknameForWallet(account)
-      assert.equal(result1, nick1)
-
-      configManager.setNicknameForWallet(account, nick2)
-      var result2 = configManager.nicknameForWallet(account)
-      assert.equal(result2, nick2)
-    })
-  })
-
-  describe('rpc manipulations', function () {
-    it('changing rpc should return a different rpc', function () {
-      var firstRpc = 'first'
-      var secondRpc = 'second'
-
-      configManager.setRpcTarget(firstRpc)
-      var firstResult = configManager.getCurrentRpcAddress()
-      assert.equal(firstResult, firstRpc)
-
-      configManager.setRpcTarget(secondRpc)
-      var secondResult = configManager.getCurrentRpcAddress()
-      assert.equal(secondResult, secondRpc)
-    })
-  })
-
-  describe('transactions', function () {
-    beforeEach(function () {
-      configManager.setTxList([])
-    })
-
-    describe('#getTxList', function () {
-      it('when new should return empty array', function () {
-        var result = configManager.getTxList()
-        assert.ok(Array.isArray(result))
-        assert.equal(result.length, 0)
-      })
-    })
-
-    describe('#setTxList', function () {
-      it('saves the submitted data to the tx list', function () {
-        var target = [{ foo: 'bar' }]
-        configManager.setTxList(target)
-        var result = configManager.getTxList()
-        assert.equal(result[0].foo, 'bar')
-      })
-    })
-  })
-})
diff --git a/test/unit/development/sample-changelog.md b/test/unit/development/sample-changelog.md
index 8fc9d2145..fd980e375 100644
--- a/test/unit/development/sample-changelog.md
+++ b/test/unit/development/sample-changelog.md
@@ -67,7 +67,7 @@
 - Estimating gas limit for simple ether sends now faster & cheaper, by avoiding VM usage on recipients with no code.
 - Add an extra px to address for Firefox clipping.
 - Fix Firefox scrollbar.
-- Open metamask popup for transaction confirmation before gas estimation finishes and add a loading screen over transaction confirmation.
+- Open MetaMask popup for transaction confirmation before gas estimation finishes and add a loading screen over transaction confirmation.
 - Fix bug that prevented eth_signTypedData from signing bytes.
 - Further improve gas price estimation.
 
@@ -330,7 +330,7 @@ rollback to 3.10.0 due to bug
 
 ## 3.7.7 2017-6-8
 
-- Fix bug where metamask would show old data after computer being asleep or disconnected from the internet.
+- Fix bug where MetaMask would show old data after computer being asleep or disconnected from the internet.
 
 ## 3.7.6 2017-6-5
 
diff --git a/test/unit/responsive/components/dropdown-test.js b/test/unit/responsive/components/dropdown-test.js
index 493b01918..f3f236d90 100644
--- a/test/unit/responsive/components/dropdown-test.js
+++ b/test/unit/responsive/components/dropdown-test.js
@@ -6,7 +6,7 @@ const path = require('path')
 const Dropdown = require(path.join(__dirname, '..', '..', '..', '..', 'ui', 'app', 'components', 'dropdowns', 'index.js')).Dropdown
 
 const { createMockStore } = require('redux-test-utils')
-const { mountWithStore } = require('../../../lib/shallow-with-store')
+const { mountWithStore } = require('../../../lib/render-helpers')
 
 const mockState = {
   metamask: {
diff --git a/test/unit/ui/add-token.spec.js b/test/unit/ui/add-token.spec.js
index 69b7fb620..f6b6155a0 100644
--- a/test/unit/ui/add-token.spec.js
+++ b/test/unit/ui/add-token.spec.js
@@ -1,7 +1,7 @@
 const assert = require('assert')
 const { createMockStore } = require('redux-test-utils')
 const h = require('react-hyperscript')
-const { shallowWithStore } = require('../../lib/shallow-with-store')
+const { shallowWithStore } = require('../../lib/render-helpers')
 const AddTokenScreen = require('../../../old-ui/app/add-token')
 
 describe('Add Token Screen', function () {
diff --git a/test/unit/ui/app/actions.spec.js b/test/unit/ui/app/actions.spec.js
new file mode 100644
index 000000000..748a58b32
--- /dev/null
+++ b/test/unit/ui/app/actions.spec.js
@@ -0,0 +1,1468 @@
+// Used to inspect long objects
+// util.inspect({JSON}, false, null))
+// const util = require('util')
+const assert = require('assert')
+const sinon = require('sinon')
+const clone = require('clone')
+const nock = require('nock')
+const fetchMock = require('fetch-mock')
+const configureStore = require('redux-mock-store').default
+const thunk = require('redux-thunk').default
+const EthQuery = require('eth-query')
+const Eth = require('ethjs')
+const KeyringController = require('eth-keyring-controller')
+
+const { createTestProviderTools } = require('../../../stub/provider')
+const provider = createTestProviderTools({ scaffold: {}}).provider
+
+const enLocale = require('../../../../app/_locales/en/messages.json')
+const actions = require('../../../../ui/app/actions')
+const MetaMaskController = require('../../../../app/scripts/metamask-controller')
+
+const firstTimeState = require('../../../unit/localhostState')
+const devState = require('../../../data/2-state.json')
+
+const middleware = [thunk]
+const mockStore = configureStore(middleware)
+
+describe('Actions', () => {
+
+  const noop = () => {}
+
+  let background, metamaskController
+
+  const TEST_SEED = 'debris dizzy just program just float decrease vacant alarm reduce speak stadium'
+  const password = 'a-fake-password'
+  const importPrivkey = '4cfd3e90fc78b0f86bf7524722150bb8da9c60cd532564d7ff43f5716514f553'
+
+  beforeEach(async () => {
+
+
+    metamaskController = new MetaMaskController({
+      provider,
+      keyringController: new KeyringController({}),
+      showUnapprovedTx: noop,
+      showUnconfirmedMessage: noop,
+      encryptor: {
+        encrypt: function (password, object) {
+          this.object = object
+          return Promise.resolve('mock-encrypted')
+        },
+        decrypt: function () {
+          return Promise.resolve(this.object)
+        },
+      },
+      initState: clone(firstTimeState),
+    })
+
+    await metamaskController.createNewVaultAndRestore(password, TEST_SEED)
+
+    await metamaskController.importAccountWithStrategy('Private Key', [ importPrivkey ])
+
+    background = metamaskController.getApi()
+
+    actions._setBackgroundConnection(background)
+
+    global.ethQuery = new EthQuery(provider)
+  })
+
+  describe('#tryUnlockMetamask', () => {
+
+    let submitPasswordSpy, verifySeedPhraseSpy
+
+    afterEach(() => {
+      submitPasswordSpy.restore()
+      verifySeedPhraseSpy.restore()
+    })
+
+    it('', async () => {
+
+      const store = mockStore({})
+
+      submitPasswordSpy = sinon.spy(background, 'submitPassword')
+      verifySeedPhraseSpy = sinon.spy(background, 'verifySeedPhrase')
+
+      return store.dispatch(actions.tryUnlockMetamask())
+        .then(() => {
+          assert(submitPasswordSpy.calledOnce)
+          assert(verifySeedPhraseSpy.calledOnce)
+        })
+    })
+
+    it('errors on submitPassword will fail', () => {
+
+      const store = mockStore({})
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'UNLOCK_IN_PROGRESS' },
+        { type: 'UNLOCK_FAILED', value: 'error in submitPassword' },
+        { type: 'HIDE_LOADING_INDICATION' },
+      ]
+
+
+      submitPasswordSpy = sinon.stub(background, 'submitPassword')
+
+      submitPasswordSpy.callsFake((password, callback) => {
+        callback(new Error('error in submitPassword'))
+      })
+
+      return store.dispatch(actions.tryUnlockMetamask('test'))
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('displays warning error and unlock failed when verifySeed fails', () => {
+      const store = mockStore({})
+      const displayWarningError = [ { type: 'DISPLAY_WARNING', value: 'error' } ]
+      const unlockFailedError = [ { type: 'UNLOCK_FAILED', value: 'error' } ]
+
+      verifySeedPhraseSpy = sinon.stub(background, 'verifySeedPhrase')
+      verifySeedPhraseSpy.callsFake(callback => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.tryUnlockMetamask('test'))
+        .catch(() => {
+          const actions = store.getActions()
+          const warning = actions.filter(action => action.type === 'DISPLAY_WARNING')
+          const unlockFailed = actions.filter(action => action.type === 'UNLOCK_FAILED')
+          assert.deepEqual(warning, displayWarningError)
+          assert.deepEqual(unlockFailed, unlockFailedError)
+        })
+    })
+  })
+
+  describe('#confirmSeedWords', () => {
+
+    let clearSeedWordCacheSpy
+
+    afterEach(() => {
+      clearSeedWordCacheSpy.restore()
+    })
+
+    it('shows account page after clearing seed word cache', () => {
+
+      const store = mockStore({})
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'SHOW_ACCOUNTS_PAGE' },
+      ]
+
+      clearSeedWordCacheSpy = sinon.spy(background, 'clearSeedWordCache')
+
+      return store.dispatch(actions.confirmSeedWords())
+        .then(() => {
+          assert.equal(clearSeedWordCacheSpy.callCount, 1)
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('errors in callback will display warning', () => {
+      const store = mockStore({})
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      clearSeedWordCacheSpy = sinon.stub(background, 'clearSeedWordCache')
+
+      clearSeedWordCacheSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.confirmSeedWords())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#createNewVaultAndRestore', () => {
+
+    let createNewVaultAndRestoreSpy, clearSeedWordCacheSpy
+
+    afterEach(() => {
+      createNewVaultAndRestoreSpy.restore()
+    })
+
+    it('clears seed words and restores new vault', () => {
+
+      const store = mockStore({})
+
+      createNewVaultAndRestoreSpy = sinon.spy(background, 'createNewVaultAndRestore')
+      clearSeedWordCacheSpy = sinon.spy(background, 'clearSeedWordCache')
+      return store.dispatch(actions.createNewVaultAndRestore())
+        .then(() => {
+          assert(clearSeedWordCacheSpy.calledOnce)
+          assert(createNewVaultAndRestoreSpy.calledOnce)
+        })
+    })
+
+    it('errors when callback in clearSeedWordCache throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'HIDE_LOADING_INDICATION' },
+      ]
+
+      clearSeedWordCacheSpy = sinon.stub(background, 'clearSeedWordCache')
+      clearSeedWordCacheSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.createNewVaultAndRestore())
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('errors when callback in createNewVaultAndRestore throws', () => {
+
+      const store = mockStore({})
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'HIDE_LOADING_INDICATION' },
+      ]
+
+      createNewVaultAndRestoreSpy = sinon.stub(background, 'createNewVaultAndRestore')
+
+      createNewVaultAndRestoreSpy.callsFake((password, seed, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.createNewVaultAndRestore())
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#createNewVaultAndKeychain', () => {
+
+    let createNewVaultAndKeychainSpy, placeSeedWordsSpy
+
+    afterEach(() => {
+      createNewVaultAndKeychainSpy.restore()
+      placeSeedWordsSpy.restore()
+    })
+
+    it('calls createNewVaultAndKeychain and placeSeedWords in background', () => {
+
+      const store = mockStore()
+
+      createNewVaultAndKeychainSpy = sinon.spy(background, 'createNewVaultAndKeychain')
+      placeSeedWordsSpy = sinon.spy(background, 'placeSeedWords')
+
+      return store.dispatch(actions.createNewVaultAndKeychain())
+        .then(() => {
+          assert(createNewVaultAndKeychainSpy.calledOnce)
+          assert(placeSeedWordsSpy.calledOnce)
+        })
+    })
+
+    it('displays error and value when callback errors', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'HIDE_LOADING_INDICATION' },
+      ]
+
+      createNewVaultAndKeychainSpy = sinon.stub(background, 'createNewVaultAndKeychain')
+      createNewVaultAndKeychainSpy.callsFake((password, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.createNewVaultAndKeychain())
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+
+    })
+
+    it('errors when placeSeedWords throws', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'HIDE_LOADING_INDICATION' },
+      ]
+
+      placeSeedWordsSpy = sinon.stub(background, 'placeSeedWords')
+      placeSeedWordsSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.createNewVaultAndKeychain())
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#requestRevealSeed', () => {
+
+    let submitPasswordSpy, placeSeedWordsSpy
+
+    afterEach(() => {
+      submitPasswordSpy.restore()
+    })
+
+    it('calls submitPassword and placeSeedWords from background', () => {
+
+      const store = mockStore()
+
+      submitPasswordSpy = sinon.spy(background, 'submitPassword')
+      placeSeedWordsSpy = sinon.spy(background, 'placeSeedWords')
+
+      return store.dispatch(actions.requestRevealSeed())
+        .then(() => {
+          assert(submitPasswordSpy.calledOnce)
+          assert(placeSeedWordsSpy.calledOnce)
+        })
+    })
+
+    it('displays warning error with value when callback errors', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      submitPasswordSpy = sinon.stub(background, 'submitPassword')
+      submitPasswordSpy.callsFake((password, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.requestRevealSeed())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#requestRevealSeedWords', () => {
+    let submitPasswordSpy
+
+    it('calls submitPassword in background', () => {
+      const store = mockStore()
+
+      submitPasswordSpy = sinon.spy(background, 'verifySeedPhrase')
+
+      return store.dispatch(actions.requestRevealSeedWords())
+        .then(() => {
+          assert(submitPasswordSpy.calledOnce)
+        })
+    })
+
+    it('displays warning error message then callback in background errors', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      submitPasswordSpy = sinon.stub(background, 'verifySeedPhrase')
+      submitPasswordSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.requestRevealSeedWords())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+
+    })
+  })
+
+  describe('#requestRevealSeed', () => {
+
+    let submitPasswordSpy, placeSeedWordsSpy
+
+    afterEach(() => {
+      submitPasswordSpy.restore()
+      placeSeedWordsSpy.restore()
+    })
+
+    it('calls submitPassword and placeSeedWords in background', () => {
+
+      const store = mockStore()
+
+      submitPasswordSpy = sinon.spy(background, 'submitPassword')
+      placeSeedWordsSpy = sinon.spy(background, 'placeSeedWords')
+
+      return store.dispatch(actions.requestRevealSeed())
+        .then(() => {
+          assert(submitPasswordSpy.calledOnce)
+          assert(placeSeedWordsSpy.calledOnce)
+        })
+    })
+
+    it('displays warning error message when submitPassword in background errors', () => {
+      submitPasswordSpy = sinon.stub(background, 'submitPassword')
+      submitPasswordSpy.callsFake((password, callback) => {
+        callback(new Error('error'))
+      })
+
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      return store.dispatch(actions.requestRevealSeed())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('errors when placeSeedWords throw', () => {
+      placeSeedWordsSpy = sinon.stub(background, 'placeSeedWords')
+      placeSeedWordsSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      return store.dispatch(actions.requestRevealSeed())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#removeAccount', () => {
+    let removeAccountSpy
+
+    afterEach(() => {
+      removeAccountSpy.restore()
+    })
+
+    it('calls removeAccount in background and expect actions to show account', () => {
+      const store = mockStore(devState)
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'SHOW_ACCOUNTS_PAGE' },
+      ]
+
+      removeAccountSpy = sinon.spy(background, 'removeAccount')
+
+      return store.dispatch(actions.removeAccount('0xe18035bf8712672935fdb4e5e431b1a0183d2dfc'))
+        .then(() => {
+          assert(removeAccountSpy.calledOnce)
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('displays warning error message when removeAccount callback errors', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+      removeAccountSpy = sinon.stub(background, 'removeAccount')
+      removeAccountSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.removeAccount('0xe18035bf8712672935fdb4e5e431b1a0183d2dfc'))
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+
+    })
+  })
+
+  describe('#addNewKeyring', () => {
+    let addNewKeyringSpy
+
+    beforeEach(() => {
+      addNewKeyringSpy = sinon.stub(background, 'addNewKeyring')
+    })
+
+    afterEach(() => {
+      addNewKeyringSpy.restore()
+    })
+
+    it('', () => {
+      const privateKey = 'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3'
+
+      const store = mockStore()
+      store.dispatch(actions.addNewKeyring('Simple Key Pair', [ privateKey ]))
+      assert(addNewKeyringSpy.calledOnce)
+    })
+
+    it('errors then addNewKeyring in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      addNewKeyringSpy.callsFake((type, opts, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.addNewKeyring())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+
+  })
+
+  describe('#resetAccount', () => {
+
+    let resetAccountSpy
+
+    afterEach(() => {
+      resetAccountSpy.restore()
+    })
+
+    it('', () => {
+
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'SHOW_ACCOUNTS_PAGE' },
+      ]
+
+      resetAccountSpy = sinon.spy(background, 'resetAccount')
+
+      return store.dispatch(actions.resetAccount())
+        .then(() => {
+          assert(resetAccountSpy.calledOnce)
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      resetAccountSpy = sinon.stub(background, 'resetAccount')
+      resetAccountSpy.callsFake((callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.resetAccount())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#importNewAccount', () => {
+
+    let importAccountWithStrategySpy
+
+    afterEach(() => {
+      importAccountWithStrategySpy.restore()
+    })
+
+    it('calls importAccountWithStrategies in background', () => {
+      const store = mockStore()
+
+      importAccountWithStrategySpy = sinon.spy(background, 'importAccountWithStrategy')
+
+      const importPrivkey = 'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3'
+
+      return store.dispatch(actions.importNewAccount('Private Key', [ importPrivkey ]))
+        .then(() => {
+          assert(importAccountWithStrategySpy.calledOnce)
+        })
+    })
+
+    it('displays warning error message when importAccount in background callback errors', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: 'This may take a while, please be patient.' },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      importAccountWithStrategySpy = sinon.stub(background, 'importAccountWithStrategy')
+      importAccountWithStrategySpy.callsFake((strategy, args, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.importNewAccount())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#addNewAccount', () => {
+
+    let addNewAccountSpy
+
+    afterEach(() => {
+      addNewAccountSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore({ metamask: devState })
+
+      addNewAccountSpy = sinon.spy(background, 'addNewAccount')
+
+      return store.dispatch(actions.addNewAccount())
+        .then(() => {
+          assert(addNewAccountSpy.calledOnce)
+        })
+    })
+  })
+
+  describe('#setCurrentCurrency', () => {
+
+    let setCurrentCurrencySpy
+
+    beforeEach(() => {
+      setCurrentCurrencySpy = sinon.stub(background, 'setCurrentCurrency')
+    })
+
+    afterEach(() => {
+      setCurrentCurrencySpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.setCurrentCurrency('jpy'))
+      assert(setCurrentCurrencySpy.calledOnce)
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+      setCurrentCurrencySpy.callsFake((currencyCode, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setCurrentCurrency())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#signMsg', () => {
+
+    let signMessageSpy, metamaskMsgs, msgId, messages
+
+    const msgParams = {
+      from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
+      data: '0x879a053d4800c6354e76c7985a865d2922c82fb5b3f4577b2fe08b998954f2e0',
+    }
+
+    beforeEach(() => {
+      metamaskController.newUnsignedMessage(msgParams, noop)
+      metamaskMsgs = metamaskController.messageManager.getUnapprovedMsgs()
+      messages = metamaskController.messageManager.messages
+      msgId = Object.keys(metamaskMsgs)[0]
+      messages[0].msgParams.metamaskId = parseInt(msgId)
+    })
+
+    afterEach(() => {
+      signMessageSpy.restore()
+    })
+
+    it('calls signMsg in background', () => {
+      const store = mockStore()
+
+      signMessageSpy = sinon.spy(background, 'signMessage')
+
+      return store.dispatch(actions.signMsg(msgParams))
+        .then(() => {
+          assert(signMessageSpy.calledOnce)
+        })
+
+    })
+
+    it('errors when signMessage in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'UPDATE_METAMASK_STATE', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      signMessageSpy = sinon.stub(background, 'signMessage')
+      signMessageSpy.callsFake((msgData, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.signMsg())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+  })
+
+  describe('#signPersonalMsg', () => {
+
+    let signPersonalMessageSpy, metamaskMsgs, msgId, personalMessages
+
+    const msgParams = {
+      from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
+      data: '0x879a053d4800c6354e76c7985a865d2922c82fb5b3f4577b2fe08b998954f2e0',
+    }
+
+    beforeEach(() => {
+      metamaskController.newUnsignedPersonalMessage(msgParams, noop)
+      metamaskMsgs = metamaskController.personalMessageManager.getUnapprovedMsgs()
+      personalMessages = metamaskController.personalMessageManager.messages
+      msgId = Object.keys(metamaskMsgs)[0]
+      personalMessages[0].msgParams.metamaskId = parseInt(msgId)
+    })
+
+    afterEach(() => {
+      signPersonalMessageSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+
+      signPersonalMessageSpy = sinon.spy(background, 'signPersonalMessage')
+
+      return store.dispatch(actions.signPersonalMsg(msgParams))
+        .then(() => {
+          assert(signPersonalMessageSpy.calledOnce)
+        })
+
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'UPDATE_METAMASK_STATE', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      signPersonalMessageSpy = sinon.stub(background, 'signPersonalMessage')
+      signPersonalMessageSpy.callsFake((msgData, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.signPersonalMsg(msgParams))
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+  })
+
+  describe('#signTx', () => {
+
+    let sendTransactionSpy
+
+    beforeEach(() => {
+      global.ethQuery = new EthQuery(provider)
+      sendTransactionSpy = sinon.stub(global.ethQuery, 'sendTransaction')
+    })
+
+    afterEach(() => {
+      sendTransactionSpy.restore()
+    })
+
+    it('calls sendTransaction in global ethQuery', () => {
+      const store = mockStore()
+      store.dispatch(actions.signTx())
+      assert(sendTransactionSpy.calledOnce)
+    })
+
+    it('errors in when sendTransaction throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'SHOW_CONF_TX_PAGE', transForward: true, id: undefined },
+      ]
+      sendTransactionSpy.callsFake((txData, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.signTx())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#signTokenTx', () => {
+
+    let tokenSpy
+
+    beforeEach(() => {
+      global.eth = new Eth(provider)
+      tokenSpy = sinon.spy(global.eth, 'contract')
+    })
+
+    afterEach(() => {
+      tokenSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.signTokenTx())
+      assert(tokenSpy.calledOnce)
+    })
+  })
+
+  describe('#lockMetamask', () => {
+    let backgroundSetLockedSpy
+
+    afterEach(() => {
+      backgroundSetLockedSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+
+      backgroundSetLockedSpy = sinon.spy(background, 'setLocked')
+
+      return store.dispatch(actions.lockMetamask())
+        .then(() => {
+          assert(backgroundSetLockedSpy.calledOnce)
+        })
+    })
+
+    it('returns display warning error with value when setLocked in background callback errors', () => {
+      const store = mockStore()
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'LOCK_METAMASK' },
+    ]
+      backgroundSetLockedSpy = sinon.stub(background, 'setLocked')
+      backgroundSetLockedSpy.callsFake(callback => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.lockMetamask())
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#setSelectedAddress', () => {
+    let setSelectedAddressSpy
+
+    beforeEach(() => {
+      setSelectedAddressSpy = sinon.stub(background, 'setSelectedAddress')
+    })
+
+    afterEach(() => {
+      setSelectedAddressSpy.restore()
+    })
+
+    it('calls setSelectedAddress in background', () => {
+      const store = mockStore({ metamask: devState })
+
+      store.dispatch(actions.setSelectedAddress('0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'))
+      assert(setSelectedAddressSpy.calledOnce)
+    })
+
+    it('errors when setSelectedAddress throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      setSelectedAddressSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setSelectedAddress())
+      assert.deepEqual(store.getActions(), expectedActions)
+
+    })
+  })
+
+  describe('#showAccountDetail', () => {
+    let setSelectedAddressSpy
+
+    beforeEach(() => {
+      setSelectedAddressSpy = sinon.stub(background, 'setSelectedAddress')
+    })
+
+    afterEach(() => {
+      setSelectedAddressSpy.restore()
+    })
+
+    it('#showAccountDetail', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.showAccountDetail())
+      assert(setSelectedAddressSpy.calledOnce)
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+      setSelectedAddressSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+
+      store.dispatch(actions.showAccountDetail())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#addToken', () => {
+    let addTokenSpy
+
+    beforeEach(() => {
+      addTokenSpy = sinon.stub(background, 'addToken')
+    })
+
+    afterEach(() => {
+      addTokenSpy.restore()
+    })
+
+    it('calls addToken in background', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.addToken())
+        .then(() => {
+          assert(addTokenSpy.calledOnce)
+        })
+    })
+
+    it('errors when addToken in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'UPDATE_TOKENS', newTokens: undefined },
+      ]
+
+      addTokenSpy.callsFake((address, symbol, decimals, image, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.addToken())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#removeToken', () => {
+
+    let removeTokenSpy
+
+    beforeEach(() => {
+      removeTokenSpy = sinon.stub(background, 'removeToken')
+    })
+
+    afterEach(() => {
+      removeTokenSpy.restore()
+    })
+
+    it('calls removeToken in background', () => {
+      const store = mockStore()
+      store.dispatch(actions.removeToken())
+        .then(() => {
+          assert(removeTokenSpy.calledOnce)
+        })
+    })
+
+    it('errors when removeToken in background fails', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'UPDATE_TOKENS', newTokens: undefined },
+      ]
+
+      removeTokenSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.removeToken())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#markNoticeRead', () => {
+    let markNoticeReadSpy
+    const notice = {
+      id: 0,
+      read: false,
+      date: 'test date',
+      title: 'test title',
+      body: 'test body',
+    }
+
+    beforeEach(() => {
+      markNoticeReadSpy = sinon.stub(background, 'markNoticeRead')
+    })
+
+    afterEach(() => {
+      markNoticeReadSpy.restore()
+    })
+
+    it('calls markNoticeRead in background', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.markNoticeRead(notice))
+      .then(() => {
+        assert(markNoticeReadSpy.calledOnce)
+      })
+
+    })
+
+    it('errors when markNoticeRead in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+      markNoticeReadSpy.callsFake((notice, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.markNoticeRead())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#setProviderType', () => {
+    let setProviderTypeSpy
+
+    beforeEach(() => {
+      setProviderTypeSpy = sinon.stub(background, 'setProviderType')
+    })
+
+    afterEach(() => {
+      setProviderTypeSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.setProviderType())
+      assert(setProviderTypeSpy.calledOnce)
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'DISPLAY_WARNING', value: 'Had a problem changing networks!' },
+      ]
+
+      setProviderTypeSpy.callsFake((type, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setProviderType())
+      assert(setProviderTypeSpy.calledOnce)
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#setRpcTarget', () => {
+    let setRpcTargetSpy
+
+    beforeEach(() => {
+      setRpcTargetSpy = sinon.stub(background, 'setCustomRpc')
+    })
+
+    afterEach(() => {
+      setRpcTargetSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.setRpcTarget('http://localhost:8545'))
+      assert(setRpcTargetSpy.calledOnce)
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'DISPLAY_WARNING', value: 'Had a problem changing networks!' },
+      ]
+
+      setRpcTargetSpy.callsFake((newRpc, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setRpcTarget())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#addToAddressBook', () => {
+    let addToAddressBookSpy
+
+    beforeEach(() => {
+      addToAddressBookSpy = sinon.stub(background, 'setAddressBook')
+    })
+
+    afterEach(() => {
+      addToAddressBookSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.addToAddressBook('test'))
+      assert(addToAddressBookSpy.calledOnce)
+    })
+  })
+
+  describe('#exportAccount', () => {
+    let submitPasswordSpy, exportAccountSpy
+
+    afterEach(() => {
+      submitPasswordSpy.restore()
+      exportAccountSpy.restore()
+    })
+
+    it('returns expected actions for successful action', () => {
+      const store = mockStore(devState)
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'SHOW_PRIVATE_KEY', value: '7ec73b91bb20f209a7ff2d32f542c3420b4fccf14abcc7840d2eff0ebcb18505' },
+      ]
+
+      submitPasswordSpy = sinon.spy(background, 'submitPassword')
+      exportAccountSpy = sinon.spy(background, 'exportAccount')
+
+      return store.dispatch(actions.exportAccount(password, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'))
+        .then((result) => {
+          assert(submitPasswordSpy.calledOnce)
+          assert(exportAccountSpy.calledOnce)
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('returns action errors when first func callback errors', () => {
+      const store = mockStore(devState)
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'Incorrect Password.' },
+      ]
+
+      submitPasswordSpy = sinon.stub(background, 'submitPassword')
+      submitPasswordSpy.callsFake((password, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.exportAccount(password, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'))
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('returns action errors when second func callback errors', () => {
+      const store = mockStore(devState)
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'Had a problem exporting the account.' },
+      ]
+
+      exportAccountSpy = sinon.stub(background, 'exportAccount')
+      exportAccountSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.exportAccount(password, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'))
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#setAccountLabel', () => {
+    let setAccountLabelSpy
+
+    beforeEach(() => {
+      setAccountLabelSpy = sinon.stub(background, 'setAccountLabel')
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.setAccountLabel('0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc', 'test'))
+      assert(setAccountLabelSpy.calledOnce)
+    })
+  })
+
+  describe('#pairUpdate', () => {
+    beforeEach(() => {
+
+      nock('https://shapeshift.io')
+        .defaultReplyHeaders({ 'access-control-allow-origin': '*' })
+        .get('/marketinfo/btc_eth')
+        .reply(200, {pair: 'BTC_ETH', rate: 25.68289016, minerFee: 0.00176, limit: 0.67748474, minimum: 0.00013569, maxLimit: 0.67758573})
+
+      nock('https://shapeshift.io')
+        .defaultReplyHeaders({ 'access-control-allow-origin': '*' })
+        .get('/coins')
+        .reply(200)
+      })
+
+    afterEach(() => {
+      nock.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      // issue with dispatch action in callback not showing
+      const expectedActions = [
+        { type: 'SHOW_SUB_LOADING_INDICATION' },
+        { type: 'HIDE_WARNING' },
+      ]
+
+      store.dispatch(actions.pairUpdate('btc'))
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#setFeatureFlag', () => {
+    let setFeatureFlagSpy
+
+    beforeEach(() => {
+      setFeatureFlagSpy = sinon.stub(background, 'setFeatureFlag')
+    })
+
+    afterEach(() => {
+      setFeatureFlagSpy.restore()
+    })
+
+    it('calls setFeatureFlag in the background', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.setFeatureFlag())
+      assert(setFeatureFlagSpy.calledOnce)
+    })
+
+    it('errors when setFeatureFlag in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      setFeatureFlagSpy.callsFake((feature, activated, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setFeatureFlag())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#updateNetworkNonce', () => {
+    let getTransactionCountSpy
+
+    afterEach(() => {
+      getTransactionCountSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      getTransactionCountSpy = sinon.spy(global.ethQuery, 'getTransactionCount')
+
+      store.dispatch(actions.updateNetworkNonce())
+        .then(() => {
+          assert(getTransactionCountSpy.calledOnce)
+        })
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+
+      getTransactionCountSpy = sinon.stub(global.ethQuery, 'getTransactionCount')
+      getTransactionCountSpy.callsFake((address, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.updateNetworkNonce())
+        .catch(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#setUseBlockie', () => {
+    let setUseBlockieSpy
+
+    beforeEach(() => {
+      setUseBlockieSpy = sinon.stub(background, 'setUseBlockie')
+    })
+
+    afterEach(() => {
+      setUseBlockieSpy.restore()
+    })
+
+    it('calls setUseBlockie in background', () => {
+      const store = mockStore()
+
+      store.dispatch(actions.setUseBlockie())
+      assert(setUseBlockieSpy.calledOnce)
+    })
+
+    it('errors when setUseBlockie in background throws', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+        { type: 'SET_USE_BLOCKIE', value: undefined },
+      ]
+
+      setUseBlockieSpy.callsFake((val, callback) => {
+        callback(new Error('error'))
+      })
+
+      store.dispatch(actions.setUseBlockie())
+      assert.deepEqual(store.getActions(), expectedActions)
+    })
+  })
+
+  describe('#updateCurrentLocale', () => {
+    let setCurrentLocaleSpy
+
+    beforeEach(() => {
+      fetchMock.get('*', enLocale)
+    })
+
+    afterEach(() => {
+      setCurrentLocaleSpy.restore()
+      fetchMock.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      setCurrentLocaleSpy = sinon.spy(background, 'setCurrentLocale')
+
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'SET_CURRENT_LOCALE', value: 'en' },
+        { type: 'SET_LOCALE_MESSAGES', value: enLocale },
+      ]
+
+      return store.dispatch(actions.updateCurrentLocale('en'))
+        .then(() => {
+          assert(setCurrentLocaleSpy.calledOnce)
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+
+    it('', () => {
+      const store = mockStore()
+      const expectedActions = [
+        { type: 'SHOW_LOADING_INDICATION', value: undefined },
+        { type: 'HIDE_LOADING_INDICATION' },
+        { type: 'DISPLAY_WARNING', value: 'error' },
+      ]
+      setCurrentLocaleSpy = sinon.stub(background, 'setCurrentLocale')
+      setCurrentLocaleSpy.callsFake((key, callback) => {
+        callback(new Error('error'))
+      })
+
+      return store.dispatch(actions.updateCurrentLocale('en'))
+        .then(() => {
+          assert.deepEqual(store.getActions(), expectedActions)
+        })
+    })
+  })
+
+  describe('#markPasswordForgotten', () => {
+    let markPasswordForgottenSpy
+
+    beforeEach(() => {
+      markPasswordForgottenSpy = sinon.stub(background, 'markPasswordForgotten')
+    })
+
+    afterEach(() => {
+      markPasswordForgottenSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.markPasswordForgotten())
+      assert(markPasswordForgottenSpy.calledOnce)
+    })
+  })
+
+  describe('#unMarkPasswordForgotten', () => {
+    let unMarkPasswordForgottenSpy
+
+    beforeEach(() => {
+      unMarkPasswordForgottenSpy = sinon.stub(background, 'unMarkPasswordForgotten')
+    })
+
+    afterEach(() => {
+      unMarkPasswordForgottenSpy.restore()
+    })
+
+    it('', () => {
+      const store = mockStore()
+      store.dispatch(actions.unMarkPasswordForgotten())
+      assert(unMarkPasswordForgottenSpy.calledOnce)
+    })
+  })
+
+
+})
diff --git a/test/unit/ui/app/components/identicon.spec.js b/test/unit/ui/app/components/identicon.spec.js
new file mode 100644
index 000000000..a2f8d8246
--- /dev/null
+++ b/test/unit/ui/app/components/identicon.spec.js
@@ -0,0 +1,36 @@
+import React from 'react'
+import assert from 'assert'
+import thunk from 'redux-thunk'
+import configureMockStore from 'redux-mock-store'
+import { mount } from 'enzyme'
+
+import IdenticonComponent from '../../../../../ui/app/components/identicon'
+
+describe('Identicon Component', () => {
+
+  const state = {
+    metamask: {
+      useBlockie: false,
+    },
+  }
+
+  const middlewares = [thunk]
+  const mockStore = configureMockStore(middlewares)
+  const store = mockStore(state)
+
+  it('renders default eth_logo identicon with no props', () => {
+    const wrapper = mount(<IdenticonComponent store={store}/>)
+    assert.equal(wrapper.find('img.balance-icon').prop('src'), './images/eth_logo.svg')
+  })
+
+  it('renders custom image and add className props', () => {
+    const wrapper = mount(<IdenticonComponent store={store} className={'test-image'} image={'test-image'} />)
+    assert.equal(wrapper.find('img.test-image').prop('className'), 'test-image identicon')
+    assert.equal(wrapper.find('img.test-image').prop('src'), 'test-image')
+  })
+
+  it('renders div with address prop', () => {
+    const wrapper = mount(<IdenticonComponent store={store} className={'test-address'} address={'0xTest'} />)
+    assert.equal(wrapper.find('div.test-address').prop('className'), 'test-address identicon')
+  })
+})
diff --git a/test/unit/ui/app/components/token-cell.spec.js b/test/unit/ui/app/components/token-cell.spec.js
new file mode 100644
index 000000000..6145c6924
--- /dev/null
+++ b/test/unit/ui/app/components/token-cell.spec.js
@@ -0,0 +1,69 @@
+import React from 'react'
+import assert from 'assert'
+import thunk from 'redux-thunk'
+import { Provider } from 'react-redux'
+import configureMockStore from 'redux-mock-store'
+import { mount } from 'enzyme'
+
+import TokenCell from '../../../../../ui/app/components/token-cell'
+import Identicon from '../../../../../ui/app/components/identicon'
+
+describe('Token Cell', () => {
+  let wrapper
+
+  const state = {
+    metamask: {
+      network: 'test',
+      currentCurrency: 'usd',
+      selectedTokenAddress: '0xToken',
+      selectedAddress: '0xAddress',
+      contractExchangeRates: {
+        '0xAnotherToken': 0.015,
+      },
+      conversionRate: 7.00,
+    },
+    appState: {
+      sidebar: {
+        isOpen: true,
+      },
+    },
+  }
+
+  const middlewares = [thunk]
+  const mockStore = configureMockStore(middlewares)
+  const store = mockStore(state)
+
+  beforeEach(() => {
+    wrapper = mount(
+      <Provider store={store}>
+        <TokenCell
+          address={'0xAnotherToken'}
+          symbol={'TEST'}
+          string={'5.000'}
+          network={22}
+          currentCurrency={'usd'}
+          image={'./test-image'}
+        />
+      </Provider>
+    )
+  })
+
+  it('renders Identicon with props from token cell', () => {
+    assert.equal(wrapper.find(Identicon).prop('address'), '0xAnotherToken')
+    assert.equal(wrapper.find(Identicon).prop('network'), 'test')
+    assert.equal(wrapper.find(Identicon).prop('image'), './test-image')
+  })
+
+  it('renders token balance', () => {
+    assert.equal(wrapper.find('.token-list-item__token-balance').text(), '5.000')
+  })
+
+  it('renders token symbol', () => {
+    assert.equal(wrapper.find('.token-list-item__token-symbol').text(), 'TEST')
+  })
+
+  it('renders converted fiat amount', () => {
+    assert.equal(wrapper.find('.token-list-item__fiat-amount').text(), '0.52 USD')
+  })
+
+})
diff --git a/test/unit/ui/app/selectors.spec.js b/test/unit/ui/app/selectors.spec.js
new file mode 100644
index 000000000..78c4267ee
--- /dev/null
+++ b/test/unit/ui/app/selectors.spec.js
@@ -0,0 +1,175 @@
+const assert = require('assert')
+const selectors = require('../../../../ui/app/selectors')
+const mockState = require('../../../data/mock-state.json')
+const Eth = require('ethjs')
+
+const { createTestProviderTools } = require('../../../stub/provider')
+const provider = createTestProviderTools({ scaffold: {}}).provider
+
+describe('Selectors', function () {
+
+  describe('#getSelectedAddress', function () {
+    let state
+    beforeEach(function () {
+      state = {
+        metamask: {
+          accounts: {
+            '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc': {
+              'balance': '0x0',
+              'address': '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
+            },
+          },
+        },
+      }
+    })
+
+    it('returns first account if selectedAddress is undefined', function () {
+      assert.equal(selectors.getSelectedAddress(state), '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+    })
+
+    it('returns selectedAddress', function () {
+      assert.equal(selectors.getSelectedAddress(mockState), '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+    })
+
+  })
+
+  it('returns selected identity', function () {
+    const identity = selectors.getSelectedIdentity(mockState)
+    assert.equal(identity.address, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+    assert.equal(identity.name, 'Test Account')
+  })
+
+  it('returns selected account', function () {
+    const account = selectors.getSelectedAccount(mockState)
+    assert.equal(account.balance, '0x0')
+    assert.equal(account.address, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+  })
+
+  it('returns selected token from first token list', function () {
+    const token = selectors.getSelectedToken(mockState)
+    assert.equal(token.address, '0x108cf70c7d384c552f42c07c41c0e1e46d77ea0d')
+    assert.equal(token.symbol, 'TEST')
+    assert.equal(token.decimals, '0')
+  })
+
+  describe('#getSelectedTokenExchangeRate', function () {
+    it('returns token exchange rate for first token', function () {
+      const tokenRate = selectors.getSelectedTokenExchangeRate(mockState)
+      assert.equal(tokenRate, '0.00039345803819379796')
+    })
+  })
+
+
+  describe('#getTokenExchangeRate', function () {
+    let missingTokenRate
+
+    beforeEach(function () {
+      missingTokenRate = {
+        metamask: {
+          'contractExchangeRates': {},
+        },
+      }
+    })
+
+    it('returns 0 token exchange rate for a token not in state', function () {
+      const tokenRate = selectors.getTokenExchangeRate(missingTokenRate, '0xd8f6a2ffb0fc5952d16c9768b71cfd35b6399aa5')
+      assert.equal(tokenRate, 0)
+    })
+
+    it('returns token exchange rate for specified token in state', function () {
+      const tokenRate = selectors.getTokenExchangeRate(mockState, '0xd8f6a2ffb0fc5952d16c9768b71cfd35b6399aa5')
+      assert.equal(tokenRate, 0.00008189274407698049)
+    })
+
+  })
+
+  it('returns conversionRate from state', function () {
+    assert.equal(selectors.conversionRateSelector(mockState), 556.12)
+  })
+
+  it('returns address book from state', function () {
+    const addressBook = selectors.getAddressBook(mockState)
+    assert.equal(addressBook[0].address, '0xc42edfcc21ed14dda456aa0756c153f7985d8813')
+    assert.equal(addressBook[0].name, '')
+  })
+
+  it('returns accounts with balance, address, and name from identity and accounts in state', function () {
+    const accountsWithSendEther = selectors.accountsWithSendEtherInfoSelector(mockState)
+    assert.equal(accountsWithSendEther.length, 2)
+    assert.equal(accountsWithSendEther[0].balance, '0x0')
+    assert.equal(accountsWithSendEther[0].address, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+    assert.equal(accountsWithSendEther[0].name, 'Test Account')
+  })
+
+  it('returns selected account with balance, address, and name from accountsWithSendEtherInfoSelector', function () {
+    const currentAccountwithSendEther = selectors.getCurrentAccountWithSendEtherInfo(mockState)
+    assert.equal(currentAccountwithSendEther.balance, '0x0')
+    assert.equal(currentAccountwithSendEther.address, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+    assert.equal(currentAccountwithSendEther.name, 'Test Account')
+  })
+
+  describe('#transactionSelector', function () {
+    it('returns transactions from state', function () {
+      selectors.transactionsSelector(mockState)
+    })
+  })
+
+  it('#getGasIsLoading', () => {
+    const gasIsLoading = selectors.getGasIsLoading(mockState)
+    assert.equal(gasIsLoading, false)
+  })
+
+  describe('Send From', () => {
+    it('#getSendFrom', () => {
+      const sendFrom = selectors.getSendFrom(mockState)
+      assert.equal(sendFrom, '0xc42edfcc21ed14dda456aa0756c153f7985d8813')
+    })
+
+    it('#getForceGasMin', () => {
+      const forceGasMin = selectors.getForceGasMin(mockState)
+      assert.equal(forceGasMin, null)
+    })
+
+    it('#getSendAmount', () => {
+      const sendAmount = selectors.getSendAmount(mockState)
+      assert.equal(sendAmount, '1bc16d674ec80000')
+    })
+
+    it('#getSendMaxModeState', () => {
+      const sendMaxModeState = selectors.getSendMaxModeState(mockState)
+      assert.equal(sendMaxModeState, false)
+    })
+  })
+
+  it('#getCurrentCurrency', () => {
+    const currentCurrency = selectors.getCurrentCurrency(mockState)
+    assert.equal(currentCurrency, 'usd')
+  })
+
+  it('#getSelectedTokenToFiatRate', () => {
+    const selectedTokenToFiatRate = selectors.getSelectedTokenToFiatRate(mockState)
+    assert.equal(selectedTokenToFiatRate, '0.21880988420033493')
+  })
+
+  describe('#getSelectedTokenContract', () => {
+
+    beforeEach(() => {
+      global.eth = new Eth(provider)
+    })
+
+    it('', () => {
+      const selectedTokenContract = selectors.getSelectedTokenContract(mockState)
+      assert(selectedTokenContract.abi)
+    })
+  })
+
+  it('#getCurrentViewContext', () => {
+    const currentViewContext = selectors.getCurrentViewContext(mockState)
+    assert.equal(currentViewContext, '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc')
+  })
+
+  it('#getTotalUnapprovedCount', () => {
+    const totalUnapprovedCount = selectors.getTotalUnapprovedCount(mockState)
+    assert.equal(totalUnapprovedCount, 1)
+  })
+})
diff --git a/test/unit/ui/etherscan-prefix-for-network.spec.js b/test/unit/ui/etherscan-prefix-for-network.spec.js
new file mode 100644
index 000000000..f0aeb8306
--- /dev/null
+++ b/test/unit/ui/etherscan-prefix-for-network.spec.js
@@ -0,0 +1,26 @@
+const assert = require('assert')
+const etherscanNetworkPrefix = require('../../../ui/lib/etherscan-prefix-for-network')
+
+describe('Etherscan Network Prefix', () => {
+
+  it('returns empy string as default value', () => {
+    assert.equal(etherscanNetworkPrefix(), '')
+  })
+
+  it('returns empty string as a prefix for networkId of 1', () => {
+    assert.equal(etherscanNetworkPrefix(1), '')
+  })
+
+  it('returns ropsten as prefix for networkId of 3', () => {
+    assert.equal(etherscanNetworkPrefix(3), 'ropsten.')
+  })
+
+  it('returns rinkeby as prefix for networkId of 4', () => {
+    assert.equal(etherscanNetworkPrefix(4), 'rinkeby.')
+  })
+
+  it('returs kovan as prefix for networkId of 42', () => {
+    assert.equal(etherscanNetworkPrefix(42), 'kovan.')
+  })
+
+})
author	brunobar79 <brunobar79@gmail.com>	2018-10-17 02:01:54 +0800
committer	brunobar79 <brunobar79@gmail.com>	2018-10-17 02:01:54 +0800
commit	13820b6cc1801a420f39cdfecd7ccb5309dc597b (patch)
tree	c79832d7077ab03e0afe0c322cb32b204865d8b5 /test
parent	eeecee01540fbad50c4c463a3b1a54142a63f168 (diff)
parent	07ab613d4c647e3fe554bc06eab8cfb833315a88 (diff)
download	tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.gz tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.bz2 tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.lz tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.xz tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.tar.zst tangerine-wallet-browser-13820b6cc1801a420f39cdfecd7ccb5309dc597b.zip