Use async/await in message manager action creators (#8434)

These action creators for the "message manager" controller
interactions have been updated to use `async/await`. There should be
almost no changes in behavior. The only things removed were a few debug
log statements, and a single `console.log`.

ui/app/store/actions.js

@@ -434,153 +434,134 @@ export function setCurrentCurrency (currencyCode) {
 
 export function signMsg (msgData) {
   log.debug('action - signMsg')
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.signMessage`)
-      background.signMessage(msgData, (err, newState) => {
+    let newState
-        log.debug('signMessage called back')
+    try {
+      newState = await promisifiedBackground.signMessage(msgData)
+    } catch (error) {
       dispatch(hideLoadingIndication())
-
+      log.error(error)
-        if (err) {
+      dispatch(displayWarning(error.message))
-          log.error(err)
+      throw error
-          dispatch(displayWarning(err.message))
-          return reject(err)
     }
-
+    dispatch(hideLoadingIndication())
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(msgData.metamaskId))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function signPersonalMsg (msgData) {
   log.debug('action - signPersonalMsg')
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.signPersonalMessage`)
-      background.signPersonalMessage(msgData, (err, newState) => {
+
-        log.debug('signPersonalMessage called back')
+    let newState
+    try {
+      newState = await promisifiedBackground.signPersonalMessage(msgData)
+    } catch (error) {
       dispatch(hideLoadingIndication())
-
+      log.error(error)
-        if (err) {
+      dispatch(displayWarning(error.message))
-          log.error(err)
+      throw error
-          dispatch(displayWarning(err.message))
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(msgData.metamaskId))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function decryptMsgInline (decryptedMsgData) {
   log.debug('action - decryptMsgInline')
-  return (dispatch) => {
+  return async (dispatch) => {
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.decryptMessageInline`)
-      background.decryptMessageInline(decryptedMsgData, (err, newState) => {
-        log.debug('decryptMsgInline called back')
 
-        if (err) {
+    let newState
-          log.error(err)
+    try {
-          dispatch(displayWarning(err.message))
+      newState = await promisifiedBackground.decryptMessageInline(decryptedMsgData)
-          return reject(err)
+    } catch (error) {
+      log.error(error)
+      dispatch(displayWarning(error.message))
+      throw error
     }
 
     dispatch(updateMetamaskState(newState))
     decryptedMsgData = newState.unapprovedDecryptMsgs[decryptedMsgData.metamaskId]
-        return resolve(decryptedMsgData)
+    return decryptedMsgData
-      })
-    })
   }
 }
 
 export function decryptMsg (decryptedMsgData) {
   log.debug('action - decryptMsg')
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.decryptMessage`)
-      background.decryptMessage(decryptedMsgData, (err, newState) => {
+
-        log.debug('decryptMsg called back')
+    let newState
+    try {
+      newState = await promisifiedBackground.decryptMessage(decryptedMsgData)
+    } catch (error) {
       dispatch(hideLoadingIndication())
-
+      log.error(error)
-        if (err) {
+      dispatch(displayWarning(error.message))
-          log.error(err)
+      throw error
-          dispatch(displayWarning(err.message))
-          return reject(err)
     }
-
+    dispatch(hideLoadingIndication())
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(decryptedMsgData.metamaskId))
     dispatch(closeCurrentNotificationWindow())
-        console.log(decryptedMsgData)
+    return decryptedMsgData
-        return resolve(decryptedMsgData)
-      })
-    })
   }
 }
 
 export function encryptionPublicKeyMsg (msgData) {
   log.debug('action - encryptionPublicKeyMsg')
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.encryptionPublicKey`)
-      background.encryptionPublicKey(msgData, (err, newState) => {
+
-        log.debug('encryptionPublicKeyMsg called back')
+    let newState
+    try {
+      newState = await promisifiedBackground.encryptionPublicKey(msgData)
+    } catch (error) {
       dispatch(hideLoadingIndication())
-
+      log.error(error)
-        if (err) {
+      dispatch(displayWarning(error.message))
-          log.error(err)
+      throw error
-          dispatch(displayWarning(err.message))
-          return reject(err)
     }
-
+    dispatch(hideLoadingIndication())
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(msgData.metamaskId))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function signTypedMsg (msgData) {
   log.debug('action - signTypedMsg')
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
     log.debug(`actions calling background.signTypedMessage`)
-      background.signTypedMessage(msgData, (err, newState) => {
+
-        log.debug('signTypedMessage called back')
+    let newState
+    try {
+      newState = await promisifiedBackground.signTypedMessage(msgData)
+    } catch (error) {
       dispatch(hideLoadingIndication())
-
+      log.error(error)
-        if (err) {
+      dispatch(displayWarning(error.message))
-          log.error(err)
+      throw error
-          dispatch(displayWarning(err.message))
-          return reject(err)
     }
-
+    dispatch(hideLoadingIndication())
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(msgData.metamaskId))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
@@ -890,111 +871,87 @@ export function txError (err) {
 }
 
 export function cancelMsg (msgData) {
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      background.cancelMessage(msgData.id, (err, newState) => {
+    let newState
+    try {
+      newState = await promisifiedBackground.cancelMessage(msgData.id)
+    } finally {
       dispatch(hideLoadingIndication())
-
-        if (err) {
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
     dispatch(completedTx(msgData.id))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function cancelPersonalMsg (msgData) {
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      const id = msgData.id
+    let newState
-      background.cancelPersonalMessage(id, (err, newState) => {
+    try {
+      newState = await promisifiedBackground.cancelPersonalMessage(msgData.id)
+    } finally {
       dispatch(hideLoadingIndication())
-
-        if (err) {
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
-        dispatch(completedTx(id))
+    dispatch(completedTx(msgData.id))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function cancelDecryptMsg (msgData) {
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      const id = msgData.id
+    let newState
-      background.cancelDecryptMessage(id, (err, newState) => {
+    try {
+      newState = await promisifiedBackground.cancelDecryptMessage(msgData.id)
+    } finally {
       dispatch(hideLoadingIndication())
-
-        if (err) {
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
-        dispatch(completedTx(id))
+    dispatch(completedTx(msgData.id))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function cancelEncryptionPublicKeyMsg (msgData) {
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      const id = msgData.id
+    let newState
-      background.cancelEncryptionPublicKey(id, (err, newState) => {
+    try {
+      newState = await promisifiedBackground.cancelEncryptionPublicKey(msgData.id)
+    } finally {
       dispatch(hideLoadingIndication())
-
-        if (err) {
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
-        dispatch(completedTx(id))
+    dispatch(completedTx(msgData.id))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }
 
 export function cancelTypedMsg (msgData) {
-  return (dispatch) => {
+  return async (dispatch) => {
     dispatch(showLoadingIndication())
-    return new Promise((resolve, reject) => {
+
-      const id = msgData.id
+    let newState
-      background.cancelTypedMessage(id, (err, newState) => {
+    try {
+      newState = await promisifiedBackground.cancelTypedMessage(msgData.id)
+    } finally {
       dispatch(hideLoadingIndication())
-
-        if (err) {
-          return reject(err)
     }
-
     dispatch(updateMetamaskState(newState))
-        dispatch(completedTx(id))
+    dispatch(completedTx(msgData.id))
     dispatch(closeCurrentNotificationWindow())
-
+    return msgData
-        return resolve(msgData)
-      })
-    })
   }
 }