diff --git a/app/components/Panel/FullHeightPanel/FullHeightPanel.jsx b/app/components/Panel/FullHeightPanel/FullHeightPanel.jsx
index e80a5517c..552317e08 100644
--- a/app/components/Panel/FullHeightPanel/FullHeightPanel.jsx
+++ b/app/components/Panel/FullHeightPanel/FullHeightPanel.jsx
@@ -97,8 +97,7 @@ export default class ViewLayout extends Component<Props> {
     return (
       renderInstructions && (
         <div className={classNames(styles.instructions, instructionsClassName)}>
-          {' '}
-          {renderInstructions()}{' '}
+          {renderInstructions()}
         </div>
       )
     )
diff --git a/app/components/Settings/EncryptForm/EncryptForm.jsx b/app/components/Settings/EncryptForm/EncryptForm.jsx
index 6fba86d9c..3d9ba73d3 100644
--- a/app/components/Settings/EncryptForm/EncryptForm.jsx
+++ b/app/components/Settings/EncryptForm/EncryptForm.jsx
@@ -1,7 +1,8 @@
 // @flow
-import React from 'react'
-import { noop } from 'lodash-es'
-import { FormattedMessage, intlShape } from 'react-intl'
+import React, { useState, useEffect } from 'react'
+import { useIntl } from 'react-intl'
+import { wallet } from '@cityofzion/neon-js'
+import { wallet as n3Wallet } from '@cityofzion/neon-js-next'
 
 import Button from '../../Button'
 import TextInput from '../../Inputs/TextInput'
@@ -11,197 +12,145 @@ import styles from './EncryptForm.scss'
 import { MIN_PASSPHRASE_LEN } from '../../../core/wallet'
 
 type Props = {
-  submitLabel: string,
-  formPrivateKey: string,
-  formPassphrase: string,
-  formConfirmPassphrase: string,
-  validatePassphraseLength: Function,
-  isWIF: Function,
-  onSubmit: Function,
-  intl: intlShape,
+  validatePassphraseLength(text: string): void,
+  setEncryptedWIF(encryptedWif: string): void,
+  chain: string,
 }
 
-type State = {
-  privateKeyError: string,
-  passphraseError: string,
-  confirmPassphraseError: string,
-  isDisabled: boolean,
-  privateKey: string,
-  passphrase: string,
-  confirmPassphrase: string,
-}
+const EncryptForm = ({
+  chain,
+  validatePassphraseLength,
+  setEncryptedWIF,
+}: Props) => {
+  const intl = useIntl()
 
-export default class EncryptForm extends React.Component<Props, State> {
-  constructor(props: Props) {
-    super(props)
-
-    this.state = {
-      privateKeyError: '',
-      passphraseError: '',
-      confirmPassphraseError: '',
-      isDisabled: false,
-      privateKey: '',
-      passphrase: '',
-      confirmPassphrase: '',
-    }
-  }
+  const [privateKey, setPrivateKey] = useState('')
+  const [passphrase, setPassphrase] = useState('')
+  const [confirmPassphrase, setConfirmPassphrase] = useState('')
+  const [privateKeyError, setPrivateKeyError] = useState('')
+  const [passphraseError, setPassphraseError] = useState('')
+  const [confirmPassphraseError, setConfirmPassphraseError] = useState('')
+  const [isDisabled, setIsDisabled] = useState(true)
 
-  static defaultProps = {
-    submitLabel: 'Generate Encrypted key',
-    onSubmit: noop,
-    isWIF: noop,
-    validatePassphraseLength: noop,
-  }
+  const validatePrivateKey = () => {
+    const isWIF = chain === 'neo3' ? n3Wallet.isWIF : wallet.isWIF
 
-  render() {
-    const {
-      submitLabel,
-      formPrivateKey,
-      formPassphrase,
-      formConfirmPassphrase,
-      intl,
-    } = this.props
-    const {
-      privateKeyError,
-      passphraseError,
-      confirmPassphraseError,
-      isDisabled,
-    } = this.state
-
-    return (
-      <section className={styles.formContainer}>
-        <form className={styles.encryptForm} onSubmit={this.handleSubmit}>
-          <TextInput
-            id="privateKey"
-            name="privateKey"
-            label={<FormattedMessage id="encryptStep1Label" />}
-            placeholder={intl.formatMessage({ id: 'encryptStep1Placeholder' })}
-            value={formPrivateKey}
-            onChange={this.handleChangePrivateKey}
-            error={privateKeyError}
-          />
-          <PasswordInput
-            id="passphrase"
-            name="passphrase"
-            label={<FormattedMessage id="encryptStep2Label" />}
-            placeholder={intl.formatMessage({ id: 'encryptStep2Placeholder' })}
-            value={formPassphrase}
-            onChange={this.handleChangePassphrase}
-            error={passphraseError}
-          />
-          <PasswordInput
-            id="confirmPassphrase"
-            name="confirmPassphrase"
-            label={<FormattedMessage id="encryptStep3Label" />}
-            placeholder={intl.formatMessage({ id: 'encryptStep3Placeholder' })}
-            value={formConfirmPassphrase}
-            onChange={this.handleChangeConfirmPassphrase}
-            error={confirmPassphraseError}
-          />
-          <Button
-            className={styles.submitButton}
-            primary
-            type="submit"
-            renderIcon={AddIcon}
-            disabled={isDisabled}
-          >
-            {submitLabel}
-          </Button>
-        </form>
-      </section>
-    )
-  }
-
-  validatePrivateKey = (privateKey: string) => {
-    const { isWIF, intl } = this.props
     if (privateKey && !isWIF(privateKey)) {
-      this.setState({
-        privateKeyError: intl.formatMessage({ id: 'errors.encrypt.valid' }),
-      })
+      setPrivateKeyError(intl.formatMessage({ id: 'errors.encrypt.valid' }))
+
       return false
     }
+
     return true
   }
 
-  validatePassphrase = (passphrase: string, confirmPassphrase: string) => {
-    const { validatePassphraseLength, intl } = this.props
-    if (passphrase !== confirmPassphrase) {
-      this.setState({
-        passphraseError: intl.formatMessage({ id: 'errors.password.match' }),
-      })
-      return false
-    }
-
+  const validatePassphrase = () => {
     if (!validatePassphraseLength(passphrase)) {
-      this.setState({
-        passphraseError: intl.formatMessage(
+      setPassphraseError(
+        intl.formatMessage(
           { id: 'errors.password.length' },
           { MIN_PASSPHRASE_LEN },
         ),
-      })
+      )
       return false
     }
-    return true
-  }
 
-  validate = (
-    privateKey: string,
-    passphrase: string,
-    confirmPassphrase: string,
-  ) => {
-    const validPrivateKey = this.validatePrivateKey(privateKey)
-    const validatePassphrase = this.validatePassphrase(
-      passphrase,
-      confirmPassphrase,
-    )
-
-    return validPrivateKey && validatePassphrase
+    return true
   }
 
-  clearErrors = (name: string) => {
-    if (name === 'passphrase' || name === 'confirmPassphrase') {
-      this.setState({ passphraseError: '' })
-      this.setState({ confirmPassphraseError: '' })
-    } else if (name === 'privateKey') {
-      this.setState({ privateKeyError: '' })
+  const validateConfirmPassphrase = () => {
+    if (passphrase !== confirmPassphrase) {
+      setConfirmPassphraseError(
+        intl.formatMessage({ id: 'errors.password.match' }),
+      )
+      return false
     }
-  }
 
-  setButtonIsDisabled = () => {
-    const { privateKey, passphrase, confirmPassphrase } = this.state
-    this.setState({
-      isDisabled: !privateKey || !passphrase || !confirmPassphrase,
-    })
+    return true
   }
 
-  handleChangePrivateKey = (event: Object) => {
-    this.setState({ privateKey: event.target.value })
-    this.clearErrors(event.target.name)
-    this.setButtonIsDisabled()
-  }
+  const handleSubmit = async event => {
+    event.preventDefault()
 
-  handleChangePassphrase = (event: Object) => {
-    this.setState({ passphrase: event.target.value })
-    this.clearErrors(event.target.name)
-    this.setButtonIsDisabled()
-  }
+    const privateKeyIsValid = validatePrivateKey()
+    const passphraseisValid = validatePassphrase()
+    const confirmPassphraseIsValid = validateConfirmPassphrase()
 
-  handleChangeConfirmPassphrase = (event: Object) => {
-    this.setState({ confirmPassphrase: event.target.value })
-    this.clearErrors(event.target.name)
-    this.setButtonIsDisabled()
-  }
+    if (!privateKeyIsValid || !passphraseisValid || !confirmPassphraseIsValid)
+      return
 
-  handleSubmit = (event: Object) => {
-    event.preventDefault()
-    const { onSubmit } = this.props
-    const { privateKey, passphrase, confirmPassphrase } = this.state
-
-    const validInput = this.validate(privateKey, passphrase, confirmPassphrase)
-    if (validInput) {
-      this.setState({ isDisabled: true })
-      onSubmit(privateKey, passphrase, confirmPassphrase)
-      this.setState({ isDisabled: false })
-    }
+    const encryptedWIF =
+      chain === 'neo3'
+        ? await n3Wallet.encrypt(privateKey, passphrase)
+        : wallet.encrypt(privateKey, passphrase)
+
+    setEncryptedWIF(encryptedWIF)
   }
+
+  useEffect(
+    () => {
+      setIsDisabled(!privateKey || !passphrase || !confirmPassphrase)
+    },
+    [privateKey, passphrase, confirmPassphrase],
+  )
+
+  useEffect(
+    () => {
+      setPassphraseError('')
+      setConfirmPassphraseError('')
+    },
+    [passphrase, confirmPassphrase],
+  )
+
+  useEffect(
+    () => {
+      setPrivateKeyError('')
+    },
+    [privateKey],
+  )
+
+  return (
+    <section className={styles.formContainer}>
+      <form className={styles.encryptForm} onSubmit={handleSubmit}>
+        <TextInput
+          id="privateKey"
+          name="privateKey"
+          label={intl.formatMessage({ id: 'encryptStep1Label' })}
+          placeholder={intl.formatMessage({ id: 'encryptStep1Placeholder' })}
+          value={privateKey}
+          onChange={event => setPrivateKey(event.target.value)}
+          error={privateKeyError}
+        />
+        <PasswordInput
+          id="passphrase"
+          name="passphrase"
+          label={intl.formatMessage({ id: 'encryptStep2Label' })}
+          placeholder={intl.formatMessage({ id: 'encryptStep2Placeholder' })}
+          value={passphrase}
+          onChange={event => setPassphrase(event.target.value)}
+          error={passphraseError}
+        />
+        <PasswordInput
+          id="confirmPassphrase"
+          name="confirmPassphrase"
+          label={intl.formatMessage({ id: 'encryptStep3Label' })}
+          placeholder={intl.formatMessage({ id: 'encryptStep3Placeholder' })}
+          value={confirmPassphrase}
+          onChange={event => setConfirmPassphrase(event.target.value)}
+          error={confirmPassphraseError}
+        />
+        <Button
+          className={styles.submitButton}
+          primary
+          type="submit"
+          renderIcon={AddIcon}
+          disabled={isDisabled}
+        >
+          {intl.formatMessage({ id: 'encryptButton' })}
+        </Button>
+      </form>
+    </section>
+  )
 }
+
+export default EncryptForm
diff --git a/app/components/Settings/EncryptForm/index.js b/app/components/Settings/EncryptForm/index.js
index 64087281c..b717dcddf 100644
--- a/app/components/Settings/EncryptForm/index.js
+++ b/app/components/Settings/EncryptForm/index.js
@@ -1,4 +1,25 @@
-import { injectIntl } from 'react-intl'
+import { compose, withProps } from 'recompose'
+import { bindActionCreators } from 'redux'
+import { connect } from 'react-redux'
+import withChainData from '../../../hocs/withChainData'
 import EncryptForm from './EncryptForm'
+import { setEncryptedWIF } from '../../../modules/generateEncryptedWIF'
+import { validatePassphraseLength } from '../../../core/wallet'
 
-export default injectIntl(EncryptForm)
+const actionCreators = {
+  setEncryptedWIF,
+}
+
+const mapDispatchToProps = dispatch =>
+  bindActionCreators(actionCreators, dispatch)
+
+export default compose(
+  connect(
+    null,
+    mapDispatchToProps,
+  ),
+  withChainData(),
+  withProps({
+    validatePassphraseLength,
+  }),
+)(EncryptForm)
diff --git a/app/components/Settings/EncryptPanel/EncryptPanel.jsx b/app/components/Settings/EncryptPanel/EncryptPanel.jsx
deleted file mode 100644
index f47f37657..000000000
--- a/app/components/Settings/EncryptPanel/EncryptPanel.jsx
+++ /dev/null
@@ -1,109 +0,0 @@
-// @flow
-import React from 'react'
-import classNames from 'classnames'
-import { FormattedMessage } from 'react-intl'
-
-import { ROUTES } from '../../../core/constants'
-import FullHeightPanel from '../../Panel/FullHeightPanel'
-import EncryptForm from '../EncryptForm'
-import EncryptSuccess from '../EncryptSuccess'
-import LockIcon from '../../../assets/icons/lock.svg'
-import CloseButton from '../../CloseButton'
-import styles from './EncryptPanel.scss'
-
-type Props = {
-  handleSubmit: Function,
-  handleN3Submit: Function,
-  validatePassphraseLength: Function,
-  isWIF: Function,
-  className: string,
-  title: string,
-  resetEncryptedWIF: Function,
-  encryptedWIF: string,
-  chain: string,
-  n3Key: string,
-}
-
-export default class EncryptPanel extends React.Component<Props> {
-  componentWillUnmount() {
-    const { resetEncryptedWIF } = this.props
-    resetEncryptedWIF()
-  }
-
-  render() {
-    const { className, resetEncryptedWIF, encryptedWIF, n3Key } = this.props
-
-    return (
-      <FormattedMessage id="encryptPanelHeader">
-        {t => (
-          <FullHeightPanel
-            className={classNames(styles.encryptPanel, className)}
-            renderHeader={this.renderHeader}
-            headerText={t}
-            renderCloseButton={() => <CloseButton routeTo={ROUTES.SETTINGS} />}
-            renderHeaderIcon={this.renderIcon}
-            renderInstructions={this.renderInstructions}
-          >
-            {this.renderPanelContent(encryptedWIF || n3Key, resetEncryptedWIF)}
-          </FullHeightPanel>
-        )}
-      </FormattedMessage>
-    )
-  }
-
-  renderHeader = () => <span>{this.props.title}</span>
-
-  renderInstructions = (encryptedWIF: string) => {
-    if (!encryptedWIF) {
-      return (
-        <div>
-          <FormattedMessage id="encryptInstructions" />
-        </div>
-      )
-    }
-    return null
-  }
-
-  renderPanelContent = (encryptedWIF: string, resetEncryptedWIF: Function) => {
-    if (!encryptedWIF) {
-      return (
-        <FormattedMessage id="encryptButton">
-          {t => (
-            <EncryptForm
-              submitLabel={t}
-              onSubmit={this.onSubmit}
-              encryptPrivateKey={encryptedWIF}
-              isWIF={this.props.isWIF}
-              validatePassphraseLength={this.props.validatePassphraseLength}
-            />
-          )}
-        </FormattedMessage>
-      )
-    }
-    return (
-      <EncryptSuccess
-        encryptedKey={encryptedWIF}
-        handleReset={resetEncryptedWIF}
-      />
-    )
-  }
-
-  renderIcon = () => (
-    <div>
-      <LockIcon />
-    </div>
-  )
-
-  onSubmit = (
-    privateKey: string,
-    passphrase: string,
-    confirmPassphrase: string,
-  ) => {
-    const { handleSubmit, chain, handleN3Submit } = this.props
-    if (chain === 'neo3') {
-      handleN3Submit(privateKey, passphrase, confirmPassphrase)
-    } else {
-      handleSubmit(privateKey, passphrase, confirmPassphrase)
-    }
-  }
-}
diff --git a/app/components/Settings/EncryptPanel/EncryptPanel.scss b/app/components/Settings/EncryptPanel/EncryptPanel.scss
deleted file mode 100644
index 9fc2b3088..000000000
--- a/app/components/Settings/EncryptPanel/EncryptPanel.scss
+++ /dev/null
@@ -1,9 +0,0 @@
-.encryptPanel {
-  display: flex;
-  justify-content: center;
-
-  .privateKeyInstruction {
-    text-align: center;
-    color: #5c677f;
-  }
-}
diff --git a/app/components/Settings/EncryptPanel/index.js b/app/components/Settings/EncryptPanel/index.js
deleted file mode 100644
index c7047d2f5..000000000
--- a/app/components/Settings/EncryptPanel/index.js
+++ /dev/null
@@ -1,29 +0,0 @@
-// @flow
-import { connect } from 'react-redux'
-import { compose } from 'recompose'
-import { bindActionCreators } from 'redux'
-import withChainData from '../../../hocs/withChainData'
-import {
-  getEncryptedWIF,
-  resetEncryptedWIF,
-} from '../../../modules/generateEncryptedWIF'
-import EncryptPanel from './EncryptPanel'
-
-const mapStateToProps = (state: Object) => ({
-  encryptedWIF: getEncryptedWIF(state),
-})
-
-const actionCreators = {
-  resetEncryptedWIF,
-}
-
-const mapDispatchToProps = dispatch =>
-  bindActionCreators(actionCreators, dispatch)
-
-export default compose(
-  connect(
-    mapStateToProps,
-    mapDispatchToProps,
-  ),
-  withChainData(),
-)(EncryptPanel)
diff --git a/app/components/Settings/EncryptQR/index.js b/app/components/Settings/EncryptQR/index.js
index 94f420549..477af8c0a 100644
--- a/app/components/Settings/EncryptQR/index.js
+++ b/app/components/Settings/EncryptQR/index.js
@@ -8,7 +8,7 @@ import {
 } from '../../../modules/generateEncryptedWIF'
 import EncryptQR from './EncryptQR'
 
-const mapStateToProps = (state: Object) => ({
+const mapStateToProps = state => ({
   encryptedWIF: getEncryptedWIF(state),
 })
 
diff --git a/app/components/Settings/EncryptSuccess/EncryptSuccess.jsx b/app/components/Settings/EncryptSuccess/EncryptSuccess.jsx
index 22fac06cf..1d724a25d 100644
--- a/app/components/Settings/EncryptSuccess/EncryptSuccess.jsx
+++ b/app/components/Settings/EncryptSuccess/EncryptSuccess.jsx
@@ -13,16 +13,12 @@ import styles from './EncryptSuccess.scss'
 
 type Props = {
   encryptedKey: string,
-  handleReset: Function,
+  resetEncryptedWIF: Function,
 }
 
 export default class EncryptSuccess extends React.Component<Props> {
-  static defaultProps = {
-    handleReset: noop,
-  }
-
   render() {
-    const { encryptedKey, handleReset } = this.props
+    const { encryptedKey, resetEncryptedWIF } = this.props
 
     return (
       <section>
@@ -51,7 +47,7 @@ export default class EncryptSuccess extends React.Component<Props> {
               exact
               to={ROUTES.DISPLAY_ENCRYPTED_WIF_QR}
             >
-              <Button primary renderIcon={() => <GridIcon />} type="submit">
+              <Button primary renderIcon={() => <GridIcon />}>
                 Generate QR Code
               </Button>
             </NavLink>
@@ -59,7 +55,7 @@ export default class EncryptSuccess extends React.Component<Props> {
 
           <Button
             className={styles.encryptResetButton}
-            onClick={handleReset}
+            onClick={resetEncryptedWIF}
             primary
             renderIcon={LockIcon}
           >
diff --git a/app/components/Settings/EncryptSuccess/index.js b/app/components/Settings/EncryptSuccess/index.js
index ca2f054ab..db49edaf0 100644
--- a/app/components/Settings/EncryptSuccess/index.js
+++ b/app/components/Settings/EncryptSuccess/index.js
@@ -1 +1,27 @@
-export { default } from './EncryptSuccess'
+// @flow
+import { connect } from 'react-redux'
+import { compose } from 'recompose'
+import { bindActionCreators } from 'redux'
+import {
+  getEncryptedWIF,
+  resetEncryptedWIF,
+} from '../../../modules/generateEncryptedWIF'
+import EncryptSuccess from './EncryptSuccess'
+
+const mapStateToProps = (state: Object) => ({
+  encryptedWIF: getEncryptedWIF(state),
+})
+
+const actionCreators = {
+  resetEncryptedWIF,
+}
+
+const mapDispatchToProps = dispatch =>
+  bindActionCreators(actionCreators, dispatch)
+
+export default compose(
+  connect(
+    mapStateToProps,
+    mapDispatchToProps,
+  ),
+)(EncryptSuccess)
diff --git a/app/containers/Encrypt/Encrypt.jsx b/app/containers/Encrypt/Encrypt.jsx
index e24fbb8f5..23eb6f8de 100644
--- a/app/containers/Encrypt/Encrypt.jsx
+++ b/app/containers/Encrypt/Encrypt.jsx
@@ -1,61 +1,50 @@
 // @flow
 import React from 'react'
-import { noop } from 'lodash-es'
-import { wallet } from '@cityofzion/neon-js'
-import { wallet as n3Wallet } from '@cityofzion/neon-js-next'
+import { useIntl } from 'react-intl'
 
-import EncryptPanel from '../../components/Settings/EncryptPanel'
+import { ROUTES } from '../../core/constants'
+import FullHeightPanel from '../../components/Panel/FullHeightPanel'
+import EncryptForm from '../../components/Settings/EncryptForm'
+import EncryptSuccess from '../../components/Settings/EncryptSuccess'
 import LockIcon from '../../assets/icons/lock.svg'
+import CloseButton from '../../components/CloseButton'
 import styles from './Encrypt.scss'
 
 type Props = {
-  generateNewEncryptedWIF: Function,
-  validatePassphraseLength: Function,
-  chain: string,
+  resetEncryptedWIF(): void,
+  encryptedWIF: string,
 }
 
-type State = {
-  n3Key: string,
-}
-
-export default class Encrypt extends React.Component<Props, State> {
-  static defaultProps = {
-    validatePassphraseLength: noop,
-    isWIF: noop,
-  }
-
-  state = {
-    n3Key: '',
-  }
-
-  generateNewN3EncryptedWif = async (wif: string, passphrase: string) => {
-    const n3Key = await n3Wallet.encrypt(wif, passphrase)
-    this.setState({ n3Key })
-  }
-
-  render = () => {
-    const {
-      generateNewEncryptedWIF,
-      validatePassphraseLength,
-      chain,
-    } = this.props
-    return (
-      <div className={styles.encrypt}>
-        <EncryptPanel
-          title="Encrypt Private Key"
-          handleSubmit={generateNewEncryptedWIF}
-          handleN3Submit={this.generateNewN3EncryptedWif}
-          isWIF={chain === 'neo3' ? n3Wallet.isWIF : wallet.isWIF}
-          validatePassphraseLength={validatePassphraseLength}
-          n3Key={this.state.n3Key}
-        />
-      </div>
-    )
-  }
-
-  renderIcon = () => (
-    <div>
-      <LockIcon />
-    </div>
+const HeaderIcon = () => (
+  <div>
+    <LockIcon />
+  </div>
+)
+
+const Encrypt = ({ encryptedWIF, resetEncryptedWIF }: Props) => {
+  const intl = useIntl()
+
+  return (
+    <FullHeightPanel
+      className={styles.encrypt}
+      headerText={intl.formatMessage({ id: 'encryptPanelHeader' })}
+      renderCloseButton={() => (
+        <CloseButton onClick={resetEncryptedWIF} routeTo={ROUTES.SETTINGS} />
+      )}
+      renderHeaderIcon={HeaderIcon}
+      renderInstructions={
+        encryptedWIF
+          ? () => intl.formatMessage({ id: 'encryptInstructions' })
+          : undefined
+      }
+    >
+      {!encryptedWIF ? (
+        <EncryptForm />
+      ) : (
+        <EncryptSuccess encryptedKey={encryptedWIF} />
+      )}
+    </FullHeightPanel>
   )
 }
+
+export default Encrypt
diff --git a/app/containers/Encrypt/index.js b/app/containers/Encrypt/index.js
index 480439630..a21a1284a 100644
--- a/app/containers/Encrypt/index.js
+++ b/app/containers/Encrypt/index.js
@@ -1,27 +1,27 @@
 // @flow
 import { connect } from 'react-redux'
 import { bindActionCreators } from 'redux'
-import { compose, withProps } from 'recompose'
-import { wallet } from '@cityofzion/neon-js'
-import { validatePassphraseLength } from '../../core/wallet'
-import { generateNewEncryptedWIF } from '../../modules/generateEncryptedWIF'
+import { compose } from 'recompose'
+import {
+  getEncryptedWIF,
+  resetEncryptedWIF,
+} from '../../modules/generateEncryptedWIF'
 import Encrypt from './Encrypt'
-import withChainData from '../../hocs/withChainData'
 
 const actionCreators = {
-  generateNewEncryptedWIF,
+  resetEncryptedWIF,
 }
 
+const mapStateToProps = state => ({
+  encryptedWIF: getEncryptedWIF(state),
+})
+
 const mapDispatchToProps = dispatch =>
   bindActionCreators(actionCreators, dispatch)
 
 export default compose(
   connect(
-    null,
+    mapStateToProps,
     mapDispatchToProps,
   ),
-  withChainData(),
-  withProps({
-    validatePassphraseLength,
-  }),
 )(Encrypt)
diff --git a/app/hocs/withCopyCanvasToClipboard.js b/app/hocs/withCopyCanvasToClipboard.js
index 5b7d12e45..a845c19a1 100644
--- a/app/hocs/withCopyCanvasToClipboard.js
+++ b/app/hocs/withCopyCanvasToClipboard.js
@@ -2,7 +2,7 @@
 import React from 'react'
 
 import QRCode from 'qrcode/lib/browser'
-import { clipboard } from 'electron'
+import { clipboard, ipcRenderer } from 'electron'
 import fs from 'fs'
 import storage from 'electron-json-storage'
 
@@ -45,7 +45,7 @@ export default function withCopyCanvasToClipboard(Component) {
       // $FlowFixMe
       const url = ref.toDataURL('image/jpg', 0.8)
       const base64Data = url.replace(/^data:image\/png;base64,/, '')
-      const storagePath = storage.getDefaultDataPath()
+      const storagePath = storage.getDataPath()
       await writeFile(`${storagePath}/${fileName}.jpg`, base64Data, 'base64')
       clipboard.writeImage(`${storagePath}/${fileName}.jpg`)
     }
diff --git a/app/modules/generateEncryptedWIF.js b/app/modules/generateEncryptedWIF.js
index 5c17e2654..7a28487a3 100644
--- a/app/modules/generateEncryptedWIF.js
+++ b/app/modules/generateEncryptedWIF.js
@@ -1,32 +1,12 @@
-// @flow
-import { wallet } from '@cityofzion/neon-js'
-import { validatePassphraseLength } from '../core/wallet'
-
 // Constants
+// @flow
 export const NEW_ENCRYPTED_WIF = 'NEW_ENCRYPTED_WIF'
 export const RESET_ENCRYPTED_WIF = 'RESET_ENCRYPTED_WIF'
 
-export const generateNewEncryptedWIF = (
-  wif: string,
-  passphrase: string,
-  confirmPassphrase: string,
-) => {
-  if (passphrase !== confirmPassphrase) {
-    throw new Error('Passphrases do not match')
-  }
-  if (!validatePassphraseLength(passphrase)) {
-    throw new Error('Please choose a longer passphrase')
-  }
-  if (wif && !wallet.isWIF(wif)) {
-    throw new Error('The private key is not valid')
-  }
-
-  const encryptedWIF = wallet.encrypt(wif, passphrase)
-  return {
-    type: NEW_ENCRYPTED_WIF,
-    payload: { encryptedWIF },
-  }
-}
+export const setEncryptedWIF = (encryptedWIF: string) => ({
+  type: NEW_ENCRYPTED_WIF,
+  payload: { encryptedWIF },
+})
 
 export function resetEncryptedWIF() {
   return {
diff --git a/app/translations/portuguese.js b/app/translations/portuguese.js
index 05e7fd4cb..e95db49b5 100644
--- a/app/translations/portuguese.js
+++ b/app/translations/portuguese.js
@@ -94,7 +94,8 @@ const MISCELLANEOUS = {
 
   noClaimableGas: 'O endereço não possui GAS claimable',
   claimTimeDisclaimer: 'Você pode reivindicar o GAS uma vez a cada 5 minutos',
-  claimFeeDisclaimerN3: 'Reivindicar GAS requer pelo menos 0,01120527 GAS para taxas de transação',
+  claimFeeDisclaimerN3:
+    'Reivindicar GAS requer pelo menos 0,01120527 GAS para taxas de transação',
   claimFeeGreater: 'Claimable GAS é menor do que as taxas de transação',
   claimUnavailableInWatch:
     'As reivindicações de GAS não estão disponíveis neste modo',