Use `async/await` in action creators that force update state (#8421)

The action creators that use `forceUpdateMetamaskState` without
awaiting that task's completion have been updated to use `async/await`.
This was done in preparation for `await`-ing the completion of
`forceUpdateMetamaskState`, which will be done in a subsequent PR.

ui/app/store/actions.js

@@ -304,86 +304,79 @@ export function importNewAccount (strategy, args) {
 
 export function addNewAccount () {
   log.debug(`background.addNewAccount`)
-  return (dispatch, getState) => {
+  return async (dispatch, getState) => {
     const oldIdentities = getState().metamask.identities
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      background.addNewAccount((err, { identities: newIdentities }) => {
+    let newIdentities
-        if (err) {
+    try {
-          dispatch(displayWarning(err.message))
+      const { identities } = await promisifiedBackground.addNewAccount()
-          return reject(err)
+      newIdentities = identities
+    } catch (error) {
+      dispatch(displayWarning(error.message))
+      throw error
     }
     const newAccountAddress = Object.keys(newIdentities).find((address) => !oldIdentities[address])
-
     dispatch(hideLoadingIndication())
-
     forceUpdateMetamaskState(dispatch)
-        return resolve(newAccountAddress)
+    return newAccountAddress
-      })
-    })
   }
 }
 
 export function checkHardwareStatus (deviceName, hdPath) {
   log.debug(`background.checkHardwareStatus`, deviceName, hdPath)
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      background.checkHardwareStatus(deviceName, hdPath, (err, unlocked) => {
+    let unlocked
-        if (err) {
+    try {
-          log.error(err)
+      unlocked = await promisifiedBackground.checkHardwareStatus(deviceName, hdPath)
-          dispatch(displayWarning(err.message))
+    } catch (error) {
-          return reject(err)
+      log.error(error)
+      dispatch(displayWarning(error.message))
+      throw error
     }
 
     dispatch(hideLoadingIndication())
-
     forceUpdateMetamaskState(dispatch)
-        return resolve(unlocked)
+    return unlocked
-      })
-    })
   }
 }
 
 export function forgetDevice (deviceName) {
   log.debug(`background.forgetDevice`, deviceName)
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+    try {
-      background.forgetDevice(deviceName, (err) => {
+      await promisifiedBackground.forgetDevice(deviceName)
-        if (err) {
+    } catch (error) {
-          log.error(err)
+      log.error(error)
-          dispatch(displayWarning(err.message))
+      dispatch(displayWarning(error.message))
-          return reject(err)
+      throw error
     }
 
     dispatch(hideLoadingIndication())
-
     forceUpdateMetamaskState(dispatch)
-        return resolve()
-      })
-    })
   }
 }
 
 export function connectHardware (deviceName, page, hdPath) {
   log.debug(`background.connectHardware`, deviceName, page, hdPath)
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
-      background.connectHardware(deviceName, page, hdPath, (err, accounts) => {
-        if (err) {
-          log.error(err)
-          dispatch(displayWarning(err.message))
-          return reject(err)
-        }
 
+    let accounts
+    try {
+      accounts = await promisifiedBackground.connectHardware(deviceName, page, hdPath)
+    } catch (error) {
+      log.error(error)
+      dispatch(displayWarning(error.message))
+      throw error
+    }
     dispatch(hideLoadingIndication())
-
     forceUpdateMetamaskState(dispatch)
-        return resolve(accounts)
+
-      })
+    return accounts
-    })
   }
 }