diff --git a/.eslintrc b/.eslintrc
index 7398fd8f225..684a3a6707b 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -24,6 +24,7 @@
     "@typescript-eslint/ban-ts-comment": "off",
     "@typescript-eslint/no-empty-function": "off",
     "consistent-return": "off",
+    "class-methods-use-this": "off",
     "func-names": "off",
     "no-console": ["error", { "allow": ["warn", "error"] }],
     "no-param-reassign": "off",
diff --git a/package.json b/package.json
index 3d8d5606a5d..618885fce13 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "blockchain-wallet-v4",
-  "version": "4.82.3",
+  "version": "4.82.5",
   "license": "AGPL-3.0-or-later",
   "private": true,
   "author": {
diff --git a/packages/blockchain-wallet-v4-frontend/src/assets/locales/en.json b/packages/blockchain-wallet-v4-frontend/src/assets/locales/en.json
index fd6f5fe4428..5348dfa0962 100644
--- a/packages/blockchain-wallet-v4-frontend/src/assets/locales/en.json
+++ b/packages/blockchain-wallet-v4-frontend/src/assets/locales/en.json
@@ -1016,7 +1016,6 @@
   "modals.active-rewards.withdrawal.total-balance-message": "Requesting a withdrawal from your Active Rewards Account will send your total balance to your Bitcoin Trading Account.",
   "modals.active-rewards.withdrawalrequested.activerewardsbutton": "Go to {coin} Active Rewards",
   "modals.active-rewards.withdrawalrequested.description": "Your withdrawal will be executed once this week's strategy is complete.",
-  "modals.active-rewards.withdrawalrequested.historybutton": "See Transfer Details",
   "modals.active-rewards.withdrawalrequested.title": "Withdrawal Requested",
   "modals.activeRewards.balancedropdown.button": "Show in {currency}",
   "modals.addbitcoinwallet.button": "Create New Bitcoin Wallet",
diff --git a/packages/blockchain-wallet-v4-frontend/src/components/Form/AmountFieldInput/index.tsx b/packages/blockchain-wallet-v4-frontend/src/components/Form/AmountFieldInput/index.tsx
index 76e7e92aa7c..38edcded113 100644
--- a/packages/blockchain-wallet-v4-frontend/src/components/Form/AmountFieldInput/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/components/Form/AmountFieldInput/index.tsx
@@ -6,6 +6,7 @@ import styled from 'styled-components'
 import Currencies from '@core/exchange/currencies'
 import { Icon, Text } from 'blockchain-info-components'
 import { AmountTextBox } from 'components/Exchange'
+import { useCoinConfig } from 'hooks'
 import { formatTextAmount } from 'services/forms'
 
 const AmountContainer = styled.div`
@@ -63,6 +64,8 @@ const AmountFieldInput: React.FC<Props> = ({
     return formatTextAmount(value, allValues && allValues.fix === 'FIAT')
   }
 
+  const { coinfig } = window.coins[coin || 'BTC']
+
   const resizeSymbol = (isFiat, inputNode, fontSizeRatio, fontSizeNumber) => {
     if (Number(fontSizeRatio) > 0) {
       setRatio(fontSizeRatio > 1 ? 1 : fontSizeRatio)
@@ -118,7 +121,7 @@ const AmountFieldInput: React.FC<Props> = ({
 
           {fix === 'CRYPTO' && (
             <Text size='56px' color={amountError ? 'red400' : 'textBlack'} weight={500}>
-              {coin}
+              {coinfig.displaySymbol}
             </Text>
           )}
           {showToggle ? (
@@ -144,7 +147,7 @@ const AmountFieldInput: React.FC<Props> = ({
               weight={500}
               data-e2e='sendQuoteAmount'
             >
-              {fix === 'FIAT' && coin} {quote} {fix === 'CRYPTO' && fiatCurrency}
+              {fix === 'FIAT' && coinfig.displaySymbol} {quote} {fix === 'CRYPTO' && fiatCurrency}
             </Text>
           </>
         ) : null}
diff --git a/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxCoinAddresses/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxCoinAddresses/selectors.ts
index 41ccf2501c5..42989b9986a 100644
--- a/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxCoinAddresses/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxCoinAddresses/selectors.ts
@@ -2,10 +2,10 @@
 import { concat, curry, reduce, sequence } from 'ramda'
 
 import { Exchange, Remote } from '@core'
-import { getBalance } from '@core/redux/data/coins/selectors'
 import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
 import { EarnAccountBalanceResponseType } from '@core/types'
 import { selectors } from 'data'
+import { getCoinNonCustodialBalance } from 'data/balances/selectors'
 
 export const getData = (
   state,
@@ -72,7 +72,7 @@ export const getData = (
   const toSelfCustodyDropdown = (balance) => [
     {
       label: buildSelfCustodyDisplay(balance),
-      value: { balance, label: 'Private Key', type: ADDRESS_TYPES.ACCOUNT }
+      value: { balance, coin, label: 'Private Key', type: ADDRESS_TYPES.ACCOUNT }
     }
   ]
   const toInterestDropdown = (account) =>
@@ -104,7 +104,9 @@ export const getData = (
           .map(toGroup('Custodial Wallet'))
       : Remote.of([]),
     includeSelfCustody
-      ? getBalance(coin, state).map(toSelfCustodyDropdown).map(toGroup('Private Key'))
+      ? getCoinNonCustodialBalance(coin)(state)
+          .map(toSelfCustodyDropdown)
+          .map(toGroup('Private Key'))
       : Remote.of([]),
     includeInterest
       ? selectors.components.interest
diff --git a/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxXlmAddresses/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxXlmAddresses/selectors.ts
index 6cce6eb201b..4dec860b460 100644
--- a/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxXlmAddresses/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/components/Form/SelectBoxXlmAddresses/selectors.ts
@@ -28,7 +28,7 @@ export const getData = (
     if (has('balance', wallet)) {
       const xlmDisplay = Exchange.displayCoinToCoin({
         coin: 'XLM',
-        value: wallet.balnace
+        value: wallet.balance
       })
       return `${wallet.label} (${xlmDisplay})`
     }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/actions.ts b/packages/blockchain-wallet-v4-frontend/src/data/actions.ts
index 5a7a06ffd10..4bcfafabf01 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/actions.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/actions.ts
@@ -13,6 +13,7 @@ import * as form from './form/actions'
 import { actions as goals } from './goals/slice'
 import { actions as logs } from './logs/slice'
 import * as middleware from './middleware/actions'
+import * as activities from './middleware/webSocket/activities/actions'
 import * as ws from './middleware/webSocket/coins/actions'
 import { actions as misc } from './misc/slice'
 import { actions as modals } from './modals/slice'
@@ -24,6 +25,7 @@ import { actions as signup } from './signup/slice'
 import * as wallet from './wallet/actions'
 
 export {
+  activities,
   alerts,
   analytics,
   auth,
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/auth/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/auth/sagas.ts
index 1f9cde6cc1e..c515bad62a4 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/auth/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/auth/sagas.ts
@@ -4,7 +4,9 @@ import { startSubmit, stopSubmit } from 'redux-form'
 import { all, call, fork, put, select, take } from 'redux-saga/effects'
 
 import { coreSelectors } from '@core'
+import { APIType } from '@core/network/api'
 import { CountryScope, WalletOptionsType } from '@core/types'
+import { sha256 } from '@core/walletCrypto'
 import { actions, actionTypes, selectors } from 'data'
 import { ClientErrorProperties } from 'data/analytics/types/errors'
 import { fetchBalances } from 'data/balances/sagas'
@@ -42,7 +44,7 @@ import {
   ProductAuthOptions
 } from './types'
 
-export default ({ api, coreSagas, networks }) => {
+export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; networks: any }) => {
   const logLocation = 'auth/sagas'
   const { createExchangeUser, createUser } = profileSagas({
     api,
@@ -242,6 +244,48 @@ export default ({ api, coreSagas, networks }) => {
     }
   }
 
+  const authWalletPubkeyService = function* ({
+    guid,
+    sharedKey
+  }: {
+    guid: string
+    sharedKey: string
+  }) {
+    try {
+      const sharedKeyHash = sha256(sharedKey).toString('hex')
+      const response = yield call(api.authWalletPubkeyService, { guid, sharedKeyHash })
+      return response.success
+    } catch (e) {
+      return false
+    }
+  }
+
+  const subscribeToUnifiedBalances = function* () {
+    const guid = yield select(selectors.core.wallet.getGuid)
+    const sharedKey = yield select(selectors.core.wallet.getSharedKey)
+
+    const guidHash = sha256(guid).toString('hex')
+    const sharedKeyHash = sha256(sharedKey).toString('hex')
+
+    const auth = yield call(authWalletPubkeyService, { guid, sharedKey })
+    if (!auth) return
+    try {
+      yield put(actions.core.data.coins.getSubscriptionsLoading())
+      const subscriptions: ReturnType<typeof api.getSubscriptions> = yield call(
+        api.getSubscriptions,
+        { guidHash, sharedKeyHash }
+      )
+      yield put(actions.core.data.coins.getSubscriptionsSuccess(subscriptions))
+      if (subscriptions.currencies.length === 0) {
+        yield put(actions.core.data.coins.initializeSubscriptions())
+      } else {
+        yield put(actions.core.data.coins.fetchUnifiedBalances())
+      }
+    } catch (e) {
+      yield put(actions.core.data.coins.getSubscriptionsFailure())
+    }
+  }
+
   const checkWalletDerivationsLegitimacy = function* () {
     const accounts = yield call(coreSagas.wallet.getAccountsWithIncompleteDerivations)
 
@@ -325,7 +369,6 @@ export default ({ api, coreSagas, networks }) => {
       yield call(coreSagas.kvStore.xlm.fetchMetadataXlm, askSecondPasswordEnhancer)
       yield call(coreSagas.kvStore.bch.fetchMetadataBch)
       yield call(coreSagas.data.xlm.fetchLedgerDetails)
-      yield call(coreSagas.data.xlm.fetchData)
 
       yield call(authNabu, firstLogin)
       if (product === ProductAuthOptions.EXCHANGE && (recovery || !firstLogin)) {
@@ -334,7 +377,7 @@ export default ({ api, coreSagas, networks }) => {
         )
       }
       const guid = yield select(selectors.core.wallet.getGuid)
-      if (firstLogin && !isAccountReset && !recovery) {
+      if (firstLogin && !isAccountReset && !recovery && country) {
         // create nabu user
         yield call(createUser)
         yield call(api.setUserInitialAddress, country, state)
@@ -390,6 +433,7 @@ export default ({ api, coreSagas, networks }) => {
       } else {
         yield put(actions.router.push('/home'))
       }
+      yield call(subscribeToUnifiedBalances)
       yield call(fetchBalances)
       yield call(saveGoals, firstLogin)
       // We run goals in accountResetSaga in this case
@@ -400,7 +444,8 @@ export default ({ api, coreSagas, networks }) => {
       yield call(upgradeAddressLabelsSaga)
       yield put(actions.auth.startLogoutTimer())
       yield call(startCoinWebsockets)
-
+      // TODO: temp, do we want this here?
+      yield put(actions.activities.startSocket())
       // store guid and email in cache for future login
       yield put(actions.cache.guidEntered(guid))
       if (email) {
@@ -521,6 +566,7 @@ export default ({ api, coreSagas, networks }) => {
         session,
         sharedKey
       })
+
       // Check which unification flow we're running
       // to determine what we want to do after authing user
       const magicLinkData: AuthMagicLink = yield select(S.getMagicLinkData)
@@ -548,6 +594,7 @@ export default ({ api, coreSagas, networks }) => {
           yield call(loginRoutineSaga, {})
           break
       }
+
       yield put(
         actions.analytics.trackEvent({
           key: Analytics.LOGIN_SIGNED_IN,
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/balances/sagas.js b/packages/blockchain-wallet-v4-frontend/src/data/balances/sagas.js
index 7b596d07479..590ff5ba882 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/balances/sagas.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/balances/sagas.js
@@ -1,5 +1,5 @@
 import { pathOr } from 'ramda'
-import { fork, join, put, select, take } from 'redux-saga/effects'
+import { put, select, take } from 'redux-saga/effects'
 
 import { Remote } from '@core'
 import { actions, actionTypes, selectors } from 'data'
@@ -10,49 +10,10 @@ export const balancePath = ['payload', 'info', 'final_balance']
 export const fetchBalances = function* () {
   yield put(actions.core.data.bch.fetchData())
   yield put(actions.core.data.btc.fetchData())
-  yield put(actions.core.data.xlm.fetchData())
   yield put(actions.core.data.eth.fetchData())
-  yield put(actions.core.data.eth.fetchErc20Data())
+  yield put(actions.core.data.coins.fetchUnifiedBalances())
   yield put(actions.components.refresh.refreshRates())
   yield put(actions.custodial.fetchRecentSwapTxs())
-  yield put(actions.core.data.coins.fetchData())
-}
-
-export const getEthBalance = function* () {
-  try {
-    const ethBalanceR = yield select(selectors.core.data.eth.getBalance)
-    if (!Remote.Success.is(ethBalanceR)) {
-      const ethData = yield take([
-        actionTypes.core.data.eth.FETCH_ETH_DATA_SUCCESS,
-        actionTypes.core.data.eth.FETCH_ETH_DATA_FAILURE
-      ])
-      return pathOr(0, balancePath, ethData)
-    }
-    return ethBalanceR.getOrElse(0)
-  } catch (e) {
-    yield put(actions.logs.logErrorMessage(logLocation, 'getEthBalance', e))
-  }
-}
-
-export const getErc20Balance = function* (token) {
-  try {
-    const erc20BalanceR = yield select(selectors.core.data.eth.getErc20Balance, token)
-    if (!Remote.Success.is(erc20BalanceR)) {
-      yield put(actions.core.data.eth.fetchErc20Data(token))
-      const erc20Data = yield take([
-        (action) =>
-          action.type === actionTypes.core.data.eth.FETCH_ERC20_TOKEN_DATA_SUCCESS &&
-          action.payload.token === token,
-        (action) =>
-          action.type === actionTypes.core.data.eth.FETCH_ERC20_TOKEN_DATA_FAILURE &&
-          action.payload.token === token
-      ])
-      return pathOr(0, balancePath, erc20Data)
-    }
-    return erc20BalanceR.getOrElse(0)
-  } catch (e) {
-    yield put(actions.logs.logErrorMessage(logLocation, 'getErc20Balance', e))
-  }
 }
 
 export const getBtcBalance = function* () {
@@ -86,29 +47,3 @@ export const getBchBalance = function* () {
     yield put(actions.logs.logErrorMessage(logLocation, 'getBchBalance', e))
   }
 }
-
-export const getXlmBalance = function* () {
-  try {
-    const xlmBalanceR = yield select(selectors.core.data.xlm.getTotalBalance)
-    if (!Remote.Success.is(xlmBalanceR)) {
-      const xlmData = yield take(actionTypes.core.data.xlm.FETCH_DATA_SUCCESS)
-      return pathOr(0, balancePath, xlmData)
-    }
-    return xlmBalanceR.getOrElse(0)
-  } catch (e) {
-    yield put(actions.logs.logErrorMessage(logLocation, 'getXlmBalance', e))
-  }
-}
-
-export const waitForAllBalances = function* () {
-  const btcT = yield fork(getBtcBalance)
-  const bchT = yield fork(getBchBalance)
-  const ethT = yield fork(getEthBalance)
-  const xlmT = yield fork(getXlmBalance)
-  const btc = yield join(btcT)
-  const bch = yield join(bchT)
-  const eth = yield join(ethT)
-  const xlm = yield join(xlmT)
-
-  return { bch, btc, eth, xlm }
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.ts
index f524d1cbbd4..3180ad4b8b1 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.ts
@@ -16,11 +16,10 @@
 
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import BigNumber from 'bignumber.js'
-import { add, curry, flatten, lift, map, pathOr, reduce, reject } from 'ramda'
+import { add, curry, lift, map, reject } from 'ramda'
 
 import { coreSelectors, Exchange, Remote } from '@core'
 import { fiatToString } from '@core/exchange/utils'
-import { getBalance } from '@core/redux/data/coins/selectors'
 import {
   BSBalancesType,
   BSBalanceType,
@@ -36,6 +35,7 @@ import {
   WalletFiatType
 } from '@core/types'
 import { createDeepEqualSelector } from '@core/utils'
+import { selectors } from 'data'
 import { PartialClientErrorProperties } from 'data/analytics/types/errors'
 import { DEFAULT_BS_BALANCE } from 'data/components/buySell/model'
 import { convertBaseToStandard } from 'data/components/exchange/services'
@@ -50,14 +50,6 @@ import {
 } from '../components/selectors'
 import * as custodialSelectors from '../custodial/selectors'
 import * as routerSelectors from '../router/selectors'
-// these selectors need to be external to this file to avoid hoisting/initialization errors
-import {
-  __getBchNonCustodialBalance,
-  __getBtcNonCustodialBalance,
-  __getErc20NonCustodialBalance,
-  __getEthNonCustodialBalance,
-  __getXlmNonCustodialBalance
-} from './selectors.utils'
 
 // these functions are private as denoted by the '__' prefix but must be at the top of this
 // file to avoid function hoisting issues. they also cannot be included in the external
@@ -216,31 +208,22 @@ export const getCoinTotalBalance = (
   coin: CoinType | FiatType
 ): ((state: RootState) => RemoteDataType<string, number>) => {
   switch (coin) {
-    case 'BCH':
-      return __getBchTotalBalance
-    case 'BTC':
-      return __getBtcTotalBalance
-    case 'ETH':
-      return __getEthTotalBalance
-    case 'XLM':
-      return __getXlmTotalBalance
     case 'EUR':
     case 'GBP':
     case 'USD':
     case 'ARS':
       return getFiatCurrencyBalance(coin)
     default:
-      switch (true) {
-        case coreSelectors.data.coins.getDynamicSelfCustodyCoins().includes(coin):
-          return __getDynamicSelfCustodyTotalBalance(coin)
-        case coreSelectors.data.coins.getCustodialCoins().includes(coin):
-          return getCoinCustodialBalance(coin)
-        case !!window.coins[coin].coinfig.type.erc20Address:
-          return __getErc20TotalBalance(coin)
-        default:
-          // coin not supported by wallet, just return 0 value
-          return () => Remote.Success(0)
-      }
+      return createDeepEqualSelector(
+        [getCoinNonCustodialBalance(coin), getCoinCustodialBalance(coin)],
+        (balancesR, custodialBalanceR) => {
+          const custodialBalance = custodialBalanceR.getOrElse(0)
+
+          return Remote.of(
+            new BigNumber(balancesR.getOrElse(new BigNumber(0))).plus(custodialBalance).toNumber()
+          )
+        }
+      )
   }
 }
 
@@ -359,19 +342,24 @@ export const getTotalWalletBalancesSorted = createDeepEqualSelector(
 export const getCoinNonCustodialBalance = (
   coin: CoinType
 ): ((state: RootState) => RemoteDataType<string, number | BigNumber>) => {
-  switch (true) {
-    case coin === 'BTC':
-      return __getBtcNonCustodialBalance
-    case coin === 'BCH':
-      return __getBchNonCustodialBalance
-    case coin === 'ETH':
-      return __getEthNonCustodialBalance
-    case coin === 'XLM':
-      return __getXlmNonCustodialBalance
-    case !!window.coins[coin].coinfig.type.erc20Address:
-      return __getErc20NonCustodialBalance(coin)
-    default:
-      throw Error(`Coin "${coin}" not supported by getCoinNonCustodialBalance`)
+  return (state: RootState) => {
+    return createDeepEqualSelector(
+      [selectors.core.data.coins.getUnifiedBalances],
+      (unifiedBalancesR) => {
+        let balance = new BigNumber(0)
+        const transform = (unifiedBalances: ExtractSuccess<typeof unifiedBalancesR>) => {
+          unifiedBalances
+            .filter(({ ticker }) => ticker === coin)
+            .forEach(({ amount }) => {
+              balance = balance.plus(amount ? amount.amount : 0)
+            })
+
+          return balance
+        }
+
+        return lift(transform)(unifiedBalancesR)
+      }
+    )(state)
   }
 }
 
@@ -388,103 +376,3 @@ export const getCoinBalancesTypeSeparated = (coin) =>
       ])
     }
   )
-
-//
-// INTERNAL SELECTORS, DO NOT USE OUTSIDE OF THIS FILE!
-//
-
-// returns BTC total balance
-const __getBtcTotalBalance = createDeepEqualSelector(
-  [
-    coreSelectors.wallet.getSpendableContext,
-    coreSelectors.data.btc.getAddresses,
-    getCoinCustodialBalance('BTC')
-  ],
-  (context, addressesR, custodialBalanceR) => {
-    const contextToBalances = (
-      context,
-      balances,
-      custodialBalance: ExtractSuccess<typeof custodialBalanceR>
-    ): Array<number> => {
-      const walletBalances: Array<number> = flatten(context).map((a) =>
-        pathOr(0, [a, 'final_balance'], balances)
-      )
-      return walletBalances.concat(custodialBalance)
-    }
-    const balancesR = lift(contextToBalances)(Remote.of(context), addressesR, custodialBalanceR)
-    return balancesR.map(reduce<number, number>(add, 0))
-  }
-)
-
-// returns BCH total balance
-const __getBchTotalBalance = createDeepEqualSelector(
-  [
-    coreSelectors.kvStore.bch.getSpendableContext,
-    coreSelectors.data.bch.getAddresses,
-    getCoinCustodialBalance('BCH')
-  ],
-  (context, addressesR, custodialBalanceR) => {
-    const contextToBalances = (
-      context,
-      balances,
-      custodialBalance: ExtractSuccess<typeof custodialBalanceR>
-    ) => {
-      const walletBalances: Array<number> = context.map((a) =>
-        pathOr(0, [a, 'final_balance'], balances)
-      )
-      return walletBalances.concat(custodialBalance)
-    }
-    const balancesR = lift(contextToBalances)(Remote.of(context), addressesR, custodialBalanceR)
-    return balancesR.map(reduce<number, number>(add, 0))
-  }
-)
-
-// returns ETH total balance
-const __getEthTotalBalance = createDeepEqualSelector(
-  [getCoinNonCustodialBalance('ETH'), getCoinCustodialBalance('ETH')],
-  (balancesR, custodialBalanceR) => {
-    const custodialBalance = custodialBalanceR.getOrElse(0)
-
-    return Remote.of(
-      new BigNumber(balancesR.getOrElse(new BigNumber(0))).plus(custodialBalance).toNumber()
-    )
-  }
-)
-
-// given an erc20 coin, returns its total balances
-const __getErc20TotalBalance = (coin: CoinType) =>
-  createDeepEqualSelector(
-    [getCoinNonCustodialBalance(coin), getCoinCustodialBalance(coin)],
-    (balanceR, custodialBalanceR) => {
-      const custodialBalance = custodialBalanceR.getOrElse(0)
-
-      return Remote.of(
-        new BigNumber(balanceR.getOrElse(new BigNumber(0))).plus(custodialBalance).toNumber()
-      )
-    }
-  )
-
-// returns XLM total balances
-const __getXlmTotalBalance = createDeepEqualSelector(
-  [getCoinNonCustodialBalance('XLM'), getCoinCustodialBalance('XLM')],
-  (balanceR, custodialBalanceR) => {
-    const custodialBalance = custodialBalanceR.getOrElse(0)
-
-    return Remote.of(
-      new BigNumber(balanceR.getOrElse(new BigNumber(0))).plus(custodialBalance).toNumber()
-    )
-  }
-)
-
-// given a dynamic self custody coin, returns its total balances
-const __getDynamicSelfCustodyTotalBalance = (coin: CoinType) =>
-  createDeepEqualSelector(
-    [getBalance(coin), getCoinCustodialBalance(coin)],
-    (balanceR, custodialBalanceR) => {
-      const custodialBalance = custodialBalanceR.getOrElse(0)
-
-      return Remote.of(
-        new BigNumber(balanceR.getOrElse(new BigNumber(0))).plus(custodialBalance).toNumber()
-      )
-    }
-  )
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.utils.ts b/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.utils.ts
deleted file mode 100644
index 0255a46b71b..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/balances/selectors.utils.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import BigNumber from 'bignumber.js'
-import { add, lift, pathOr, reduce } from 'ramda'
-
-import { coreSelectors, Remote } from '@core'
-import { RemoteDataType } from '@core/remote/types'
-import { createDeepEqualSelector } from '@core/utils'
-
-// gets BTC non-custodial balance which includes hd accounts excluding imported addresses
-export const __getBtcNonCustodialBalance = createDeepEqualSelector(
-  [coreSelectors.common.btc.getActiveHDAccounts],
-  (accountsR) => {
-    const getBalances = (balances) => {
-      const walletBalances: Array<number> = balances.map((account) =>
-        pathOr(0, ['info', 'final_balance'], account)
-      )
-      return walletBalances
-    }
-    const balancesR = lift(getBalances)(accountsR)
-
-    return balancesR.map(reduce<number, number>(add, 0))
-  }
-)
-
-// gets BCH non-custodial balance which includes hd accounts excluding imported addresses
-export const __getBchNonCustodialBalance = createDeepEqualSelector(
-  [coreSelectors.common.bch.getActiveHDAccounts],
-  (accountsR) => {
-    const getBalances = (balances) => {
-      const walletBalances: Array<number> = balances.map((account) =>
-        pathOr(0, ['info', 'final_balance'], account)
-      )
-      return walletBalances
-    }
-    const balancesR = lift(getBalances)(accountsR)
-
-    return balancesR.map(reduce<number, number>(add, 0))
-  }
-)
-
-// gets ETH non-custodial balance
-export const __getEthNonCustodialBalance = createDeepEqualSelector(
-  [coreSelectors.kvStore.eth.getContext, coreSelectors.data.eth.getAddresses],
-  (context, addressesR) => {
-    const contextToBalances = (context, balances) =>
-      context.map((a) => pathOr(0, [a, 'balance'], balances))
-
-    const balancesR: RemoteDataType<string, RemoteDataType<string, string>> = lift(
-      contextToBalances
-    )(Remote.of(context), addressesR)
-    return balancesR.map((b) => {
-      return new BigNumber(b.getOrElse('0'))
-    })
-  }
-)
-
-// gets XLM non-custodial balance
-export const __getXlmNonCustodialBalance = createDeepEqualSelector(
-  [
-    (state) =>
-      coreSelectors.kvStore.xlm
-        .getDefaultAccountId(state)
-        .map((accountId) => coreSelectors.data.xlm.getBalance(state, accountId).getOrElse(0))
-  ],
-  (balanceR) => {
-    return Remote.of(new BigNumber(balanceR.getOrElse(0)))
-  }
-)
-
-// given an ERC20 coin, returns its non-custodial balance
-export const __getErc20NonCustodialBalance = (coin) =>
-  createDeepEqualSelector(
-    [(state) => coreSelectors.data.eth.getErc20Balance(state, coin)],
-    (balanceR) => {
-      return Remote.of(new BigNumber(balanceR.getOrElse(0)))
-    }
-  )
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.classes.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.classes.ts
new file mode 100644
index 00000000000..f85dd13dfb3
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.classes.ts
@@ -0,0 +1,46 @@
+/* eslint-disable max-classes-per-file */
+import { CallEffect, SelectEffect } from 'redux-saga/effects'
+
+import { APIType } from '@core/network/api'
+import { CoinType, RemoteDataType } from '@core/types'
+import { RootState } from 'data/rootReducer'
+import { RequestExtrasType, SwapAccountType } from 'data/types'
+
+export enum CoinAccountTypeEnum {
+  CUSTODIAL = 'CUSTODIAL',
+  DYNAMIC_SELF_CUSTODY = 'DYNAMIC_SELF_CUSTODY',
+  ERC20 = 'ERC20',
+  NON_CUSTODIAL = 'NON_CUSTODIAL'
+}
+
+export class AccountTypeClass {
+  api: APIType
+
+  networks: any
+
+  constructor(api: APIType, networks) {
+    this.api = api
+    this.networks = networks
+  }
+
+  getNextReceiveAddress: (
+    coin: CoinType,
+    index?: number
+  ) => Generator<
+    CallEffect<unknown> | SelectEffect,
+    { address?: string; extras?: RequestExtrasType } | undefined,
+    any
+  >
+
+  getAccounts: (state: RootState, ownProps: any) => RemoteDataType<string, SwapAccountType[]>
+}
+
+export class NonCustodialAccountTypeClass extends AccountTypeClass {
+  getDefaultAccount: (coin: string) => Generator<SelectEffect, any, unknown>
+
+  getOrUpdateProvisionalPayment: (
+    coreSagas: any,
+    paymentR: any,
+    coin: string
+  ) => Generator<any, any, unknown>
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.custodial.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.custodial.ts
new file mode 100644
index 00000000000..28b72da4fce
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.custodial.ts
@@ -0,0 +1,64 @@
+import { call } from '@redux-saga/core/effects'
+import { lift } from 'ramda'
+
+import { APIType } from '@core/network/api'
+import { BSBalanceType, CoinType, ExtractSuccess } from '@core/types'
+import { createDeepEqualSelector } from '@core/utils'
+import { selectors } from 'data'
+import { RequestExtrasType, SwapAccountType } from 'data/types'
+
+import { generateTradingAccount } from '../utils'
+import { AccountTypeClass } from './accountTypes.classes'
+
+export class CustodialAccountType implements AccountTypeClass {
+  api: APIType
+
+  networks: any
+
+  constructor(api: APIType, networks: any) {
+    this.api = api
+    this.networks = networks
+  }
+
+  *getNextReceiveAddress(coin: CoinType) {
+    const custodial: ReturnType<typeof this.api.getBSPaymentAccount> = yield call(
+      this.api.getBSPaymentAccount,
+      coin
+    )
+    let { address } = custodial
+    const extras = {} as RequestExtrasType
+    if (window.coins[coin].coinfig.type.isMemoBased && address.split(':')[1]) {
+      // eslint-disable-next-line prefer-destructuring
+      extras.Memo = address.split(':')[1]
+      // eslint-disable-next-line prefer-destructuring
+      address = address.split(':')[0]
+    }
+
+    return { address, extras }
+  }
+
+  getAccounts = createDeepEqualSelector(
+    [
+      (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+      (state, ownProps) => ownProps // selector config
+    ],
+    (sbBalanceR, ownProps) => {
+      const transform = (sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
+        const { coin } = ownProps
+        const { coinfig } = window.coins[coin]
+        let accounts: SwapAccountType[] = []
+
+        // add trading accounts if requested
+        if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
+          accounts = accounts.concat(
+            generateTradingAccount(coin as CoinType, sbBalance as BSBalanceType)
+          )
+        }
+
+        return accounts
+      }
+
+      return lift(transform)(sbBalanceR)
+    }
+  )
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.dynamicSelfCustody.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.dynamicSelfCustody.ts
new file mode 100644
index 00000000000..38d89cfecfc
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.dynamicSelfCustody.ts
@@ -0,0 +1,68 @@
+import { call, select } from '@redux-saga/core/effects'
+import { lift } from 'ramda'
+
+import { APIType } from '@core/network/api'
+import { getPubKey } from '@core/redux/data/self-custody/sagas'
+import { BSBalanceType, CoinType } from '@core/types'
+import { createDeepEqualSelector } from '@core/utils'
+import { selectors } from 'data'
+import { SwapAccountType } from 'data/types'
+import { promptForSecondPassword } from 'services/sagas'
+
+import { generateSelfCustodyAccount, generateTradingAccount } from '../utils'
+import { AccountTypeClass } from './accountTypes.classes'
+
+export class DynamicSelfCustodyAccountType implements AccountTypeClass {
+  api: APIType
+
+  networks: any
+
+  constructor(api: APIType, networks: any) {
+    this.api = api
+    this.networks = networks
+  }
+
+  *getNextReceiveAddress(coin: CoinType) {
+    if (coin === 'STX') {
+      const password = yield call(promptForSecondPassword)
+      const pubKeys = yield call(getPubKey, coin, password)
+      const { results }: ReturnType<typeof this.api.deriveAddress> = yield call(
+        this.api.deriveAddress,
+        coin,
+        pubKeys
+      )
+      const result = results.find(({ default: isDefault }) => isDefault)
+      return { address: result?.address }
+    }
+    const address = selectors.core.kvStore.eth
+      .getDefaultAddress(yield select())
+      .getOrFail(`Failed to get ETH receive address`)
+
+    return { address }
+  }
+
+  getAccounts = createDeepEqualSelector(
+    [
+      (state, ownProps) => selectors.balances.getCoinNonCustodialBalance(ownProps.coin)(state),
+      (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+      (state, ownProps) => ownProps // selector config
+    ],
+    (balanceR, sbBalanceR, ownProps) => {
+      const { coin } = ownProps
+      const { coinfig } = window.coins[coin]
+      let accounts: SwapAccountType[] = []
+
+      const transform = (balance, sbBalance) => {
+        accounts = accounts.concat(generateSelfCustodyAccount(coin, balance))
+
+        // add trading accounts if requested
+        if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
+          accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
+        }
+        return accounts
+      }
+
+      return lift(transform)(balanceR, sbBalanceR)
+    }
+  )
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.erc20.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.erc20.ts
new file mode 100644
index 00000000000..71b1cd6a3ec
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.erc20.ts
@@ -0,0 +1,85 @@
+import { head, lift } from 'ramda'
+import { select } from 'redux-saga/effects'
+
+import { coreSelectors } from '@core'
+import { APIType } from '@core/network/api'
+import { BSBalanceType, ExtractSuccess, PaymentValue } from '@core/types'
+import { createDeepEqualSelector } from '@core/utils'
+import { selectors } from 'data'
+import { SwapAccountType, SwapBaseCounterTypes } from 'data/types'
+
+import { generateTradingAccount } from '../utils'
+import { NonCustodialAccountTypeClass } from './accountTypes.classes'
+
+export class ERC20AccountType implements NonCustodialAccountTypeClass {
+  api: APIType
+
+  networks: any
+
+  constructor(api: APIType, networks: any) {
+    this.api = api
+    this.networks = networks
+  }
+
+  *getNextReceiveAddress(coin: string) {
+    const address = selectors.core.kvStore.eth
+      .getDefaultAddress(yield select())
+      .getOrFail(`Failed to get ${coin} receive address.`)
+
+    return { address }
+  }
+
+  *getDefaultAccount(coin: string) {
+    const erc20AccountR = yield select(selectors.core.common.eth.getErc20AccountBalances, coin)
+    return erc20AccountR.map(head)
+  }
+
+  *getOrUpdateProvisionalPayment(coreSagas, networks, paymentR) {
+    return yield coreSagas.payment.eth.create({
+      network: networks.eth,
+      payment: paymentR.getOrElse(<PaymentValue>{})
+    })
+  }
+
+  getAccounts = createDeepEqualSelector(
+    [
+      coreSelectors.kvStore.eth.getDefaultAddress,
+      (state, { coin }) => selectors.balances.getCoinNonCustodialBalance(coin)(state), // non-custodial metadata
+      (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+      (state, ownProps) => ownProps // selector config
+    ],
+    (ethAddressR, erc20BalanceR, sbBalanceR, ownProps) => {
+      const transform = (
+        ethAddress,
+        erc20Balance,
+        sbBalance: ExtractSuccess<typeof sbBalanceR>
+      ) => {
+        const { coin } = ownProps
+        const { coinfig } = window.coins[coin]
+        let accounts: SwapAccountType[] = []
+
+        // add non-custodial accounts if requested
+        if (ownProps?.nonCustodialAccounts) {
+          accounts = accounts.concat([
+            {
+              address: ethAddress,
+              balance: erc20Balance,
+              baseCoin: 'ETH',
+              coin,
+              label: 'Private Key Wallet',
+              type: SwapBaseCounterTypes.ACCOUNT
+            }
+          ])
+        }
+
+        // add trading accounts if requested
+        if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
+          accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
+        }
+        return accounts
+      }
+
+      return lift(transform)(ethAddressR, erc20BalanceR, sbBalanceR)
+    }
+  )
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.nonCustodial.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.nonCustodial.ts
new file mode 100644
index 00000000000..c293a17e1cf
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/accountTypes/accountTypes.nonCustodial.ts
@@ -0,0 +1,357 @@
+import BigNumber from 'bignumber.js'
+import { add, head, lift, nth, path, prop, propEq } from 'ramda'
+import { select } from 'redux-saga/effects'
+
+import { coreSelectors, Remote, utils } from '@core'
+import { APIType } from '@core/network/api'
+import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
+import { BSBalanceType, CoinType, ExtractSuccess, PaymentValue } from '@core/types'
+import { createDeepEqualSelector } from '@core/utils'
+import { selectors } from 'data'
+import { convertStandardToBase } from 'data/components/exchange/services'
+import { SwapAccountType } from 'data/types'
+
+import { CoinAccountSelectorType } from '../types'
+import { generateInterestAccount, generateTradingAccount } from '../utils'
+import { NonCustodialAccountTypeClass } from './accountTypes.classes'
+
+const { formatAddr, isCashAddr, toCashAddr } = utils.bch
+
+export class NonCustodialAccountType implements NonCustodialAccountTypeClass {
+  api: APIType
+
+  networks: any
+
+  constructor(api: APIType, networks: any) {
+    this.api = api
+    this.networks = networks
+  }
+
+  *getNextReceiveAddress(coin: string, index?: number) {
+    let address = ''
+
+    switch (coin) {
+      case 'BCH': {
+        const state = yield select()
+        const defaultAccountIndex =
+          index || (yield select(selectors.core.kvStore.bch.getDefaultAccountIndex)).getOrFail()
+        const nextAddress = selectors.core.common.bch
+          .getNextAvailableReceiveAddress(this.networks.bch, defaultAccountIndex, state)
+          .getOrFail('Failed to get BCH receive address')
+
+        address = isCashAddr(nextAddress) ? formatAddr(nextAddress) : toCashAddr(nextAddress)
+        break
+      }
+      case 'BTC': {
+        const state = yield select()
+        const defaultAccountIndex =
+          index || (yield select(selectors.core.wallet.getDefaultAccountIndex))
+        const defaultDerivation = selectors.core.common.btc.getAccountDefaultDerivation(
+          defaultAccountIndex,
+          state
+        )
+        address = selectors.core.common.btc
+          .getNextAvailableReceiveAddress(
+            this.networks.btc,
+            defaultAccountIndex,
+            defaultDerivation,
+            state
+          )
+          .getOrFail('Failed to get BTC receive address')
+        break
+      }
+      case 'ETH':
+        address = selectors.core.kvStore.eth
+          .getDefaultAddress(yield select())
+          .getOrFail(`Failed to get ETH receive address`)
+        break
+      case 'XLM':
+        address = selectors.core.kvStore.xlm
+          .getDefaultAccountId(yield select())
+          .getOrFail(`Failed to get XLM receive address`)
+        break
+      default:
+    }
+
+    return { address }
+  }
+
+  *getDefaultAccount(coin: string) {
+    switch (coin) {
+      case 'BCH':
+        const bchAccountsR = yield select(selectors.core.common.bch.getAccountsBalances)
+        const bchDefaultIndex = (yield select(
+          selectors.core.kvStore.bch.getDefaultAccountIndex
+        )).getOrElse(0)
+        return bchAccountsR.map(nth(bchDefaultIndex))
+      case 'BTC':
+        const btcAccountsR = yield select(selectors.core.common.btc.getAccountsBalances)
+        const btcDefaultIndex = yield select(selectors.core.wallet.getDefaultAccountIndex)
+        return btcAccountsR.map(nth(btcDefaultIndex))
+      case 'ETH':
+        const ethAccountR = yield select(selectors.core.common.eth.getAccountBalances)
+        return ethAccountR.map(head)
+      case 'XLM':
+        return (yield select(selectors.core.common.xlm.getAccountBalances)).map(head)
+      default:
+    }
+  }
+
+  *getOrUpdateProvisionalPayment(coreSagas, paymentR, coin: string) {
+    return yield coreSagas.payment[coin.toLowerCase()].create({
+      network: this.networks[coin.toLowerCase()],
+      payment: paymentR.getOrElse(<PaymentValue>{})
+    })
+  }
+
+  getAccounts = (state, ownProps) => {
+    switch (ownProps.coin) {
+      case 'BCH': {
+        return createDeepEqualSelector(
+          [
+            coreSelectors.wallet.getHDAccounts, // non-custodial accounts
+            coreSelectors.data.bch.getAddresses, // non-custodial xpub info
+            coreSelectors.kvStore.bch.getAccounts, // non-custodial metadata info
+            coreSelectors.common.bch.getActiveAddresses, // imported addresses
+            (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+            (state, ownProps) => ownProps // selector config
+          ],
+          (bchAccounts, bchDataR, bchMetadataR, importedAddressesR, sbBalanceR, ownProps) => {
+            const transform = (
+              bchData,
+              bchMetadata,
+              importedAddresses,
+              sbBalance: ExtractSuccess<typeof sbBalanceR>
+            ) => {
+              const { coin } = ownProps
+              let accounts: SwapAccountType[] = []
+              // add non-custodial accounts if requested
+              if (ownProps?.nonCustodialAccounts) {
+                accounts = accounts.concat(
+                  bchAccounts
+                    .map((acc) => {
+                      const index = prop('index', acc)
+                      // this is using hdAccount with new segwit structure
+                      // need to get legacy xPub from derivations object similar to btc selector
+                      const xpub = prop(
+                        'xpub',
+                        prop('derivations', acc).find((derr) => derr.type === 'legacy')
+                      )
+                      const data = prop(xpub, bchData)
+                      const metadata = bchMetadata[index]
+                      return {
+                        accountIndex: prop('index', acc),
+                        address: index,
+                        archived: prop('archived', metadata) || false,
+                        balance: prop('final_balance', data),
+                        baseCoin: coin,
+                        coin,
+                        label: prop('label', metadata) || xpub,
+                        type: ADDRESS_TYPES.ACCOUNT
+                      }
+                    })
+                    .filter(propEq('archived', false))
+                )
+              }
+
+              // add imported addresses if requested
+              if (ownProps?.importedAddresses) {
+                accounts = accounts.concat(
+                  importedAddresses.map((importedAcc) => ({
+                    address: importedAcc.addr,
+                    balance: importedAcc.info.final_balance,
+                    baseCoin: coin,
+                    coin,
+                    label: importedAcc.label || importedAcc.addr,
+                    type: ADDRESS_TYPES.LEGACY
+                  }))
+                )
+              }
+
+              // add trading accounts if requested
+              if (ownProps?.tradingAccounts) {
+                accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
+              }
+
+              return accounts
+            }
+
+            return lift(transform)(bchDataR, bchMetadataR, importedAddressesR, sbBalanceR)
+          }
+        )(state, ownProps)
+      }
+      case 'BTC': {
+        return createDeepEqualSelector(
+          [
+            coreSelectors.wallet.getHDAccounts, // non-custodial accounts
+            coreSelectors.data.btc.getAddresses, // non-custodial xpub info
+            coreSelectors.common.btc.getActiveAddresses, // imported addresses
+            (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+            (state, { coin }) => selectors.balances.getCoinInterestBalance(coin, state), // custodial accounts
+            (state, ownProps): CoinAccountSelectorType & { coin: CoinType } => ownProps // selector config
+          ],
+          (btcAccounts, btcDataR, importedAddressesR, sbBalanceR, interestBalanceR, ownProps) => {
+            const transform = (
+              btcData,
+              importedAddresses,
+              sbBalance: ExtractSuccess<typeof sbBalanceR>,
+              interestBalance: ExtractSuccess<typeof interestBalanceR>
+            ) => {
+              const { coin } = ownProps
+              let accounts: SwapAccountType[] = []
+              // add non-custodial accounts if requested
+              if (ownProps?.nonCustodialAccounts) {
+                // each account has a derivations object with legacy xpub and segwit xpub
+                // need to extract each xpub for balance
+                const xpubArray = (acc) =>
+                  prop('derivations', acc).map((derr) => prop('xpub', derr))
+                const xpubBalance = (acc) =>
+                  xpubArray(acc).map((xpub) =>
+                    prop<string, any>('final_balance', prop(xpub, btcData))
+                  )
+                accounts = accounts.concat(
+                  btcAccounts
+                    .map((acc) => ({
+                      accountIndex: prop('index', acc),
+                      address: prop('index', acc),
+                      archived: prop('archived', acc) || false,
+                      balance: xpubBalance(acc).reduce(add, 0),
+                      baseCoin: coin,
+                      coin,
+                      label: prop('label', acc) || prop('xpub', acc),
+                      type: ADDRESS_TYPES.ACCOUNT
+                    }))
+                    .filter(propEq('archived', false))
+                )
+              }
+
+              // add imported addresses if requested
+              if (ownProps?.importedAddresses) {
+                accounts = accounts.concat(
+                  importedAddresses.map((importedAcc) => ({
+                    address: importedAcc.addr,
+                    balance: importedAcc.info.final_balance,
+                    baseCoin: coin,
+                    coin,
+                    label: importedAcc.label || importedAcc.addr,
+                    type: ADDRESS_TYPES.LEGACY
+                  }))
+                )
+              }
+
+              // add trading accounts if requested
+              if (ownProps?.tradingAccounts) {
+                accounts = accounts.concat(generateTradingAccount(coin, sbBalance))
+              }
+
+              // add interest accounts if requested
+              if (ownProps?.interestAccounts) {
+                accounts = accounts.concat(generateInterestAccount(coin, interestBalance))
+              }
+              return accounts
+            }
+
+            return lift(transform)(btcDataR, importedAddressesR, sbBalanceR, interestBalanceR)
+          }
+        )(state, ownProps)
+      }
+      case 'ETH': {
+        return createDeepEqualSelector(
+          [
+            coreSelectors.data.eth.getAddresses, // non-custodial accounts
+            coreSelectors.kvStore.eth.getAccounts, // non-custodial metadata
+            (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+            (state, ownProps) => ownProps // selector config
+          ],
+          (ethDataR, ethMetadataR, sbBalanceR, ownProps) => {
+            const transform = (
+              ethData,
+              ethMetadata,
+              sbBalance: ExtractSuccess<typeof sbBalanceR>
+            ) => {
+              const { coin } = ownProps
+              let accounts: SwapAccountType[] = []
+
+              // add non-custodial accounts if requested
+              if (ownProps?.nonCustodialAccounts) {
+                accounts = accounts.concat(
+                  ethMetadata.map((acc) => {
+                    const address = prop('addr', acc)
+                    const data = prop(address, ethData)
+
+                    return {
+                      address,
+                      balance: prop('balance', data),
+                      baseCoin: coin,
+                      coin,
+                      label: prop('label', acc) || address,
+                      type: ADDRESS_TYPES.ACCOUNT
+                    }
+                  })
+                )
+              }
+
+              // add trading accounts if requested
+              if (ownProps?.tradingAccounts) {
+                accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
+              }
+
+              return accounts
+            }
+
+            return lift(transform)(ethDataR, ethMetadataR, sbBalanceR)
+          }
+        )(state, ownProps)
+      }
+      case 'XLM': {
+        return createDeepEqualSelector(
+          [
+            coreSelectors.kvStore.xlm.getAccounts, // non-custodial metadata
+            (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
+            (state, ownProps) => ownProps // selector config
+          ],
+          (xlmMetadataR, sbBalanceR, ownProps) => {
+            const transform = (xlmMetadata, sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
+              const { coin } = ownProps
+              let accounts: SwapAccountType[] = []
+
+              // add non-custodial accounts if requested
+              if (ownProps?.nonCustodialAccounts) {
+                accounts = accounts.concat(
+                  xlmMetadata
+                    .map((acc) => {
+                      const address = prop('publicKey', acc)
+                      const balance = coreSelectors.data.coins
+                        .getCoinUnifiedBalance('XLM')(state)
+                        .getOrElse(new BigNumber(0))
+                      return {
+                        address,
+                        archived: prop('archived', acc) || false,
+                        balance,
+                        baseCoin: coin,
+                        coin,
+                        label: prop('label', acc) || address,
+                        type: ADDRESS_TYPES.ACCOUNT
+                      }
+                    })
+                    .filter(propEq('archived', false))
+                )
+              }
+
+              // add trading accounts if requested
+              if (ownProps?.tradingAccounts) {
+                accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
+              }
+
+              return accounts
+            }
+
+            return lift(transform)(xlmMetadataR, sbBalanceR)
+          }
+        )(state, ownProps)
+      }
+      default:
+        return Remote.Failure('')
+    }
+  }
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas.ts
new file mode 100644
index 00000000000..dbb5457931f
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas.ts
@@ -0,0 +1,60 @@
+import { CoinType, PaymentValue, RemoteDataType } from '@core/types'
+import { RequestExtrasType } from 'data/types'
+
+import {
+  CoinAccountTypeEnum,
+  NonCustodialAccountTypeClass
+} from './accountTypes/accountTypes.classes'
+import { CustodialAccountType } from './accountTypes/accountTypes.custodial'
+import { DynamicSelfCustodyAccountType } from './accountTypes/accountTypes.dynamicSelfCustody'
+import { ERC20AccountType } from './accountTypes/accountTypes.erc20'
+import { NonCustodialAccountType } from './accountTypes/accountTypes.nonCustodial'
+import { getKey } from './selectors'
+
+export default ({ api, coreSagas, networks }) => {
+  const accounts = {
+    CUSTODIAL: new CustodialAccountType(api, networks),
+    DYNAMIC_SELF_CUSTODY: new DynamicSelfCustodyAccountType(api, networks),
+    ERC20: new ERC20AccountType(api, networks),
+    NON_CUSTODIAL: new NonCustodialAccountType(api, networks)
+  }
+  // gets the default account/address for requested coin
+  const getDefaultAccountForCoin = function* (coin: CoinType) {
+    const accountType = getKey(coin)
+    const defaultAccountR = yield (
+      accounts[accountType] as NonCustodialAccountTypeClass
+    ).getDefaultAccount(coin)
+
+    return defaultAccountR.getOrFail('Failed to find default account')
+  }
+
+  // gets the next receive address for requested coin
+  // account based currencies will just return the account address
+  const getNextReceiveAddressForCoin = function* (
+    coin: CoinType,
+    coinAccountType: CoinAccountTypeEnum,
+    index?: number
+    // @ts-ignore
+  ): { address: string; extras?: RequestExtrasType } {
+    return yield accounts[coinAccountType].getNextReceiveAddress(coin, index)
+  }
+
+  // gets or updates a provisional payment for a coin
+  // provisional payments are mutable payment objects used to build a transaction
+  // over an extended period of time (e.g. as user goes through interest/swap/sell flows)
+  const getOrUpdateProvisionalPaymentForCoin = function* (
+    coin: CoinType,
+    paymentR: RemoteDataType<string | Error, PaymentValue | undefined>
+  ) {
+    const accountType = getKey(coin)
+    return yield (
+      accounts[accountType] as NonCustodialAccountTypeClass
+    ).getOrUpdateProvisionalPayment(coreSagas, paymentR, coin)
+  }
+
+  return {
+    getDefaultAccountForCoin,
+    getNextReceiveAddressForCoin,
+    getOrUpdateProvisionalPaymentForCoin
+  }
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/ars.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/ars.ts
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/bch.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/bch.ts
deleted file mode 100644
index c5c35784452..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/bch.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { nth } from 'ramda'
-import { select } from 'redux-saga/effects'
-
-import { utils } from '@core'
-import { PaymentValue } from '@core/redux/payment/types'
-import { selectors } from 'data'
-
-const { formatAddr, isCashAddr, toCashAddr } = utils.bch
-
-// retrieves default account/address
-export const getDefaultAccount = function* () {
-  const bchAccountsR = yield select(selectors.core.common.bch.getAccountsBalances)
-  const bchDefaultIndex = (yield select(
-    selectors.core.kvStore.bch.getDefaultAccountIndex
-  )).getOrElse(0)
-  return bchAccountsR.map(nth(bchDefaultIndex))
-}
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* (_, networks, index) {
-  const state = yield select()
-  const defaultAccountIndex =
-    index || (yield select(selectors.core.kvStore.bch.getDefaultAccountIndex)).getOrFail()
-  const nextAddress = selectors.core.common.bch
-    .getNextAvailableReceiveAddress(networks.bch, defaultAccountIndex, state)
-    .getOrFail('Failed to get BCH receive address')
-
-  return isCashAddr(nextAddress) ? formatAddr(nextAddress) : toCashAddr(nextAddress)
-}
-
-// gets or updates a provisional payment
-export const getOrUpdateProvisionalPayment = function* (coreSagas, networks, paymentR) {
-  return yield coreSagas.payment.bch.create({
-    network: networks.bch,
-    payment: paymentR.getOrElse(<PaymentValue>{})
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/btc.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/btc.ts
deleted file mode 100644
index 0b785cbe123..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/btc.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { nth } from 'ramda'
-import { select } from 'redux-saga/effects'
-
-import { PaymentValue } from '@core/redux/payment/types'
-import { selectors } from 'data'
-
-// retrieves default account/address
-export const getDefaultAccount = function* () {
-  const btcAccountsR = yield select(selectors.core.common.btc.getAccountsBalances)
-  const btcDefaultIndex = yield select(selectors.core.wallet.getDefaultAccountIndex)
-  return btcAccountsR.map(nth(btcDefaultIndex))
-}
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* (_, networks, index) {
-  const state = yield select()
-  const defaultAccountIndex = index || (yield select(selectors.core.wallet.getDefaultAccountIndex))
-
-  const defaultDerivation = selectors.core.common.btc.getAccountDefaultDerivation(
-    defaultAccountIndex,
-    state
-  )
-
-  return selectors.core.common.btc
-    .getNextAvailableReceiveAddress(networks.btc, defaultAccountIndex, defaultDerivation, state)
-    .getOrFail('Failed to get BTC receive address')
-}
-
-// gets or updates a provisional payment
-export const getOrUpdateProvisionalPayment = function* (coreSagas, networks, paymentR) {
-  return yield coreSagas.payment.btc.create({
-    network: networks.btc,
-    payment: paymentR.getOrElse(<PaymentValue>{})
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/custodial.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/custodial.ts
deleted file mode 100644
index 044f2cd02b4..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/custodial.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// retrieves default account/address
-export const getDefaultAccount = function* () {
-  //   const btcAccountsR = yield select(selectors.core.common.btc.getAccountsBalances)
-  //   const btcDefaultIndex = yield select(selectors.core.wallet.getDefaultAccountIndex)
-  //   return btcAccountsR.map(nth(btcDefaultIndex))
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/erc20.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/erc20.ts
deleted file mode 100644
index 495ed38f852..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/erc20.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { head } from 'ramda'
-import { select } from 'redux-saga/effects'
-
-import { CoinType, PaymentValue } from '@core/types'
-import { selectors } from 'data'
-
-// retrieves default account/address
-export const getDefaultAccount = function* (coin: CoinType) {
-  const erc20AccountR = yield select(selectors.core.common.eth.getErc20AccountBalances, coin)
-  return erc20AccountR.map(head)
-}
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* (coin: CoinType) {
-  return selectors.core.kvStore.eth
-    .getDefaultAddress(yield select())
-    .getOrFail(`Failed to get ${coin} receive address`)
-}
-
-// gets or updates a provisional payment
-export const getOrUpdateProvisionalPayment = function* (coreSagas, networks, paymentR) {
-  return yield coreSagas.payment.eth.create({
-    network: networks.eth,
-    payment: paymentR.getOrElse(<PaymentValue>{})
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/eth.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/eth.ts
deleted file mode 100644
index 8d55ed2b489..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/eth.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { head } from 'ramda'
-import { select } from 'redux-saga/effects'
-
-import { PaymentValue } from '@core/redux/payment/types'
-import { selectors } from 'data'
-
-// retrieves default account/address
-export const getDefaultAccount = function* () {
-  const ethAccountR = yield select(selectors.core.common.eth.getAccountBalances)
-  return ethAccountR.map(head)
-}
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* () {
-  return selectors.core.kvStore.eth
-    .getDefaultAddress(yield select())
-    .getOrFail(`Failed to get ETH receive address`)
-}
-
-// gets or updates a provisional payment
-export const getOrUpdateProvisionalPayment = function* (coreSagas, networks, paymentR) {
-  return yield coreSagas.payment.eth.create({
-    network: networks.eth,
-    payment: paymentR.getOrElse(<PaymentValue>{})
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/eur.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/eur.ts
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/gbp.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/gbp.ts
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/self-custody.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/self-custody.ts
deleted file mode 100644
index 63b9f7b0a54..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/self-custody.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { call } from 'redux-saga/effects'
-
-import { APIType } from '@core/network/api'
-import { getPubKey } from '@core/redux/data/self-custody/sagas'
-import { CoinType } from '@core/types'
-import { promptForSecondPassword } from 'services/sagas'
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* (coin: CoinType, networks, index, api: APIType) {
-  const password = yield call(promptForSecondPassword)
-  const pubKeys = yield call(getPubKey, password)
-  const { results }: ReturnType<typeof api.deriveAddress> = yield call(
-    api.deriveAddress,
-    coin,
-    pubKeys
-  )
-  const address = results.find(({ default: isDefault }) => isDefault)
-  return address?.address
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/usd.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/usd.ts
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/xlm.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/xlm.ts
deleted file mode 100644
index 11759215e66..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/coins/xlm.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { head } from 'ramda'
-import { select } from 'redux-saga/effects'
-
-import { PaymentValue } from '@core/redux/payment/types'
-import { selectors } from 'data'
-
-// retrieves default account/address
-export const getDefaultAccount = function* () {
-  return (yield select(selectors.core.common.xlm.getAccountBalances)).map(head)
-}
-
-// retrieves the next receive address
-export const getNextReceiveAddress = function* () {
-  return selectors.core.kvStore.xlm
-    .getDefaultAccountId(yield select())
-    .getOrFail(`Failed to get XLM receive address`)
-}
-
-// gets or updates a provisional payment
-export const getOrUpdateProvisionalPayment = function* (coreSagas, networks, paymentR) {
-  return yield coreSagas.payment.xlm.create({
-    payment: paymentR.getOrElse(<PaymentValue>{})
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/index.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/index.ts
deleted file mode 100644
index d6f76b495b2..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/sagas/index.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { CoinType, PaymentType, PaymentValue, RemoteDataType } from '@core/types'
-import { selectors } from 'data'
-
-import * as BCH from './coins/bch'
-import * as BTC from './coins/btc'
-import * as ERC20 from './coins/erc20'
-import * as ETH from './coins/eth'
-import * as SELF_CUSTODY from './coins/self-custody'
-// import * as EUR from './coins/eur'
-// import * as GBP from './coins/gbp'
-// import * as USD from './coins/usd'
-import * as XLM from './coins/xlm'
-
-const getSaga = (coin: CoinType) => {
-  if (selectors.core.data.coins.getErc20Coins().includes(coin)) {
-    return 'ERC20'
-  }
-  if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
-    return 'SELF_CUSTODY'
-  }
-  return coin
-}
-
-// create a function map of all coins
-const coinSagas = {
-  BCH,
-  BTC,
-  ERC20,
-  ETH,
-  SELF_CUSTODY,
-  // EUR,
-  // GBP,
-  // USD,
-  XLM
-}
-
-//
-// for now this is a dumping ground for both sagas and util functions (not generator functions)
-// that require coin specific logic to execute. perhaps in the future we split these out further
-//
-
-export default ({ api, coreSagas, networks }) => {
-  // gets the default account/address for requested coin
-  const getDefaultAccountForCoin = function* (coin: CoinType): Generator<string> {
-    const saga = getSaga(coin)
-    const defaultAccountR = yield coinSagas[saga]?.getDefaultAccount(coin)
-    // @ts-ignore
-    return defaultAccountR.getOrFail('Failed to find default account')
-  }
-
-  // gets the next receive address for requested coin
-  // account based currencies will just return the account address
-  const getNextReceiveAddressForCoin = function* (
-    coin: CoinType,
-    index?: number
-  ): Generator<string> {
-    const saga = getSaga(coin)
-    return yield coinSagas[saga]?.getNextReceiveAddress(coin, networks, index, api)
-  }
-
-  // gets or updates a provisional payment for a coin
-  // provisional payments are mutable payment objects used to build a transaction
-  // over an extended period of time (e.g. as user goes through interest/swap/sell flows)
-  const getOrUpdateProvisionalPaymentForCoin = function* (
-    coin: CoinType,
-    paymentR: RemoteDataType<string | Error, PaymentValue | undefined>
-  ): Generator<PaymentType> {
-    const saga = getSaga(coin)
-    return yield coinSagas[saga]?.getOrUpdateProvisionalPayment(
-      coreSagas,
-      networks,
-      paymentR
-    ) as PaymentType
-  }
-
-  return {
-    getDefaultAccountForCoin,
-    getNextReceiveAddressForCoin,
-    getOrUpdateProvisionalPaymentForCoin
-  }
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/index.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors.ts
similarity index 64%
rename from packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/index.ts
rename to packages/blockchain-wallet-v4-frontend/src/data/coins/selectors.ts
index 3d210c929e0..8ce3fbffe1b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/index.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors.ts
@@ -1,58 +1,37 @@
 import { any, isEmpty, isNil, map, values } from 'ramda'
 
 import { Remote } from '@core'
-import { CoinfigType, CoinType, InvitationsType, RemoteDataType } from '@core/types'
+import { CoinType, InvitationsType, RemoteDataType } from '@core/types'
 import { selectors } from 'data'
 import { CoinAccountSelectorType } from 'data/coins/types'
 import { SwapAccountType } from 'data/components/swap/types'
 import { RootState } from 'data/rootReducer'
 
-import * as ARS from './coins/ars'
-import * as BCH from './coins/bch'
-import * as BTC from './coins/btc'
-import * as CUSTODIAL from './coins/custodial'
-import * as DYNAMIC_SELF_CUSTODY from './coins/dynamic-self-custody'
-import * as ERC20 from './coins/erc20'
-import * as ETH from './coins/eth'
-import * as EUR from './coins/eur'
-import * as GBP from './coins/gbp'
-import * as USD from './coins/usd'
-import * as XLM from './coins/xlm'
-
-// create a function map of all coins
-const coinSelectors = {
-  ARS,
-  BCH,
-  BTC,
-  CUSTODIAL,
-  DYNAMIC_SELF_CUSTODY,
-  ERC20,
-  ETH,
-  EUR,
-  GBP,
-  USD,
-  XLM
-}
+import { CustodialAccountType } from './accountTypes/accountTypes.custodial'
+import { DynamicSelfCustodyAccountType } from './accountTypes/accountTypes.dynamicSelfCustody'
+import { ERC20AccountType } from './accountTypes/accountTypes.erc20'
+import { NonCustodialAccountType } from './accountTypes/accountTypes.nonCustodial'
 
-// internal util get locate correct selectors
-const __getSelector = (coinfig: CoinfigType) => {
-  if (selectors.core.data.coins.getErc20Coins().includes(coinfig.symbol)) {
+export const getKey = (coin: CoinType) => {
+  if (selectors.core.data.coins.getErc20Coins().includes(coin)) {
     return 'ERC20'
   }
-  if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coinfig.symbol)) {
+  if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
     return 'DYNAMIC_SELF_CUSTODY'
   }
-  if (selectors.core.data.coins.getCustodialCoins().includes(coinfig.symbol)) {
-    return 'CUSTODIAL'
-  }
-  return coinfig.symbol
+  return 'NON_CUSTODIAL'
 }
 
 // retrieves introduction text for coin on its transaction page
 const getIntroductionText = (coin: string) => {
-  const { coinfig } = window.coins[coin]
-  const selector = __getSelector(coinfig)
-  return coinSelectors[selector]?.getTransactionPageHeaderText(coinfig.symbol)
+  return ''
+}
+
+const accountTypes = {
+  CUSTODIAL: new CustodialAccountType({} as any, {} as any),
+  DYNAMIC_SELF_CUSTODY: new DynamicSelfCustodyAccountType({} as any, {} as any),
+  ERC20: new ERC20AccountType({} as any, {} as any),
+  NON_CUSTODIAL: new NonCustodialAccountType({} as any, {} as any)
 }
 
 // generic selector that should be used by all features to request their desired
@@ -66,10 +45,8 @@ const getCoinAccounts = (state: RootState, ownProps: CoinAccountSelectorType) =>
       isEmpty(coinList) || isNil(coinList)
         ? Remote.of({})
         : coinList.reduce((accounts, coin) => {
-            const { coinfig } = window.coins[coin]
-            const selector = __getSelector(coinfig)
-            // eslint-disable-next-line
-          accounts[coin] = coinSelectors[selector]?.getAccounts(state, { coin, ...ownProps })
+            const accountType = getKey(coin)
+            accounts[coin] = accountTypes[accountType].getAccounts(state, { coin, ...ownProps })
             return accounts
           }, {})
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/ars.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/ars.tsx
deleted file mode 100644
index b4bfe3892cc..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/ars.tsx
+++ /dev/null
@@ -1,10 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.ars.intro'
-    defaultMessage='Store Argentine peso in your wallet and use it to Buy crypto.'
-  />
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/bch.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/bch.tsx
deleted file mode 100644
index a9891801064..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/bch.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import { lift, prop, propEq } from 'ramda'
-
-import { coreSelectors } from '@core'
-import { BSBalanceType } from '@core/network/api/buySell/types'
-import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
-import { ExtractSuccess } from '@core/remote/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.bch.intro'
-    defaultMessage='Bitcoin Cash (BCH) is a fork of Bitcoin built for everyday transactions.'
-  />
-)
-
-// main selector for all BCH account types
-// accepts a CoinAccountSelectorType config object
-export const getAccounts = createDeepEqualSelector(
-  [
-    coreSelectors.wallet.getHDAccounts, // non-custodial accounts
-    coreSelectors.data.bch.getAddresses, // non-custodial xpub info
-    coreSelectors.kvStore.bch.getAccounts, // non-custodial metadata info
-    coreSelectors.common.bch.getActiveAddresses, // imported addresses
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (bchAccounts, bchDataR, bchMetadataR, importedAddressesR, sbBalanceR, ownProps) => {
-    const transform = (
-      bchData,
-      bchMetadata,
-      importedAddresses,
-      sbBalance: ExtractSuccess<typeof sbBalanceR>
-    ) => {
-      const { coin } = ownProps
-      let accounts: SwapAccountType[] = []
-      // add non-custodial accounts if requested
-      if (ownProps?.nonCustodialAccounts) {
-        accounts = accounts.concat(
-          bchAccounts
-            .map((acc) => {
-              const index = prop('index', acc)
-              // this is using hdAccount with new segwit structure
-              // need to get legacy xPub from derivations object similar to btc selector
-              const xpub = prop(
-                'xpub',
-                prop('derivations', acc).find((derr) => derr.type === 'legacy')
-              )
-              const data = prop(xpub, bchData)
-              const metadata = bchMetadata[index]
-              return {
-                accountIndex: prop('index', acc),
-                address: index,
-                archived: prop('archived', metadata) || false,
-                balance: prop('final_balance', data),
-                baseCoin: coin,
-                coin,
-                label: prop('label', metadata) || xpub,
-                type: ADDRESS_TYPES.ACCOUNT
-              }
-            })
-            .filter(propEq('archived', false))
-        )
-      }
-
-      // add imported addresses if requested
-      if (ownProps?.importedAddresses) {
-        accounts = accounts.concat(
-          importedAddresses.map((importedAcc) => ({
-            address: importedAcc.addr,
-            balance: importedAcc.info.final_balance,
-            baseCoin: coin,
-            coin,
-            label: importedAcc.label || importedAcc.addr,
-            type: ADDRESS_TYPES.LEGACY
-          }))
-        )
-      }
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
-      }
-
-      return accounts
-    }
-
-    return lift(transform)(bchDataR, bchMetadataR, importedAddressesR, sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/btc.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/btc.tsx
deleted file mode 100644
index 6f0db3ff0ff..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/btc.tsx
+++ /dev/null
@@ -1,94 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import { add, lift, prop, propEq } from 'ramda'
-
-import { coreSelectors } from '@core'
-import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
-import { ExtractSuccess } from '@core/remote/types'
-import { CoinType } from '@core/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { CoinAccountSelectorType } from 'data/coins/types'
-import { generateInterestAccount, generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.btc.intro'
-    defaultMessage='Bitcoin (BTC) is the original crypto and the internet’s premier digital currency.'
-  />
-)
-
-// main selector for all BTC account types
-// accepts a CoinAccountSelectorType config object
-export const getAccounts = createDeepEqualSelector(
-  [
-    coreSelectors.wallet.getHDAccounts, // non-custodial accounts
-    coreSelectors.data.btc.getAddresses, // non-custodial xpub info
-    coreSelectors.common.btc.getActiveAddresses, // imported addresses
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, { coin }) => selectors.balances.getCoinInterestBalance(coin, state), // custodial accounts
-    (state, ownProps): CoinAccountSelectorType & { coin: CoinType } => ownProps // selector config
-  ],
-  (btcAccounts, btcDataR, importedAddressesR, sbBalanceR, interestBalanceR, ownProps) => {
-    const transform = (
-      btcData,
-      importedAddresses,
-      sbBalance: ExtractSuccess<typeof sbBalanceR>,
-      interestBalance: ExtractSuccess<typeof interestBalanceR>
-    ) => {
-      const { coin } = ownProps
-      let accounts: SwapAccountType[] = []
-      // add non-custodial accounts if requested
-      if (ownProps?.nonCustodialAccounts) {
-        // each account has a derivations object with legacy xpub and segwit xpub
-        // need to extract each xpub for balance
-        const xpubArray = (acc) => prop('derivations', acc).map((derr) => prop('xpub', derr))
-        const xpubBalance = (acc) =>
-          xpubArray(acc).map((xpub) => prop<string, any>('final_balance', prop(xpub, btcData)))
-        accounts = accounts.concat(
-          btcAccounts
-            .map((acc) => ({
-              accountIndex: prop('index', acc),
-              address: prop('index', acc),
-              archived: prop('archived', acc) || false,
-              balance: xpubBalance(acc).reduce(add, 0),
-              baseCoin: coin,
-              coin,
-              label: prop('label', acc) || prop('xpub', acc),
-              type: ADDRESS_TYPES.ACCOUNT
-            }))
-            .filter(propEq('archived', false))
-        )
-      }
-
-      // add imported addresses if requested
-      if (ownProps?.importedAddresses) {
-        accounts = accounts.concat(
-          importedAddresses.map((importedAcc) => ({
-            address: importedAcc.addr,
-            balance: importedAcc.info.final_balance,
-            baseCoin: coin,
-            coin,
-            label: importedAcc.label || importedAcc.addr,
-            type: ADDRESS_TYPES.LEGACY
-          }))
-        )
-      }
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance))
-      }
-
-      // add interest accounts if requested
-      if (ownProps?.interestAccounts) {
-        accounts = accounts.concat(generateInterestAccount(coin, interestBalance))
-      }
-      return accounts
-    }
-
-    return lift(transform)(btcDataR, importedAddressesR, sbBalanceR, interestBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/custodial.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/custodial.ts
deleted file mode 100644
index 728edb0cd1a..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/custodial.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { lift } from 'ramda'
-
-import { BSBalanceType } from '@core/network/api/buySell/types'
-import { ExtractSuccess } from '@core/remote/types'
-import { CoinType } from '@core/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => null
-
-// main selector for all CUSTODIAL account types
-// accepts a CoinAccountSelectorType config object
-// NOT IMPLEMENTED FOR COIN: non-custodial accounts, imported addresses/accounts
-export const getAccounts = createDeepEqualSelector(
-  [
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (sbBalanceR, ownProps) => {
-    const transform = (sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
-      const { coin } = ownProps
-      const { coinfig } = window.coins[coin]
-      let accounts: SwapAccountType[] = []
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
-        accounts = accounts.concat(
-          generateTradingAccount(coin as CoinType, sbBalance as BSBalanceType)
-        )
-      }
-
-      return accounts
-    }
-
-    return lift(transform)(sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/dynamic-self-custody.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/dynamic-self-custody.ts
deleted file mode 100644
index 9a9624e5b7f..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/dynamic-self-custody.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { lift } from 'ramda'
-
-import { getBalance } from '@core/redux/data/coins/selectors'
-import { BSBalanceType } from '@core/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateSelfCustodyAccount, generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType } from 'data/types'
-
-export const getTransactionPageHeaderText = () => null
-
-// main selector for all DYNAMIC-SELF-CUSTODY account types
-// accepts a coin string
-export const getAccounts = createDeepEqualSelector(
-  [
-    (state, ownProps) => getBalance(ownProps.coin, state),
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (balanceR, sbBalanceR, ownProps) => {
-    const { coin } = ownProps
-    const { coinfig } = window.coins[coin]
-    let accounts: SwapAccountType[] = []
-
-    const transform = (balance, sbBalance) => {
-      accounts = accounts.concat(generateSelfCustodyAccount(coin, balance))
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
-      }
-      return accounts
-    }
-
-    return lift(transform)(balanceR, sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/erc20.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/erc20.tsx
deleted file mode 100644
index cae287c5c12..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/erc20.tsx
+++ /dev/null
@@ -1,95 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import { lift } from 'ramda'
-
-import { coreSelectors } from '@core'
-import { BSBalanceType } from '@core/network/api/buySell/types'
-import { ExtractSuccess } from '@core/remote/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType, SwapBaseCounterTypes } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = (coin) => {
-  switch (coin) {
-    case 'AAVE':
-      return (
-        <FormattedMessage
-          id='coins.aave.intro'
-          defaultMessage='Aave is a decentralized finance protocol that allows people to lend and borrow crypto.'
-        />
-      )
-    case 'PAX':
-      return (
-        <FormattedMessage
-          id='coins.pax.intro1'
-          defaultMessage='Paxos Standard (PAX) is a stablecoin backed by the U.S. dollar.'
-        />
-      )
-    case 'USDT':
-      return (
-        <FormattedMessage
-          id='coins.usdt.intro'
-          defaultMessage='Tether (USDT) is a stablecoin backed by the U.S. dollar.'
-        />
-      )
-    case 'WDGLD':
-      return (
-        <FormattedMessage
-          id='coins.wdgld.intro'
-          defaultMessage='Wrapped Digital Gold (wDGLD) is a gold-backed token built with the power and flexibility of Ethereum.'
-        />
-      )
-    case 'YFI':
-      return (
-        <FormattedMessage
-          id='coins.yfi.intro'
-          defaultMessage='Yearn.Finance (YFI) is a portal to DeFi and yield-generating products in the Ethereum ecosystem.'
-        />
-      )
-    default:
-      return null
-  }
-}
-
-// main selector for all ERC20 account types
-// accepts a CoinAccountSelectorType config object
-// NOT IMPLEMENTED: imported addresses/accounts
-export const getAccounts = createDeepEqualSelector(
-  [
-    coreSelectors.kvStore.eth.getDefaultAddress,
-    (state, { coin }) => coreSelectors.data.eth.getErc20Balance(state, coin), // non-custodial metadata
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (ethAddressR, erc20BalanceR, sbBalanceR, ownProps) => {
-    const transform = (ethAddress, erc20Balance, sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
-      const { coin } = ownProps
-      const { coinfig } = window.coins[coin]
-      let accounts: SwapAccountType[] = []
-
-      // add non-custodial accounts if requested
-      if (ownProps?.nonCustodialAccounts) {
-        accounts = accounts.concat([
-          {
-            address: ethAddress,
-            balance: erc20Balance,
-            baseCoin: 'ETH',
-            coin,
-            label: 'Private Key Wallet',
-            type: SwapBaseCounterTypes.ACCOUNT
-          }
-        ])
-      }
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts && coinfig.products.includes('CustodialWalletBalance')) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
-      }
-      return accounts
-    }
-
-    return lift(transform)(ethAddressR, erc20BalanceR, sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eth.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eth.tsx
deleted file mode 100644
index 8dd3550b711..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eth.tsx
+++ /dev/null
@@ -1,66 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import { lift, prop } from 'ramda'
-
-import { coreSelectors } from '@core'
-import { BSBalanceType } from '@core/network/api/buySell/types'
-import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
-import { ExtractSuccess } from '@core/remote/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateTradingAccount } from 'data/coins/utils'
-import { SwapAccountType } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.eth.intro'
-    defaultMessage='Ethereum (ETH) is a currency and platform for execution of decentralized smart contracts.'
-  />
-)
-
-// main selector for all ETH account types
-// accepts a CoinAccountSelectorType config object
-// NOT IMPLEMENTED: imported addresses/accounts
-export const getAccounts = createDeepEqualSelector(
-  [
-    coreSelectors.data.eth.getAddresses, // non-custodial accounts
-    coreSelectors.kvStore.eth.getAccounts, // non-custodial metadata
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (ethDataR, ethMetadataR, sbBalanceR, ownProps) => {
-    const transform = (ethData, ethMetadata, sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
-      const { coin } = ownProps
-      let accounts: SwapAccountType[] = []
-
-      // add non-custodial accounts if requested
-      if (ownProps?.nonCustodialAccounts) {
-        accounts = accounts.concat(
-          ethMetadata.map((acc) => {
-            const address = prop('addr', acc)
-            const data = prop(address, ethData)
-
-            return {
-              address,
-              balance: prop('balance', data),
-              baseCoin: coin,
-              coin,
-              label: prop('label', acc) || address,
-              type: ADDRESS_TYPES.ACCOUNT
-            }
-          })
-        )
-      }
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
-      }
-
-      return accounts
-    }
-
-    return lift(transform)(ethDataR, ethMetadataR, sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eur.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eur.tsx
deleted file mode 100644
index dd1a264f9b9..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/eur.tsx
+++ /dev/null
@@ -1,10 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.eur.intro'
-    defaultMessage='Store Euros in your wallet and use it to Buy crypto.'
-  />
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/gbp.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/gbp.tsx
deleted file mode 100644
index d99ab1019e0..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/gbp.tsx
+++ /dev/null
@@ -1,10 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.gbp.intro'
-    defaultMessage='Store British pounds in your wallet and use it to Buy crypto.'
-  />
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/usd.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/usd.tsx
deleted file mode 100644
index b333a9695c9..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/usd.tsx
+++ /dev/null
@@ -1,10 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.usd.intro'
-    defaultMessage='Store U.S. dollars in your wallet and use it to Buy crypto.'
-  />
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/xlm.tsx b/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/xlm.tsx
deleted file mode 100644
index 5ae10dff007..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/selectors/coins/xlm.tsx
+++ /dev/null
@@ -1,78 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import { lift, path, prop, propEq } from 'ramda'
-
-import { coreSelectors } from '@core'
-import { BSBalanceType } from '@core/network/api/buySell/types'
-import { ADDRESS_TYPES } from '@core/redux/payment/btc/utils'
-import { ExtractSuccess } from '@core/remote/types'
-import { createDeepEqualSelector } from '@core/utils'
-import { selectors } from 'data'
-import { generateTradingAccount } from 'data/coins/utils'
-import { convertStandardToBase } from 'data/components/exchange/services'
-import { SwapAccountType } from 'data/types'
-
-// retrieves introduction text for coin on its transaction page
-export const getTransactionPageHeaderText = () => (
-  <FormattedMessage
-    id='coins.xlm.intro'
-    defaultMessage='Stellar (XLM) connects banks, payments and you to the Stellar Payment network.'
-  />
-)
-
-// main selector for all XLM account types
-// accepts a CoinAccountSelectorType config object
-// NOT IMPLEMENTED FOR COIN: imported addresses/accounts
-export const getAccounts = createDeepEqualSelector(
-  [
-    coreSelectors.data.xlm.getAccounts, // non-custodial accounts
-    coreSelectors.kvStore.xlm.getAccounts, // non-custodial metadata
-    (state, { coin }) => selectors.balances.getCoinTradingBalance(coin, state), // custodial accounts
-    (state, ownProps) => ownProps // selector config
-  ],
-  (xlmData, xlmMetadataR, sbBalanceR, ownProps) => {
-    const transform = (xlmMetadata, sbBalance: ExtractSuccess<typeof sbBalanceR>) => {
-      const { coin } = ownProps
-      let accounts: SwapAccountType[] = []
-
-      // add non-custodial accounts if requested
-      if (ownProps?.nonCustodialAccounts) {
-        accounts = accounts.concat(
-          xlmMetadata
-            .map((acc) => {
-              const address = prop('publicKey', acc)
-              const account = prop(address, xlmData)
-              const noAccount = path(['error', 'message'], account) === 'Not Found'
-              const balance = convertStandardToBase(
-                coin,
-                account
-                  // @ts-ignore
-                  .map(coreSelectors.data.xlm.selectBalanceFromAccount)
-                  .getOrElse(0)
-              )
-              return {
-                address,
-                archived: prop('archived', acc) || false,
-                balance,
-                baseCoin: coin,
-                coin,
-                label: prop('label', acc) || address,
-                noAccount,
-                type: ADDRESS_TYPES.ACCOUNT
-              }
-            })
-            .filter(propEq('archived', false))
-        )
-      }
-
-      // add trading accounts if requested
-      if (ownProps?.tradingAccounts) {
-        accounts = accounts.concat(generateTradingAccount(coin, sbBalance as BSBalanceType))
-      }
-
-      return accounts
-    }
-
-    return lift(transform)(xlmMetadataR, sbBalanceR)
-  }
-)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/types.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/types.ts
index 52198727b56..fcbee25e318 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/types.ts
@@ -1,3 +1,6 @@
+import { PubkeyServiceSubscriptions } from '@core/network/api/coins/types'
+import { RemoteDataType } from '@core/types'
+
 export type CoinAccountSelectorType = {
   coins?: Array<string>
   importedAddresses?: boolean
@@ -5,3 +8,7 @@ export type CoinAccountSelectorType = {
   nonCustodialAccounts?: boolean
   tradingAccounts?: boolean
 }
+
+export type CoinsStateType = {
+  subscriptions: RemoteDataType<string, PubkeyServiceSubscriptions>
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/coins/utils.ts b/packages/blockchain-wallet-v4-frontend/src/data/coins/utils.ts
index d390c117d70..25eb6b4dc05 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/coins/utils.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/coins/utils.ts
@@ -1,4 +1,4 @@
-import { BSBalanceType, CoinType, EarnBalanceType } from '@core/types'
+import { BSBalanceType, CoinfigType, CoinType, EarnBalanceType } from '@core/types'
 import { convertStandardToBase } from 'data/components/exchange/services'
 import { SwapAccountType, SwapBaseCounterTypes } from 'data/types'
 
@@ -57,3 +57,11 @@ export const generateProvisionalPaymentAmount = (
 
   return convertStandardToBase(coin, amount)
 }
+
+export const getSymbolWithParentChain = (coinfig: CoinfigType) => {
+  if (coinfig.symbol.includes('.') && coinfig.type.parentChain) {
+    return `${coinfig.displaySymbol} - ${coinfig.type.parentChain}`
+  }
+
+  return coinfig.displaySymbol
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/model.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/model.ts
index 68c2d424a63..1fda4645bdd 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/model.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/model.ts
@@ -40,8 +40,6 @@ export const CARD_ORDER_POLLING = {
 export const LIMIT = { max: '10000', min: '500' } as Limits
 export const LIMIT_FACTOR = 100 // we get 10000 from API
 
-export const SDD_TIER = 3
-
 export enum BS_ERROR {
   APPLE_PAY_INFO_NOT_FOUND = 'APPLE_PAY_INFO_NOT_FOUND',
   APPLE_PAY_SESSION_NOT_SUPPORTED = 'APPLE_PAY_SESSION_NOT_SUPPORTED',
@@ -64,6 +62,7 @@ export enum BS_ERROR {
   ORDER_NOT_FOUND = 'ORDER_NOT_FOUND',
   ORDER_VALUE_CHANGED = 'ORDER_VALUE_CHANGED',
   ORDER_VERIFICATION_TIMED_OUT = 'ORDER_VERIFICATION_TIMED_OUT',
+  ORDER_VERIFICATION_UNEXPECTED_ERROR = 'ORDER_VERIFICATION_UNEXPECTED_ERROR',
   RETRYING_TO_GET_AUTH_URL = 'RETRYING_TO_GET_AUTH_URL',
   UNHANDLED_PAYMENT_STATE = 'UNHANDLED_PAYMENT_STATE',
   USER_CANCELLED_APPLE_PAY = 'USER_CANCELLED_APPLE_PAY',
@@ -104,6 +103,7 @@ export enum ORDER_ERROR_CODE {
   CARD_PAYMENT_INSUFFICIENT_FUNDS = 'CARD_PAYMENT_INSUFFICIENT_FUNDS',
   CARD_PAYMENT_NOT_SUPPORTED = 'CARD_PAYMENT_NOT_SUPPORTED',
 
+  ORDER_CVV_UPDATE_ERROR = 'ORDER_CVV_UPDATE_ERROR',
   ORDER_FAILED_AFTER_POLL = 'ORDER_FAILED_AFTER_POLL'
   // TODO implement later
   // "BANK_TRANSFER_ACCOUNT_ALREADY_LINKED"
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/sagas.ts
index 71e362a16b9..d0caf987d16 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/sagas.ts
@@ -73,15 +73,16 @@ import {
   GOOGLE_PAY_MERCHANT_ID,
   isFiatCurrencySupported,
   ORDER_ERROR_CODE,
-  ORDER_POLLING,
-  SDD_TIER
+  ORDER_POLLING
 } from './model'
 import { createBuyQuoteLoopAndWaitForFirstResult } from './sagas/createBuyQuoteLoopAndWaitForFirstResult'
 import { updateCardCvvAndPollOrder } from './sagas/updateCardCvvAndPollOrder'
 import * as S from './selectors'
+import { getIsSddFlow } from './selectors/getIsSddFlow'
 import { actions as A } from './slice'
 import * as T from './types'
 import { getDirection, getEnterAmountStepType, getQuoteRefreshConfig, reversePair } from './utils'
+import * as SddFlow from './utils/sddFlow'
 
 export const logLocation = 'components/buySell/sagas'
 
@@ -602,8 +603,8 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
 
   const asyncOrderConfirmCheck = function* (orderId) {
     try {
-      // When isAsync is true on the confirm request this call can return the "ux" nabu error but the request is still
-      // techniclly not an http error (ex. 400, 500) and so we need to catch it and manually return the order info "dataFields"
+      // When isAsync is true on the confirm request this call can return the "ux" NABU error but the request is still
+      // technically not an http error (ex. 400, 500) and so we need to catch it and manually return the order info "dataFields"
       const order: ReturnType<typeof api.getBSOrder> = yield call(api.getBSOrder, orderId)
       if (order.state === 'FINISHED' || order.state === 'FAILED' || order.state === 'CANCELED') {
         return order
@@ -631,12 +632,19 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
     throw new Error(BS_ERROR.ORDER_VERIFICATION_TIMED_OUT)
   }
 
-  const orderConfirmCheck = function* (orderId) {
-    const order: ReturnType<typeof api.getBSOrder> = yield call(api.getBSOrder, orderId)
-    if (order.state === 'FINISHED' || order.state === 'FAILED' || order.state === 'CANCELED') {
-      return order
-    }
+  const orderConfirmCheck = function* (orderId: string) {
+    try {
+      const order: ReturnType<typeof api.getBSOrder> = yield call(api.getBSOrder, orderId)
 
+      if (order.state === 'FINISHED' || order.state === 'FAILED' || order.state === 'CANCELED') {
+        return order
+      }
+    } catch (e) {
+      return {
+        error: e,
+        type: BS_ERROR.ORDER_VERIFICATION_UNEXPECTED_ERROR
+      }
+    }
     throw new Error(BS_ERROR.ORDER_VERIFICATION_TIMED_OUT)
   }
 
@@ -650,6 +658,10 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
     const confirmedOrder = yield retry(RETRY_AMOUNT, SECONDS, orderConfirmCheck, payload.id)
     yield put(actions.form.stopSubmit(FORM_BS_CHECKOUT_CONFIRM))
 
+    if (confirmedOrder.type === BS_ERROR.ORDER_VERIFICATION_UNEXPECTED_ERROR) {
+      throw confirmedOrder.error
+    }
+
     if (confirmedOrder.paymentError) {
       throw new Error(confirmedOrder.paymentError)
     }
@@ -1012,15 +1024,18 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
         }
 
         try {
-          // Inside the polling, if the order is finished, we set the order success and set the step to ORDER_SUMMARY
           yield call(confirmOrderPoll, A.confirmOrderPoll(confirmedOrder), CARD_ORDER_POLLING)
         } catch (e) {
-          // Exhausted the retry attempts, so just show the order summary with the order we have
-          yield put(A.confirmOrderSuccess(confirmedOrder))
+          const error = errorHandler(e)
+          if (error === BS_ERROR.ORDER_VERIFICATION_TIMED_OUT) {
+            yield put(A.confirmOrderSuccess(confirmedOrder))
 
-          yield put(cacheActions.removeLastUsedAmount({ pair: confirmedOrder.pair }))
+            yield put(cacheActions.removeLastUsedAmount({ pair: confirmedOrder.pair }))
 
-          yield put(A.setStep({ step: 'ORDER_SUMMARY' }))
+            yield put(A.setStep({ step: 'ORDER_SUMMARY' }))
+          } else {
+            throw e
+          }
         }
       } else if (
         confirmedOrder.attributes?.everypay ||
@@ -1206,12 +1221,6 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
     try {
       yield call(waitForUserData)
 
-      yield call(fetchSDDVerified)
-      const isUserTier2 = yield call(isTier2)
-      const sddVerified = S.isUserSddVerified(yield select()).getOrElse(false)
-      const loadCards = isUserTier2 || sddVerified
-
-      if (!loadCards) return yield put(A.fetchCardsSuccess([]))
       if (!payload) yield put(A.fetchCardsLoading())
 
       useNewPaymentProviders = (yield select(
@@ -1390,28 +1399,18 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
         S.getFiatCurrency(yield select()) ||
         (yield select(selectors.core.settings.getCurrency)).getOrElse('USD')
 
-      const userSDDTierR = S.getUserSddEligibleTier(yield select())
-      if (!Remote.Success.is(userSDDTierR)) {
-        yield call(fetchSDDEligible)
-      }
       const state = yield select()
       const currentUserTier = selectors.modules.profile
         .getCurrentTier(state)
         .getOrFail('User has no tier')
-      const userSDDEligibleTier = S.getUserSddEligibleTier(state).getOrElse(1)
-      // only fetch non-eligible payment methods if user is not tier 2
-      const includeNonEligibleMethods = currentUserTier === 2
-      // if user is SDD tier 3 eligible, fetch limits for tier 3
-      // else let endpoint return default current tier limits for current tier of user
-      // double check if user is tier 2 and in case user is ignore this property
-      const includeTierLimits =
-        userSDDEligibleTier === SDD_TIER && currentUserTier !== 2 ? SDD_TIER : undefined
+
+      // Present all possible (but necessarily eligible) payment methods to SDD users
+      const includeEligibleOnlyPaymentMethods = currentUserTier === 2
 
       let paymentMethods = yield call(
         api.getBSPaymentMethods,
         payload || fallbackFiatCurrency,
-        includeNonEligibleMethods,
-        includeTierLimits
+        includeEligibleOnlyPaymentMethods
       )
 
       // 🚨👋 temporarily remove ACH from user payment methods if they are not t2
@@ -1665,37 +1664,17 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
     const pair = S.getBSPair(yield select())
     const swapAccount = S.getSwapAccount(yield select())
     if (!pair) throw new Error(BS_ERROR.NO_PAIR_SELECTED)
-    const isUserTier2 = yield call(isTier2)
 
-    if (!isUserTier2) {
-      switch (method.type) {
-        // https://blockc.slack.com/archives/GT1JZ1ZN2/p1596546978351100?thread_ts=1596541628.345800&cid=GT1JZ1ZN2
-        // REMOVE THIS WHEN BACKEND CAN HANDLE PENDING 'FUNDS' ORDERS
-        // 👇--------------------------------------------------------
-        case BSPaymentTypes.BANK_ACCOUNT:
-        case BSPaymentTypes.USER_CARD:
-          return yield put(
-            A.setStep({
-              step: 'KYC_REQUIRED'
-            })
-          )
-        // REMOVE THIS WHEN BACKEND CAN HANDLE PENDING 'FUNDS' ORDERS
-        // 👆--------------------------------------------------------
-        case BSPaymentTypes.PAYMENT_CARD:
-          // ADD THIS WHEN BACKEND CAN HANDLE PENDING 'FUNDS' ORDERS
-          // 👇-----------------------------------------------------
-          // const methodType =
-          //   method.type === BSPaymentTypes.BANK_ACCOUNT ? BSPaymentTypes.FUNDS : method.type
-          // return yield put(A.createOrder(undefined, methodType))
-          // 👆------------------------------------------------------
-
-          return yield put(A.createOrder({ paymentType: method.type }))
-        default:
-          return
-      }
+    const isSddFlow = getIsSddFlow(yield select()).getOrElse(false)
+    const isAllowedPaymentType = SddFlow.isAllowedPaymentType(method, mobilePaymentMethod)
+    if (isSddFlow && !isAllowedPaymentType) {
+      return yield put(
+        A.setStep({
+          step: 'KYC_REQUIRED'
+        })
+      )
     }
 
-    // User is Tier 2
     switch (method.type) {
       case BSPaymentTypes.BANK_ACCOUNT:
         return yield put(
@@ -1971,6 +1950,11 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
         ) {
           yield cancel()
         }
+
+        // In case that transaction is pending and waiting for 3DS response we do not need to poll to the end of poll cycle
+        if (order.attributes?.cardCassy?.paymentState === 'WAITING_FOR_3DS_RESPONSE') {
+          break
+        }
         yield delay(2000)
       }
 
@@ -1983,6 +1967,8 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
       } else {
         yield put(A.createOrderFailure(ORDER_ERROR_CODE.ORDER_FAILED_AFTER_POLL))
       }
+      // return back to ORDER_SUMMARY and show the error
+      yield put(A.setStep({ step: 'ORDER_SUMMARY' }))
     }
   }
 
@@ -2309,8 +2295,9 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
       yield put(A.cvvStatusLoading())
       yield call(api.updateCardCvv, payload)
       yield put(A.cvvStatusSuccess())
-    } catch (e) {
-      yield put(A.cvvStatusFailure())
+    } catch (error) {
+      const errorPayload = isNabuError(error) ? error : ORDER_ERROR_CODE.ORDER_CVV_UPDATE_ERROR
+      yield put(A.cvvStatusFailure(errorPayload))
     }
   }
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/selectors/getIsSddFlow.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/selectors/getIsSddFlow.ts
new file mode 100644
index 00000000000..96a138d9472
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/selectors/getIsSddFlow.ts
@@ -0,0 +1,9 @@
+import { createSelector } from 'reselect'
+
+import { getUserData } from 'data/modules/profile/selectors'
+
+import * as SddFlow from '../utils/sddFlow'
+
+export const getIsSddFlow = createSelector([getUserData], (userDataR) =>
+  userDataR.map(SddFlow.isSddUser)
+)
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/slice.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/slice.ts
index e65ad81fe95..90d5f7892ee 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/slice.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/slice.ts
@@ -44,6 +44,7 @@ import {
   StepActionsPayload,
   SwapAccountType
 } from 'data/types'
+import { NabuError } from 'services/errors'
 
 import { getCoinFromPair, getFiatFromPair } from './model'
 import { BSCardSuccessRateType, BuySellState } from './types'
@@ -166,8 +167,8 @@ const buySellSlice = createSlice({
       state.order = Remote.Success(action.payload)
       state.pendingOrder = action.payload
     },
-    cvvStatusFailure: (state) => {
-      state.cvvStatus = Remote.Failure('The code entered is either invalid or expired. Try Again.')
+    cvvStatusFailure: (state, action: PayloadAction<string | NabuError>) => {
+      state.cvvStatus = Remote.Failure(action.payload)
     },
     cvvStatusLoading: (state) => {
       state.cvvStatus = Remote.Loading
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/types.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/types.ts
index b9722e60bae..c818b7760b6 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/types.ts
@@ -32,6 +32,7 @@ import { PartialClientErrorProperties } from 'data/analytics/types/errors'
 import type { CountryType } from 'data/components/identityVerification/types'
 import type { RecurringBuyPeriods } from 'data/components/recurringBuy/types'
 import type { SwapAccountType, SwapBaseCounterTypes } from 'data/components/swap/types'
+import { NabuError } from 'services/errors'
 
 import { BankDWStepType, PlaidSettlementErrorReasons } from '../brokerage/types'
 
@@ -189,7 +190,7 @@ export type BuySellState = {
   checkoutDotComApiKey?: string
   crossBorderLimits: RemoteDataType<unknown, CrossBorderLimits>
   cryptoCurrency?: CoinType
-  cvvStatus: RemoteDataType<string, boolean>
+  cvvStatus: RemoteDataType<string | NabuError, boolean>
   displayBack: boolean
   fiatCurrency?: FiatType
   fiatEligible: RemoteDataType<PartialClientErrorProperties | Error, FiatEligibleType>
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.test.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.test.ts
new file mode 100644
index 00000000000..83f4c445e1a
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.test.ts
@@ -0,0 +1,74 @@
+import {
+  BSPaymentMethodType,
+  BSPaymentTypes,
+  MobilePaymentType
+} from '@core/network/api/buySell/types'
+import { Tiers, UserDataType } from 'data/modules/profile/types'
+
+import * as SddFlow from './sddFlow'
+
+describe('SddFlow', () => {
+  describe('isSddUser', () => {
+    const makeUserDataStub = (currentTier: Tiers['current']) => {
+      const tiers: Tiers = {
+        current: currentTier,
+        next: 2,
+        selected: 2
+      }
+
+      return {
+        tiers
+      } as UserDataType
+    }
+
+    describe('when user current tier is 1', () => {
+      it('should return true', () => {
+        const userDataStub = makeUserDataStub(1)
+
+        expect(SddFlow.isSddUser(userDataStub)).toBe(true)
+      })
+    })
+
+    describe('otherwise', () => {
+      it.each([0, 2] as const)('should return false %#', (tier) => {
+        const userDataStub = makeUserDataStub(tier)
+
+        expect(SddFlow.isSddUser(userDataStub)).toBe(false)
+      })
+    })
+  })
+
+  describe('isAllowedPaymentType', () => {
+    const makePaymentMethodStub = (type: BSPaymentTypes) =>
+      ({
+        type
+      } as BSPaymentMethodType)
+
+    describe('when payment method is card and it is not mobile payment', () => {
+      it('should return true', () => {
+        const paymentStub = makePaymentMethodStub(BSPaymentTypes.PAYMENT_CARD)
+
+        expect(SddFlow.isAllowedPaymentType(paymentStub, undefined)).toBe(true)
+      })
+    })
+
+    describe('when payment method is card and it is mobile payment', () => {
+      it('should return false', () => {
+        const paymentStub = makePaymentMethodStub(BSPaymentTypes.PAYMENT_CARD)
+
+        expect(SddFlow.isAllowedPaymentType(paymentStub, MobilePaymentType.APPLE_PAY)).toBe(false)
+      })
+    })
+
+    describe('when payment method is not card', () => {
+      it.each([BSPaymentTypes.BANK_TRANSFER, BSPaymentTypes.FUNDS])(
+        'should return false %#',
+        (paymentType) => {
+          const paymentStub = makePaymentMethodStub(paymentType)
+
+          expect(SddFlow.isAllowedPaymentType(paymentStub, undefined)).toBe(false)
+        }
+      )
+    })
+  })
+})
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.ts
new file mode 100644
index 00000000000..bcab7abfc03
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/buySell/utils/sddFlow.ts
@@ -0,0 +1,28 @@
+import {
+  BSPaymentMethodType,
+  BSPaymentTypes,
+  MobilePaymentType
+} from '@core/network/api/buySell/types'
+import { UserDataType } from 'data/modules/profile/types'
+
+/**
+ * Back-End allows only T1 SDD eligible+verified and T2 users to access Buy/Sell flows.
+ * Thus, for purpose of these flows, T1 users are SDD users.
+ */
+const TIER = 1
+
+export const isSddUser = (userData: UserDataType) => {
+  const currentTier = userData.tiers.current
+
+  return currentTier === TIER
+}
+
+export const isAllowedPaymentType = (
+  method: BSPaymentMethodType,
+  mobilePaymentType?: MobilePaymentType
+) => {
+  const isCardPayment = method.type === BSPaymentTypes.PAYMENT_CARD
+  const isMobilePayment = !!mobilePaymentType
+
+  return isCardPayment && !isMobilePayment
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/coinTransactions/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/coinTransactions/sagas.ts
index 17b80838d64..9a4f0993a72 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/coinTransactions/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/coinTransactions/sagas.ts
@@ -9,7 +9,9 @@ export const logLocation = 'components/coinTransactions/sagas'
 export default () => {
   const initialized = function* (action: ReturnType<typeof A.initialized>) {
     try {
-      yield put(actions.core.data.coins.fetchTransactions(action.payload.coin, true))
+      yield put(
+        actions.core.data.coins.fetchTransactions({ coin: action.payload.coin, reset: true })
+      )
     } catch (e) {
       yield put(actions.logs.logErrorMessage(logLocation, 'initialized', e))
     }
@@ -17,7 +19,7 @@ export default () => {
 
   const loadMore = function* (action: ReturnType<typeof A.loadMore>) {
     try {
-      yield put(actions.core.data.coins.fetchTransactions(action.payload.coin))
+      yield put(actions.core.data.coins.fetchTransactions({ coin: action.payload.coin }))
     } catch (e) {
       yield put(actions.logs.logErrorMessage(logLocation, 'loadMore', e))
     }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/interest/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/interest/sagas.ts
index 4e762aee839..7f6075768d8 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/interest/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/interest/sagas.ts
@@ -25,6 +25,7 @@ import {
 } from '@core/types'
 import { errorHandler, errorHandlerCode } from '@core/utils'
 import { actions, selectors } from 'data'
+import { CoinAccountTypeEnum } from 'data/coins/accountTypes/accountTypes.classes'
 import coinSagas from 'data/coins/sagas'
 import { generateProvisionalPaymentAmount } from 'data/coins/utils'
 import profileSagas from 'data/modules/profile/sagas'
@@ -1214,8 +1215,17 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
           origin
         })
       } else {
-        const receiveAddress = yield call(getNextReceiveAddressForCoin, coin)
-        yield call(api.initiateInterestWithdrawal, withdrawalAmountBase, coin, receiveAddress)
+        const receiveAddress: ReturnType<typeof getNextReceiveAddressForCoin> = yield call(
+          getNextReceiveAddressForCoin,
+          coin,
+          CoinAccountTypeEnum.NON_CUSTODIAL
+        )
+        yield call(
+          api.initiateInterestWithdrawal,
+          withdrawalAmountBase,
+          coin,
+          receiveAddress.address
+        )
       }
 
       // notify success
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/nfts/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/nfts/sagas.ts
index 1bdf7561f13..06fcf8e56a0 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/nfts/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/nfts/sagas.ts
@@ -419,8 +419,7 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas; network
           value: amtToWrap
         })
         yield call(executeWrapEth, signer, amount, wrapFees)
-        yield put(actions.core.data.eth.fetchData())
-        yield put(actions.core.data.eth.fetchErc20Data())
+        yield put(actions.core.data.coins.fetchUnifiedBalances())
       }
 
       yield put(A.setOrderFlowStep({ step: NftOrderStepEnum.STATUS }))
@@ -1146,8 +1145,7 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas; network
           value: action.payload.amtToWrap
         })
         yield call(executeWrapEth, signer, amount, action.payload.wrapFees)
-        yield put(actions.core.data.eth.fetchData())
-        yield put(actions.core.data.eth.fetchErc20Data())
+        yield put(actions.core.data.coins.fetchUnifiedBalances())
       }
 
       yield put(A.setOrderFlowStep({ step: NftOrderStepEnum.STATUS }))
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/refresh/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/refresh/sagas.ts
index 16e9a45f54a..a6b0a2a0ba0 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/refresh/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/refresh/sagas.ts
@@ -23,7 +23,7 @@ export default () => {
   }
 
   const refreshCoinTransactions = function* (coin) {
-    yield put(actions.core.data.coins.fetchTransactions(coin, true))
+    yield put(actions.core.data.coins.fetchTransactions({ coin, reset: true }))
   }
 
   const refreshXlmTransactions = function* () {
@@ -42,18 +42,11 @@ export default () => {
       yield put(actions.core.data.bch.fetchData())
       yield put(actions.core.data.btc.fetchData())
       yield put(actions.core.data.eth.fetchData())
-      yield put(actions.core.data.xlm.fetchData())
-      yield put(actions.core.data.eth.fetchErc20Data())
       yield put(actions.components.interest.fetchRewardsBalance())
       yield put(actions.components.interest.fetchStakingBalance())
       yield put(actions.components.interest.fetchActiveRewardsBalance())
       yield put(actions.components.buySell.fetchBalance({}))
       yield put(actions.components.buySell.fetchOrders())
-      // TODO: SELF_CUSTODY, remove
-      const stxEligibility = selectors.coins.getStxSelfCustodyAvailability(yield select())
-      if (stxEligibility) {
-        yield put(actions.core.data.coins.fetchData())
-      }
       // Prices (new approach)
       yield put(actions.prices.fetchCoinPrices())
       // Rates
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/request/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/request/sagas.ts
index e652c0253ed..769914e2ae4 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/request/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/request/sagas.ts
@@ -1,12 +1,15 @@
-import { call, CallEffect, put, PutEffect, SelectEffect } from 'redux-saga/effects'
+import { call, CallEffect, put, PutEffect, select, SelectEffect } from 'redux-saga/effects'
 
 import { APIType } from '@core/network/api'
 import { errorHandler } from '@core/utils'
+import { actions } from 'data'
+import { CoinAccountTypeEnum } from 'data/coins/accountTypes/accountTypes.classes'
 
 import coinSagas from '../../coins/sagas'
 import profileSagas from '../../modules/profile/sagas'
 import { SwapBaseCounterTypes } from '../swap/types'
 import * as A from './actions'
+import * as S from './selectors'
 import { RequestExtrasType } from './types'
 import { generateKey } from './utils'
 
@@ -23,33 +26,35 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
     action: ReturnType<typeof A.getNextAddress>
   ): Generator<CallEffect | PutEffect | SelectEffect, void, any> {
     const key = generateKey(action.payload.account)
+    yield call(waitForUserData)
     try {
       yield put(A.getNextAddressLoading(key))
       let address
-      const extras: RequestExtrasType = {}
+      let extras: RequestExtrasType = {}
       const { account } = action.payload
+      const { coinfig } = window.coins[account.coin]
 
+      const subscriptions = S.getSubscriptions(yield select())
+      const isSubscribed = subscriptions.data.currencies.some((c) => c.ticker === account.baseCoin)
+      if (!isSubscribed) {
+        yield put(actions.core.data.coins.subscribe(account.baseCoin))
+      }
       switch (account.type) {
         case SwapBaseCounterTypes.ACCOUNT:
-          const { accountIndex, coin } = account
-          address = yield call(getNextReceiveAddressForCoin, coin, accountIndex)
-          break
         case SwapBaseCounterTypes.CUSTODIAL:
-          yield call(waitForUserData)
-          const custodial: ReturnType<typeof api.getBSPaymentAccount> = yield call(
-            // @ts-ignore
-            api.getBSPaymentAccount,
-            account.coin
-          )
-          address = custodial.address
-          if (window.coins[account.coin].coinfig.type.isMemoBased && address.split(':')[1]) {
-            // eslint-disable-next-line prefer-destructuring
-            extras.Memo = address.split(':')[1]
-            // eslint-disable-next-line prefer-destructuring
-            address = address.split(':')[0]
-          }
+          const { accountIndex, coin } = account
+          const accountType =
+            account.type === SwapBaseCounterTypes.ACCOUNT
+              ? coinfig.products.includes('DynamicSelfCustody')
+                ? CoinAccountTypeEnum.DYNAMIC_SELF_CUSTODY
+                : coinfig.type.name === 'ERC20'
+                ? CoinAccountTypeEnum.ERC20
+                : CoinAccountTypeEnum.NON_CUSTODIAL
+              : CoinAccountTypeEnum.CUSTODIAL
+          const response = yield call(getNextReceiveAddressForCoin, coin, accountType, accountIndex)
+          address = response.address
+          extras = response.extras
           break
-        // SwapAccountType only supports ACCOUNT and CUSTODIAL?
         // @ts-ignore
         case 'LEGACY':
           address = account.address
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/request/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/request/selectors.ts
index 0b898413349..c696cbb62f8 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/request/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/request/selectors.ts
@@ -6,3 +6,5 @@ import { SwapAccountType } from '../swap/types'
 export const getNextAddress = (state: RootState, account: SwapAccountType) => {
   return state.components.request[`${account.coin} ${account.label}`] || Remote.NotAsked
 }
+
+export const getSubscriptions = (state: RootState) => state.dataPath.coins.subscriptions
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/sagas.ts
index 04d2d8fa6a9..0ab0627d2d8 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/sagas.ts
@@ -1,11 +1,13 @@
 import { SEND_FORM } from 'blockchain-wallet-v4-frontend/src/modals/SendCrypto/model'
 import { SendFormType } from 'blockchain-wallet-v4-frontend/src/modals/SendCrypto/types'
+import * as ethers from 'ethers'
 import { call, delay, put, select } from 'redux-saga/effects'
 import secp256k1 from 'secp256k1'
 
 import { convertCoinToCoin, convertFiatToCoin } from '@core/exchange'
 import { APIType } from '@core/network/api'
-import { BuildTxIntentType, BuildTxResponseType } from '@core/network/api/coin/types'
+import { BuildTxIntentType, BuildTxResponseType } from '@core/network/api/coins/types'
+import { getCoinNetworksAndTypes } from '@core/redux/data/coins/selectors'
 import { getPrivKey, getPubKey } from '@core/redux/data/self-custody/sagas'
 import { FiatType, WalletAccountEnum } from '@core/types'
 import { errorHandler } from '@core/utils'
@@ -20,6 +22,14 @@ import * as S from './selectors'
 import { actions as A } from './slice'
 import { SendCryptoStepType } from './types'
 
+const getNetwork = (coin: string) => {
+  if (coin.includes('.')) {
+    return coin.split('.')[1]
+  }
+
+  return coin
+}
+
 export default ({ api }: { api: APIType }) => {
   const initializeSend = function* () {
     const totalBalanceR = yield select(selectors.balances.getTotalWalletBalanceNotFormatted)
@@ -44,18 +54,18 @@ export default ({ api }: { api: APIType }) => {
 
       if (account.type === SwapBaseCounterTypes.ACCOUNT) {
         const password = yield call(promptForSecondPassword)
-        const pubKey = yield call(getPubKey, password)
+        const pubKey = yield call(getPubKey, coin, password)
         const guid = yield select(selectors.core.wallet.getGuid)
         const [uuid] = yield call(api.generateUUIDs, 1)
 
-        const tx: ReturnType<typeof api.buildTx> = yield call(api.buildTx, {
+        const tx: ReturnType<typeof api.buildTx> = yield call(api.buildTx, coin, {
           id: {
             guid,
             uuid
           },
           intent: {
             amount: baseCryptoAmt,
-            currency: coin,
+            currency: 'native',
             destination,
             extraData: {
               memo
@@ -69,7 +79,8 @@ export default ({ api }: { api: APIType }) => {
               }
             ],
             type: 'PAYMENT'
-          } as BuildTxIntentType
+          } as BuildTxIntentType,
+          network: getNetwork(coin)
         })
 
         yield put(A.buildTxSuccess(tx))
@@ -202,8 +213,8 @@ export default ({ api }: { api: APIType }) => {
     }
   }
 
-  const signTx = function* (prebuildTx: BuildTxResponseType, password: string) {
-    const privateKey = yield call(getPrivKey, password)
+  const signTx = function* (coin: string, prebuildTx: BuildTxResponseType, password: string) {
+    const privateKey = yield call(getPrivKey, coin, password)
 
     if (!privateKey) throw new Error('Could not derive private key')
 
@@ -211,7 +222,10 @@ export default ({ api }: { api: APIType }) => {
     const signedPreImages = prebuildTx.preImages.map((preImage) => {
       // @ts-ignore
       const { recovery, signature } = secp256k1.sign(
-        Buffer.from(preImage.preImage, 'hex'),
+        Buffer.from(
+          preImage.preImage.startsWith('0x') ? preImage.preImage.substr(2) : preImage.preImage,
+          'hex'
+        ),
         Buffer.from(privateKey, 'hex')
       )
 
@@ -255,7 +269,7 @@ export default ({ api }: { api: APIType }) => {
           'No prebuildTx'
         ) as BuildTxResponseType
         prebuildTxFee = prebuildTx.summary.absoluteFeeEstimate
-        const signedTx: BuildTxResponseType = yield call(signTx, prebuildTx, password)
+        const signedTx: BuildTxResponseType = yield call(signTx, coin, prebuildTx, password)
         const pushedTx: ReturnType<typeof api.pushTx> = yield call(
           api.pushTx,
           coin,
@@ -264,7 +278,8 @@ export default ({ api }: { api: APIType }) => {
           {
             guid,
             uuid
-          }
+          },
+          getNetwork(coin)
         )
 
         const value = convertCoinToCoin({
@@ -280,7 +295,7 @@ export default ({ api }: { api: APIType }) => {
             })
           )
           yield delay(2000)
-          yield put(actions.core.data.coins.fetchTransactions(coin, true))
+          yield put(actions.core.data.coins.fetchTransactions({ coin, reset: true }))
         } else {
           throw new Error('Failed to submit transaction.')
         }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/slice.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/slice.ts
index 5115860fe43..7b0dae04b17 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/slice.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/slice.ts
@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { createSlice, PayloadAction } from '@reduxjs/toolkit'
 
-import { BuildTxFeeType, BuildTxResponseType } from '@core/network/api/coin/types'
+import { BuildTxFeeType, BuildTxResponseType } from '@core/network/api/coins/types'
 import Remote from '@core/remote'
 import {
   CrossBorderLimits,
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/types.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/types.ts
index 5f814be72fd..b47c409bed7 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/sendCrypto/types.ts
@@ -1,4 +1,4 @@
-import { BuildTxResponseType } from '@core/network/api/coin/types'
+import { BuildTxResponseType } from '@core/network/api/coins/types'
 import {
   CrossBorderLimits,
   RemoteDataType,
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/sendXlm/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/sendXlm/sagas.ts
index 687c0dc48eb..9e00114e18c 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/sendXlm/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/sendXlm/sagas.ts
@@ -315,7 +315,6 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas: any; ne
       } else {
         payment = yield call(payment.publish)
       }
-      yield put(actions.core.data.xlm.fetchData())
       yield put(A.paymentUpdatedSuccess(value))
       const { description } = value
       if (description) yield put(actions.core.kvStore.xlm.setTxNotesXlm(value.txId, description))
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/swap/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/swap/sagas.ts
index 430054b797c..16fb3ecec2f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/swap/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/swap/sagas.ts
@@ -467,11 +467,12 @@ export default ({ api, coreSagas, networks }: { api: APIType; coreSagas; network
   }
 
   const showModal = function* ({ payload }: ReturnType<typeof A.showModal>) {
-    const { baseCurrency, counterCurrency, origin } = payload
+    const { baseCurrency, counterCurrency, fromType, origin } = payload
     yield put(
       actions.modals.showModal(ModalName.SWAP_MODAL, {
         baseCurrency,
         counterCurrency,
+        fromType,
         origin
       })
     )
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/swap/slice.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/swap/slice.ts
index 836c14208ae..9bad84d0010 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/swap/slice.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/swap/slice.ts
@@ -9,7 +9,8 @@ import {
   PaymentValue,
   SwapOrderType,
   SwapQuoteStateType,
-  SwapUserLimitsType
+  SwapUserLimitsType,
+  WalletAccountSuperAppType
 } from '@core/types'
 import { ModalOriginType } from 'data/modals/types'
 
@@ -149,6 +150,7 @@ const swapSlice = createSlice({
       action: PayloadAction<{
         baseCurrency?: CoinType
         counterCurrency?: CoinType
+        fromType?: WalletAccountSuperAppType
         origin: ModalOriginType
       }>
     ) => {},
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/utils/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/utils/sagas.ts
index c5d5ad4fa59..3354e23389c 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/utils/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/utils/sagas.ts
@@ -1,9 +1,8 @@
 import * as ethers from 'ethers'
-import { equals, identity, is, isEmpty, prop } from 'ramda'
-import { call, select } from 'redux-saga/effects'
+import { equals, is, prop } from 'ramda'
+import { call } from 'redux-saga/effects'
 
-import { utils } from '@core'
-import { selectors } from 'data'
+import { CoinAccountTypeEnum } from 'data/coins/accountTypes/accountTypes.classes'
 
 import coinSagas from '../../coins/sagas'
 
@@ -14,7 +13,6 @@ export const selectReceiveAddress = function* (source, networks, api, coreSagas)
     networks
   })
 
-  const appState = yield select(identity)
   const coin = prop('coin', source)
   const address = prop('address', source)
   const { coinfig } = window.coins[coin]
@@ -23,45 +21,13 @@ export const selectReceiveAddress = function* (source, networks, api, coreSagas)
     return ethers.utils.getAddress(address)
   }
 
-  if (equals('XLM', coin) && is(String, address)) return address
-
-  if (equals('BCH', coin)) {
-    const bchReceiveAddress = selectors.core.common.bch.getNextAvailableReceiveAddress(
-      networks.bch,
-      address,
-      appState
-    )
-
-    if (isEmpty(bchReceiveAddress.getOrElse(''))) {
-      throw new Error('Could not generate bitcoin cash receive address')
-    }
-
-    return utils.bch.toCashAddr(bchReceiveAddress.getOrElse(''))
-  }
-
-  if (equals('BTC', coin)) {
-    const defaultDerivation = selectors.core.common.btc.getAccountDefaultDerivation(
-      address,
-      appState
-    )
-
-    const btcReceiveAddress = selectors.core.common.btc.getNextAvailableReceiveAddress(
-      networks.btc,
-      address,
-      defaultDerivation,
-      appState
-    )
-
-    if (isEmpty(btcReceiveAddress.getOrElse(''))) {
-      throw new Error('Could not generate return bitcoin receive address')
-    }
-
-    return btcReceiveAddress.getOrElse('')
-  }
-
   try {
-    const address = yield call(getNextReceiveAddressForCoin, coin)
-    return address
+    const address: ReturnType<typeof getNextReceiveAddressForCoin> = yield call(
+      getNextReceiveAddressForCoin,
+      CoinAccountTypeEnum.NON_CUSTODIAL,
+      coin
+    )
+    return address.address
   } catch (e) {
     throw new Error('Could not generate receive address')
   }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/components/utils/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/data/components/utils/selectors.ts
index b7e1510f92d..09359f09676 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/components/utils/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/components/utils/selectors.ts
@@ -1,12 +1,6 @@
-import { lift, mapObjIndexed, values } from 'ramda'
+import { lift, mapObjIndexed, uniq, values } from 'ramda'
 
-import {
-  AccountTokensBalancesResponseType,
-  BSPaymentTypes,
-  CoinfigType,
-  ExtractSuccess,
-  SwapOrderType
-} from '@core/types'
+import { BSPaymentTypes, CoinfigType, ExtractSuccess, SwapOrderType } from '@core/types'
 import { selectors } from 'data'
 import { RootState } from 'data/rootReducer'
 import { UserDataType } from 'data/types'
@@ -16,45 +10,27 @@ import { getOutputFromPair } from '../swap/model'
 // eslint-disable-next-line import/prefer-default-export
 export const getCoinsWithBalanceOrMethod = (state: RootState) => {
   const sbMethodsR = selectors.components.buySell.getBSPaymentMethods(state)
-  // TODO: SELF_CUSTODY, remove this
-  const stxEligibility = selectors.coins.getStxSelfCustodyAvailability(state)
-  // TODO, check all custodial features
+  const unifiedBalancesR = selectors.core.data.coins.getUnifiedBalances(state)
   const sbBalancesR = selectors.components.buySell.getBSBalances(state)
-  const erc20sR = selectors.core.data.eth.getErc20AccountTokenBalances(state)
   const recentSwapTxs = selectors.custodial.getRecentSwapTxs(state).getOrElse([] as SwapOrderType[])
   const custodials = selectors.core.data.coins.getCustodialCoins()
   const userData = selectors.modules.profile.getUserData(state).getOrElse({} as UserDataType)
   const fiatCurrencies = userData.currencies?.userFiatCurrencies || []
-  // TODO: SELF_CUSTODY
-  const selfCustodials = stxEligibility ? ['STX'] : []
 
   const transform = (
+    unifiedBalances: ExtractSuccess<typeof unifiedBalancesR>,
     paymentMethods: ExtractSuccess<typeof sbMethodsR>,
-    sbBalances: ExtractSuccess<typeof sbBalancesR>,
-    erc20s: AccountTokensBalancesResponseType['tokenAccounts']
+    sbBalances: ExtractSuccess<typeof sbBalancesR>
   ) => {
-    const custodialErc20s = Object.keys(sbBalances).filter(
-      (coin) => window.coins[coin] && window.coins[coin].coinfig.type.erc20Address
-    )
+    const custodialErc20s = Object.keys(sbBalances)
     const coinsInRecentSwaps = recentSwapTxs.map((tx) => getOutputFromPair(tx.pair))
+    const coinsInUnifiedBalances = uniq(unifiedBalances.map(({ ticker }) => ticker))
+
     const coinOrder = [
       ...new Set([
         ...fiatCurrencies,
-        'BTC',
-        'ETH',
-        'BCH',
-        'XLM',
-        ...selfCustodials,
+        ...coinsInUnifiedBalances,
         ...custodials,
-        ...(erc20s
-          .map(({ tokenHash }) => {
-            return Object.keys(window.coins).find(
-              (coin) =>
-                window.coins[coin].coinfig.type?.erc20Address?.toLowerCase() ===
-                tokenHash.toLowerCase()
-            )
-          })
-          .filter(Boolean) as string[]),
         ...custodialErc20s,
         ...coinsInRecentSwaps
       ])
@@ -77,7 +53,7 @@ export const getCoinsWithBalanceOrMethod = (state: RootState) => {
     )
   }
 
-  return lift(transform)(sbMethodsR, sbBalancesR, erc20sR)
+  return lift(transform)(unifiedBalancesR, sbMethodsR, sbBalancesR)
 }
 
 export default getCoinsWithBalanceOrMethod
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagaRegister.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagaRegister.js
index c221d05487c..584b452dd15 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagaRegister.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagaRegister.js
@@ -2,7 +2,7 @@ import { fork } from 'redux-saga/effects'
 
 import webSocket from './webSocket/sagaRegister'
 
-export default ({ api, coinsSocket, ratesSocket }) =>
+export default ({ activitiesSocket, api, coinsSocket, ratesSocket }) =>
   function* middlewareSaga() {
-    yield fork(webSocket({ api, coinsSocket, ratesSocket }))
+    yield fork(webSocket({ activitiesSocket, api, coinsSocket, ratesSocket }))
   }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagas.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagas.js
index 4eab26a2094..5dfba1a6866 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagas.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/sagas.js
@@ -1,7 +1,8 @@
 import webSocket from './webSocket/sagas'
 
-export default ({ api, coinsSocket, ratesSocket }) => ({
+export default ({ activitiesSocket, api, coinsSocket, ratesSocket }) => ({
   webSocket: webSocket({
+    activitiesSocket,
     api,
     coinsSocket,
     ratesSocket
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actionTypes.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actionTypes.js
index 10836d46837..bdd72f3bd5b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actionTypes.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actionTypes.js
@@ -1,5 +1,6 @@
+import * as activities from './activities/actionTypes'
 import * as coins from './coins/actionTypes'
 import * as rates from './rates/actionTypes'
 import * as xlm from './xlm/actionTypes'
 
-export { coins, rates, xlm }
+export { activities, coins, rates, xlm }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actions.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actions.js
index 511867f27ee..dd33f346127 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actions.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/actions.js
@@ -1,5 +1,6 @@
+import * as activities from './activities/actions'
 import * as coins from './coins/actions'
 import * as rates from './rates/actions'
 import * as xlm from './xlm/actions'
 
-export { coins, rates, xlm }
+export { activities, coins, rates, xlm }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actionTypes.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actionTypes.js
new file mode 100644
index 00000000000..380181abfe0
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actionTypes.js
@@ -0,0 +1,9 @@
+export const START_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_START'
+export const AUTH_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_AUTH'
+export const STOP_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_STOP'
+
+export const OPEN_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_OPEN'
+export const MESSAGE_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_MESSAGE'
+export const CLOSE_SOCKET = '@CORE.ACTIVITIES_WEBSOCKET_CLOSE'
+
+export const RESEND_MESSAGE_SOCKET = '@CORE.RESEND_MESSAGE_SOCKET'
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actions.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actions.js
new file mode 100644
index 00000000000..4ec702585b2
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/actions.js
@@ -0,0 +1,11 @@
+import * as AT from './actionTypes'
+
+export const startSocket = () => ({ type: AT.START_SOCKET })
+export const authSocket = () => ({ type: AT.AUTH_SOCKET })
+export const stopSocket = () => ({ type: AT.STOP_SOCKET })
+
+export const openSocket = () => ({ type: AT.OPEN_SOCKET })
+export const messageSocket = (payload) => ({ payload, type: AT.MESSAGE_SOCKET })
+export const closeSocket = () => ({ type: AT.CLOSE_SOCKET })
+
+export const resendMessageSocket = () => ({ type: AT.RESEND_MESSAGE_SOCKET })
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagaRegister.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagaRegister.js
new file mode 100644
index 00000000000..1648839f3d2
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagaRegister.js
@@ -0,0 +1,15 @@
+import { takeEvery } from 'redux-saga/effects'
+
+import * as AT from './actionTypes'
+import sagas from './sagas'
+
+export default ({ activitiesSocket, api }) => {
+  const activitiesSocketSagas = sagas({ api, socket: activitiesSocket })
+  return function* activitiesSocketSaga() {
+    yield takeEvery(AT.OPEN_SOCKET, activitiesSocketSagas.onOpen)
+    yield takeEvery(AT.AUTH_SOCKET, activitiesSocketSagas.onAuth)
+    yield takeEvery(AT.MESSAGE_SOCKET, activitiesSocketSagas.onMessage)
+    yield takeEvery(AT.CLOSE_SOCKET, activitiesSocketSagas.onClose)
+    yield takeEvery(AT.RESEND_MESSAGE_SOCKET, activitiesSocketSagas.resendMessageSocket)
+  }
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagas.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagas.js
new file mode 100644
index 00000000000..04ab480dcec
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/activities/sagas.js
@@ -0,0 +1,65 @@
+import { prop } from 'ramda'
+import { call, put, select } from 'redux-saga/effects'
+
+import { sha256 } from '@core/walletCrypto'
+import { actions, selectors } from 'data'
+
+export default ({ socket }) => {
+  const authenticateSocket = function* () {
+    const guid = yield select(selectors.core.wallet.getGuid)
+    const sharedKey = yield select(selectors.core.wallet.getSharedKey)
+
+    const guidHash = sha256(guid).toString('hex')
+    const sharedKeyHash = sha256(sharedKey).toString('hex')
+
+    const authParams = {
+      action: 'subscribe',
+      auth: {
+        guidHash,
+        sharedKeyHash
+      },
+      channel: 'activity',
+      params: {
+        // remove hardcoding timezone here??
+        acceptLanguage: 'en-GB;q=1.0, en',
+        fiatCurrency: 'GBP',
+        timezoneIana: 'Europe/London'
+      }
+    }
+
+    socket.send(JSON.stringify(authParams))
+  }
+
+  const onOpen = function* () {
+    yield call(authenticateSocket)
+  }
+
+  const onAuth = function* () {}
+
+  const onMessage = function* (action) {
+    // let pubkeyData = []
+    // pubkeyData.push(action.payload.data)
+    // console.log(action.payload.data.pubKey, action.payload.data.network)
+    // console.log(pubkeyData)
+  }
+
+  const resendMessageSocket = function* (action) {}
+
+  const onClose = function* () {
+    yield put(
+      actions.logs.logErrorMessage(
+        'middleware/webSocket/activities/sagas',
+        'onClose',
+        `websocket closed at ${Date.now()}`
+      )
+    )
+  }
+
+  return {
+    onAuth,
+    onClose,
+    onMessage,
+    onOpen,
+    resendMessageSocket
+  }
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagaRegister.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagaRegister.js
index fd6b64decf8..a79e851cd1b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagaRegister.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagaRegister.js
@@ -1,12 +1,14 @@
 import { fork } from 'redux-saga/effects'
 
+import activities from './activities/sagaRegister'
 import coins from './coins/sagaRegister'
 import rates from './rates/sagaRegister'
 import xlm from './xlm/sagaRegister'
 
-export default ({ api, coinsSocket, ratesSocket }) =>
+export default ({ activitiesSocket, api, coinsSocket, ratesSocket }) =>
   function* webSocketSaga() {
     yield fork(xlm())
+    yield fork(activities({ activitiesSocket, api }))
     yield fork(rates({ api, ratesSocket }))
     yield fork(coins({ api, coinsSocket }))
   }
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagas.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagas.js
index bac12cad907..c62ff614618 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagas.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/sagas.js
@@ -1,8 +1,10 @@
+import activities from './activities/sagas'
 import coins from './coins/sagas'
 import rates from './rates/sagas'
 import xlm from './xlm/sagas'
 
-export default ({ api, coinsSocket, ratesSocket }) => ({
+export default ({ activitiesSocket, api, coinsSocket, ratesSocket }) => ({
+  activities: activities({ activitiesSocket, api }),
   rates: rates({ api, ratesSocket }),
   sds: coins({ api, coinsSocket }),
   xlm: xlm()
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/xlm/sagas.js b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/xlm/sagas.js
index 0a51fcc5e57..4eff4fdf3f1 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/xlm/sagas.js
+++ b/packages/blockchain-wallet-v4-frontend/src/data/middleware/webSocket/xlm/sagas.js
@@ -16,7 +16,6 @@ export default () => {
       if (tx.source_account !== accountId) {
         yield put(actions.alerts.displaySuccess(T.PAYMENT_RECEIVED_XLM))
       }
-      yield put(actions.core.data.xlm.fetchData())
       const pathname = yield select(selectors.router.getPathname)
       if (includes(pathname, ['/coins/XLM', '/home'])) yield call(addWalletTransaction, tx)
     } catch (e) {
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/prices/sagas.ts b/packages/blockchain-wallet-v4-frontend/src/data/prices/sagas.ts
index 9fabe3f188e..7fdd1fd1064 100755
--- a/packages/blockchain-wallet-v4-frontend/src/data/prices/sagas.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/prices/sagas.ts
@@ -2,7 +2,7 @@ import { getUnixTime, subDays } from 'date-fns'
 import { call, put, select } from 'redux-saga/effects'
 
 import { APIType } from '@core/network/api'
-import { IndexMultiResponseType } from '@core/network/api/coin/types'
+import { IndexMultiResponseType } from '@core/network/api/coins/types'
 import { errorCodeAndMessage } from '@core/utils'
 import { selectors } from 'data'
 import { PartialClientErrorProperties } from 'data/analytics/types/errors'
diff --git a/packages/blockchain-wallet-v4-frontend/src/data/rootSaga.ts b/packages/blockchain-wallet-v4-frontend/src/data/rootSaga.ts
index d65a66c46be..77a920f36ed 100644
--- a/packages/blockchain-wallet-v4-frontend/src/data/rootSaga.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/data/rootSaga.ts
@@ -22,7 +22,14 @@ import session from './session/sagaRegister'
 import signup from './signup/sagaRegister'
 import wallet from './wallet/sagaRegister'
 
-export default function* rootSaga({ api, coinsSocket, networks, options, ratesSocket }) {
+export default function* rootSaga({
+  activitiesSocket,
+  api,
+  coinsSocket,
+  networks,
+  options,
+  ratesSocket
+}) {
   const coreSagas = coreSagasFactory({ api, networks, options })
   const { initAppLanguage, logAppConsoleWarning } = miscSagas()
 
@@ -42,8 +49,9 @@ export default function* rootSaga({ api, coinsSocket, networks, options, ratesSo
     fork(preferences()),
     fork(prices({ api })),
     fork(goals({ api, coreSagas, networks })),
+    fork(middleware({ activitiesSocket, api, coinsSocket, ratesSocket })),
     fork(wallet({ coreSagas })),
-    fork(middleware({ api, coinsSocket, ratesSocket })),
+    fork(middleware({ activitiesSocket, api, coinsSocket, ratesSocket })),
     fork(coreRootSagaFactory({ api, networks, options })),
     fork(router()),
     fork(session({ api })),
diff --git a/packages/blockchain-wallet-v4-frontend/src/hooks/useCoinTransactionsQuery/useCoinTransactionsQuery.types.ts b/packages/blockchain-wallet-v4-frontend/src/hooks/useCoinTransactionsQuery/useCoinTransactionsQuery.types.ts
index f89a48f1876..8bcf4326a2b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/hooks/useCoinTransactionsQuery/useCoinTransactionsQuery.types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/hooks/useCoinTransactionsQuery/useCoinTransactionsQuery.types.ts
@@ -1,4 +1,4 @@
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { ActivityResponseType, IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import {
   BSOrderType,
   BSTransactionType,
@@ -15,6 +15,7 @@ type TransactionItem =
   | ProcessedTxType
   | FiatBSAndSwapTransactionType
   | IngestedSelfCustodyType
+  | ActivityResponseType['activity'][0]
 
 type CoinTransactionsQueryHookProps = {
   coin: CoinType
diff --git a/packages/blockchain-wallet-v4-frontend/src/hooks/useWalletsForCoin/useWalletsForCoin.ts b/packages/blockchain-wallet-v4-frontend/src/hooks/useWalletsForCoin/useWalletsForCoin.ts
index e872a38f17d..15d50a04fa5 100644
--- a/packages/blockchain-wallet-v4-frontend/src/hooks/useWalletsForCoin/useWalletsForCoin.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/hooks/useWalletsForCoin/useWalletsForCoin.ts
@@ -26,6 +26,11 @@ export const useWalletsForCoin: WalletsForCoinHook = ({ coin }) => {
     [coin]
   )
 
+  const isDynamicSelfCustodyCoin = useMemo(
+    () => selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin),
+    [coin]
+  )
+
   const isBTC = coin === 'BTC'
   const isBCH = coin === 'BCH'
   const isETH = coin === 'ETH'
@@ -80,6 +85,15 @@ export const useWalletsForCoin: WalletsForCoinHook = ({ coin }) => {
       })
     }
 
+    if (isDynamicSelfCustodyCoin) {
+      return getCoinAddressData(state, {
+        coin,
+        includeCustodial: isCustodialCoin,
+        includeInterest: true,
+        includeSelfCustody: true
+      })
+    }
+
     if (isCustodialCoin) {
       return getCoinAddressData(state, {
         coin,
diff --git a/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuLeft/Balances/WalletBalance/Balance/index.tsx b/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuLeft/Balances/WalletBalance/Balance/index.tsx
index 56e34522ce6..71791f7dc83 100644
--- a/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuLeft/Balances/WalletBalance/Balance/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuLeft/Balances/WalletBalance/Balance/index.tsx
@@ -1,6 +1,5 @@
 import React from 'react'
 import { connect, ConnectedProps } from 'react-redux'
-import { toLower } from 'ramda'
 import { bindActionCreators } from 'redux'
 
 import { CoinType, ExtractSuccess } from '@core/types'
@@ -13,14 +12,7 @@ import Success from './template.success'
 
 class Balance extends React.PureComponent<Props> {
   handleRefresh = () => {
-    const { coin } = this.props
-    const { coinfig } = window.coins[coin]
-    if (coinfig.type.erc20Address) {
-      this.props.ethActions.fetchErc20Data(coin)
-    } else {
-      const coinLower = toLower(coin)
-      this.props[`${coinLower}Actions`].fetchData()
-    }
+    this.props.coinsActions.fetchUnifiedBalances()
   }
 
   render() {
@@ -49,11 +41,7 @@ const mapStateToProps = (state, ownProps) => ({
 })
 
 const mapDispatchToProps = (dispatch) => ({
-  bchActions: bindActionCreators(actions.core.data.bch, dispatch),
-  btcActions: bindActionCreators(actions.core.data.btc, dispatch),
-  ethActions: bindActionCreators(actions.core.data.eth, dispatch),
-  stxActions: bindActionCreators(actions.core.data.stx, dispatch),
-  xlmActions: bindActionCreators(actions.core.data.xlm, dispatch)
+  coinsActions: bindActionCreators(actions.core.data.coins, dispatch)
 })
 
 const connector = connect(mapStateToProps, mapDispatchToProps)
diff --git a/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuTop/Header.tsx b/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuTop/Header.tsx
index 21c6a5d9f1e..229294757bd 100644
--- a/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuTop/Header.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/layouts/Wallet/MenuTop/Header.tsx
@@ -103,6 +103,16 @@ const Header = (props: OwnProps) => {
       e2e: 'earnLink',
       isNew: true,
       text: <FormattedMessage id='copy.earn' defaultMessage='Earn' />
+    },
+    {
+      dest: '/defi',
+      e2e: 'defiTest',
+      text: <FormattedMessage id='copy.defi_test' defaultMessage='Defi Test' />
+    },
+    {
+      dest: '/accounts',
+      e2e: 'accountsTest',
+      text: <FormattedMessage id='copy.account_test' defaultMessage='Account Test' />
     }
   ]
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/middleware/index.js b/packages/blockchain-wallet-v4-frontend/src/middleware/index.js
index 5dad97549ee..3ebbb02a21d 100644
--- a/packages/blockchain-wallet-v4-frontend/src/middleware/index.js
+++ b/packages/blockchain-wallet-v4-frontend/src/middleware/index.js
@@ -1,6 +1,7 @@
 import analyticsMiddleware from './analyticsMiddleware'
 import streamingXlm from './streamingXlm'
+import webSocketActivities from './webSocketActivities'
 import webSocketCoins from './webSocketCoins'
 import webSocketRates from './webSocketRates'
 
-export { analyticsMiddleware, streamingXlm, webSocketCoins, webSocketRates }
+export { analyticsMiddleware, streamingXlm, webSocketActivities, webSocketCoins, webSocketRates }
diff --git a/packages/blockchain-wallet-v4-frontend/src/middleware/webSocketActivities.js b/packages/blockchain-wallet-v4-frontend/src/middleware/webSocketActivities.js
new file mode 100644
index 00000000000..d46043527f8
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/middleware/webSocketActivities.js
@@ -0,0 +1,42 @@
+import { compose } from 'ramda'
+
+import { actions, actionTypes } from 'data'
+
+export const fallbackInterval = 5000
+const fallbackIntervalPID = null
+
+const socket = (socket) => (store) => {
+  return (next) => (action) => {
+    const { type } = action
+
+    if (type === actionTypes.middleware.webSocket.activities.START_SOCKET) {
+      clearInterval(fallbackIntervalPID)
+      socket.connect(
+        // onOpen
+        compose(store.dispatch, actions.middleware.webSocket.activities.openSocket),
+        // onMessage
+        compose(store.dispatch, actions.middleware.webSocket.activities.messageSocket),
+        // onClose
+        compose(store.dispatch, actions.middleware.webSocket.activities.closeSocket),
+        // onError
+        // eslint-disable-next-line no-console
+        (e) => console.error('Failed to connect to websocket', e),
+        // fallback
+        () => {
+          // fallbackIntervalPID = setInterval(
+          //   compose(store.dispatch, actions.middleware.webSocket.activities.restFallback),
+          //   fallbackInterval
+          // )
+        }
+      )
+    }
+
+    if (type === actionTypes.middleware.webSocket.activities.STOP_SOCKET) {
+      socket.close()
+    }
+
+    return next(action)
+  }
+}
+
+export default socket
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/AddCardVgs/AddCardVgs.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/AddCardVgs/AddCardVgs.tsx
index 0bd30f249fd..1d507909774 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/AddCardVgs/AddCardVgs.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/AddCardVgs/AddCardVgs.tsx
@@ -41,6 +41,7 @@ const AddCardVgs: VgsComponent = ({ handleClose }) => {
         // FIXME: due to a recent change on the backend `country` is no longer supported in favor of `countryCode`
         //        but not supported everywhere yet so need to keep `country` for now.
         address.countryCode = address.country
+        address.state = address.state || ''
 
         ref.current?.contentWindow?.postMessage(
           { messageData: address, method: 'billingAddress' },
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/index.tsx
index 9dd919aa77e..70c07e72838 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/index.tsx
@@ -23,8 +23,6 @@ class CheckoutConfirm extends PureComponent<Props> {
   componentDidMount() {
     this.props.sendActions.getLockRule()
     if (!Remote.Success.is(this.props.data)) {
-      this.props.buySellActions.fetchSDDEligibility()
-      this.props.buySellActions.fetchSDDVerified()
       this.props.buySellActions.fetchCards(false)
       this.props.brokerageActions.fetchBankTransferAccounts()
     }
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/selectors.ts
index a4af1d73b3e..56402e9fb9b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/selectors.ts
@@ -3,6 +3,7 @@ import { createSelector } from 'reselect'
 
 import { ExtractSuccess } from '@core/types'
 import { selectors } from 'data'
+import { getIsSddFlow } from 'data/components/buySell/selectors/getIsSddFlow'
 import { RootState } from 'data/rootReducer'
 
 import * as QuoteSummaryViewModel from './models/quoteSummaryViewModel'
@@ -17,12 +18,8 @@ export const getData = (state: RootState) => {
 
   const quoteSummaryViewModelR = selectQuoteSummaryViewModel(state)
   const sbBalancesR = selectors.components.buySell.getBSBalances(state)
-  const sddEligibleR = selectors.components.buySell.getSddEligible(state)
-  const userSDDTierR = selectors.components.buySell.getUserSddEligibleTier(state)
-  const isUserSddVerifiedR = selectors.components.buySell.isUserSddVerified(state)
   const cardsR = selectors.components.buySell.getBSCards(state)
-
-  const userDataR = selectors.modules.profile.getUserData(state)
+  const isSddFlowR = getIsSddFlow(state)
 
   const withdrawLockCheckR = selectors.components.send.getWithdrawLockCheckRule(state)
 
@@ -33,34 +30,26 @@ export const getData = (state: RootState) => {
       bankAccounts: ExtractSuccess<typeof bankAccountsR>,
       quoteSummaryViewModel: ExtractSuccess<typeof quoteSummaryViewModelR>,
       sbBalances: ExtractSuccess<typeof sbBalancesR>,
-      userData: ExtractSuccess<typeof userDataR>,
       withdrawLockCheck: ExtractSuccess<typeof withdrawLockCheckR>,
-      sddEligible: ExtractSuccess<typeof sddEligibleR>,
-      userSDDTier: ExtractSuccess<typeof userSDDTierR>,
-      isUserSddVerified: ExtractSuccess<typeof isUserSddVerifiedR>,
       cards: ExtractSuccess<typeof cardsR>,
-      order: ExtractSuccess<typeof orderR>
+      order: ExtractSuccess<typeof orderR>,
+      isSddFlow: ExtractSuccess<typeof isSddFlowR>
     ) => ({
       bankAccounts,
       cards,
-      isSddFlow: sddEligible.eligible || userSDDTier === 3,
-      isUserSddVerified,
+      isSddFlow,
       order,
       quoteSummaryViewModel,
       sbBalances,
-      userData,
       withdrawLockCheck
     })
   )(
     bankAccountsR,
     quoteSummaryViewModelR,
     sbBalancesR,
-    userDataR,
     withdrawLockCheckR,
-    sddEligibleR,
-    userSDDTierR,
-    isUserSddVerifiedR,
     cardsR,
-    orderR
+    orderR,
+    isSddFlowR
   )
 }
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/template.success.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/template.success.tsx
index a9c5b0a938c..e1b69c5122c 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/template.success.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CheckoutConfirm/template.success.tsx
@@ -24,8 +24,7 @@ import {
   BankTransferAccountType,
   BrokerageModalOriginType,
   ModalName,
-  RecurringBuyPeriods,
-  UserDataType
+  RecurringBuyPeriods
 } from 'data/types'
 import { useDefer3rdPartyScript, useSardineContext } from 'hooks'
 import { isNabuError } from 'services/errors'
@@ -192,6 +191,7 @@ const Success: React.FC<InjectedFormProps<{ form: string }, Props> & Props> = (p
       key: Analytics.BUY_CHECKOUT_SCREEN_VIEWED,
       properties: {}
     })
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   useEffect(() => {
@@ -219,37 +219,24 @@ const Success: React.FC<InjectedFormProps<{ form: string }, Props> & Props> = (p
       properties: {}
     })
 
-    const { bankAccounts, cards, isSddFlow, isUserSddVerified, sbBalances, userData } =
-      props.data.getOrElse({
-        isSddFlow: false,
-        userData: { tiers: { current: 0 } } as UserDataType
-      } as SuccessStateType)
+    const { bankAccounts, cards, isSddFlow, sbBalances } = props.data.getOrElse({
+      isSddFlow: false
+    } as SuccessStateType)
 
-    const userTier = userData?.tiers?.current
     const inputCurrency = props.order.inputCurrency as WalletFiatType
-    // check for SDD flow and direct to add card
-    if (isSddFlow && props.order.paymentType === BSPaymentTypes.PAYMENT_CARD) {
-      if (isUserSddVerified) {
-        // user has to have at least one active card
-        if (cards && cards.length > 0 && cards[0].state === 'ACTIVE') {
-          const card = cards[0]
-          return props.buySellActions.confirmOrder({
-            order: props.order,
-            paymentMethodId: card.id
-          })
-        }
-        return props.buySellActions.setStep({
-          step: 'DETERMINE_CARD_PROVIDER'
+
+    if (isSddFlow) {
+      // user has to have at least one active card
+      if (cards && cards.length > 0 && cards[0].state === 'ACTIVE') {
+        const card = cards[0]
+        return props.buySellActions.confirmOrder({
+          order: props.order,
+          paymentMethodId: card.id
         })
       }
-      return props.buySellActions.setStep({
-        step: 'KYC_REQUIRED'
-      })
-    }
 
-    if (userTier < 2) {
       return props.buySellActions.setStep({
-        step: 'KYC_REQUIRED'
+        step: 'DETERMINE_CARD_PROVIDER'
       })
     }
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/CryptoSelector/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/CryptoSelector/index.tsx
index 95abd214250..418744fc379 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/CryptoSelector/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/CryptoSelector/index.tsx
@@ -9,6 +9,7 @@ import { Icon, Image, TabMenu, TabMenuItem, Text } from 'blockchain-info-compone
 import { FlyoutWrapper } from 'components/Flyout'
 import { model } from 'data'
 import { getCoinFromPair, getFiatFromPair } from 'data/components/buySell/model'
+import * as SddFlow from 'data/components/buySell/utils/sddFlow'
 import { Analytics, ModalName, SwapAccountType } from 'data/types'
 
 import { Props as OwnProps, SuccessStateType } from '../index'
@@ -101,26 +102,13 @@ class CryptoSelector extends React.Component<InjectedFormProps<{}, Props> & Prop
   }
 
   handleBuy = (pair: BSPairType) => {
-    const currentTier = this.props.userData?.tiers?.current ?? 0
-
     this.props.analyticsActions.trackEvent({
       key: Analytics.BUY_ASSET_SELECTED,
       properties: {}
     })
 
-    // if first time user, send to verify email step which is required future SDD check
-    if (!this.props.emailVerified && currentTier !== 2 && currentTier !== 1) {
-      return this.props.buySellActions.setStep({
-        cryptoCurrency: getCoinFromPair(pair.pair),
-        fiatCurrency: getFiatFromPair(pair.pair),
-        orderType: this.state.orderType,
-        pair,
-        step: 'VERIFY_EMAIL'
-      })
-    }
-
     // if SDD user has already placed on order, force them to Gold upgrade
-    if (currentTier === 3 && this.props.sbOrders?.length > 0) {
+    if (SddFlow.isSddUser(this.props.userData) && this.props.sbOrders?.length > 0) {
       return this.props.buySellActions.setStep({
         step: 'UPGRADE_TO_GOLD'
       })
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/index.tsx
index 68d7fd3c04c..07033af530b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/index.tsx
@@ -28,7 +28,6 @@ const CryptoSelection: React.FC<Props> = memo((props) => {
         (currentCurrencyIsInSupportedFiat ? props.walletCurrency : 'USD')
       props.buySellActions.fetchPairs({ currency })
       props.buySellActions.fetchFiatEligible(props.walletCurrency)
-      props.buySellActions.fetchSDDEligibility()
       props.buySellActions.fetchBSOrders()
     }
   }, [])
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/selectors.ts
index 6997cf7bf83..dbf19f165cf 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/CryptoSelection/selectors.ts
@@ -12,7 +12,6 @@ export const getData = (state) => {
   ) as BSCheckoutFormValuesType
   const emailVerifiedR = selectors.core.settings.getEmailVerified(state)
   const sbOrdersR = selectors.components.buySell.getBSOrders(state)
-  const sddEligibleR = selectors.components.buySell.getSddEligible(state)
   // checks orderType on state for the 'SELL' button on top of activity feed
   const stateOrderType = selectors.components.buySell.getOrderType(state)
   const pairsR = selectors.components.buySell.getBSPairs(state)
@@ -26,7 +25,6 @@ export const getData = (state) => {
       pairs: ExtractSuccess<typeof pairsR>,
       userData: ExtractSuccess<typeof userDataR>,
       sbOrders: ExtractSuccess<typeof sbOrdersR>,
-      sddEligible: ExtractSuccess<typeof sddEligibleR>,
       walletCurrency: FiatType
     ) => ({
       eligibility,
@@ -37,11 +35,10 @@ export const getData = (state) => {
       orderType: formValues ? formValues.orderType : stateOrderType || 'BUY',
       pairs,
       sbOrders,
-      sddEligible,
       userData,
       walletCurrency
     })
-  )(eligibilityR, emailVerifiedR, pairsR, userDataR, sbOrdersR, sddEligibleR, walletCurrencyR)
+  )(eligibilityR, emailVerifiedR, pairsR, userDataR, sbOrdersR, walletCurrencyR)
 }
 
 export default getData
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/ActionButton/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/ActionButton/index.tsx
index 3a3f00e9f11..df58aaf9618 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/ActionButton/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/ActionButton/index.tsx
@@ -10,14 +10,12 @@ type Props = {
   invalid: boolean
   isAmountInBounds: boolean
   isDailyLimitExceeded: boolean
-  isSufficientEthForErc20: boolean
   submitting: boolean
 } & OwnProps &
   SuccessStateType
 
 const ActionButton: React.FC<Props> = (props) => {
   const disabled = props.invalid || props.submitting || !props.isAmountInBounds
-  const disableInsufficientEth = props.isSufficientEthForErc20
   const dailyLimitExceeded = props.isDailyLimitExceeded
 
   switch (props.userData.kycState) {
@@ -93,7 +91,7 @@ const ActionButton: React.FC<Props> = (props) => {
           nature='primary'
           type='submit'
           fullwidth
-          disabled={disabled || disableInsufficientEth || dailyLimitExceeded}
+          disabled={disabled || dailyLimitExceeded}
         >
           {props.submitting ? (
             <HeartbeatLoader height='16px' width='16px' color='white' />
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/index.tsx
index 0f5ab5a5b1e..6b280d5d74e 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/index.tsx
@@ -15,7 +15,6 @@ import { FlyoutOopsError } from 'components/Flyout/Errors'
 import { GenericNabuErrorFlyout } from 'components/GenericNabuErrorFlyout'
 import { actions, model, selectors } from 'data'
 import { PartialClientErrorProperties } from 'data/analytics/types/errors'
-import { getValidPaymentMethod } from 'data/components/buySell/model'
 import { RootState } from 'data/rootReducer'
 import { Analytics, BSCheckoutFormValuesType, ModalName, RecurringBuyPeriods } from 'data/types'
 import { useRemote } from 'hooks'
@@ -54,9 +53,7 @@ const Checkout = (props: Props) => {
   const handleSubmit = () => {
     if (!data) return
 
-    // if the user is < tier 2 go to kyc but save order info
-    // if the user is tier 2 try to submit order, let BE fail
-    const { hasPaymentAccount, isSddFlow, userData } = data
+    const { hasPaymentAccount, isSddFlow } = data
 
     const buySellGoal = find(propEq('name', 'buySell'), goals)
 
@@ -79,22 +76,7 @@ const Checkout = (props: Props) => {
     })
 
     if (isSddFlow) {
-      const currentTier = userData?.tiers?.current ?? 0
-
-      if (currentTier === 2 || currentTier === 1) {
-        // user in SDD but already completed eligibility check, continue to payment
-        props.buySellActions.createOrder({ paymentType: BSPaymentTypes.PAYMENT_CARD })
-      } else {
-        // user in SDD but needs to confirm KYC and SDD eligibility
-        props.identityVerificationActions.verifyIdentity({
-          checkSddEligibility: true,
-          needMoreInfo: false,
-          onCompletionCallback: () =>
-            props.buySellActions.createOrder({ paymentType: BSPaymentTypes.PAYMENT_CARD }),
-          origin: 'BuySell',
-          tier: 2
-        })
-      }
+      props.buySellActions.createOrder({ paymentType: BSPaymentTypes.PAYMENT_CARD })
     } else if (!method) {
       const nextStep = hasPaymentAccount ? 'LINKED_PAYMENT_ACCOUNTS' : 'PAYMENT_METHODS'
       props.buySellActions.setStep({
@@ -104,8 +86,6 @@ const Checkout = (props: Props) => {
         pair: props.pair,
         step: nextStep
       })
-    } else if (userData.tiers.current < 2) {
-      props.buySellActions.createOrder({ paymentMethodId: getValidPaymentMethod(method.type) })
     } else if (formValues && method) {
       switch (method.type) {
         case BSPaymentTypes.PAYMENT_CARD:
@@ -178,7 +158,6 @@ const Checkout = (props: Props) => {
     }
 
     if (!data) {
-      props.buySellActions.fetchSDDEligibility()
       props.brokerageActions.fetchBankTransferAccounts()
     }
     // we fetch limits as part of home banners logic at that point we had only fiatCurrency
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/selectors.ts
index 6dcd99d28f9..c07f93548fc 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/selectors.ts
@@ -2,6 +2,7 @@ import { lift } from 'ramda'
 
 import { BSPaymentTypes, CrossBorderLimits, ExtractSuccess } from '@core/types'
 import { model, selectors } from 'data'
+import { getIsSddFlow } from 'data/components/buySell/selectors/getIsSddFlow'
 import { RootState } from 'data/rootReducer'
 
 const { FORM_BS_CHECKOUT } = model.components.buySell
@@ -13,8 +14,6 @@ const getData = (state: RootState) => {
   const ratesR = selectors.core.data.misc.getRatesSelector(coin, state)
   const sbBalancesR = selectors.components.buySell.getBSBalances(state)
   const userDataR = selectors.modules.profile.getUserData(state)
-  const sddEligibleR = selectors.components.buySell.getSddEligible(state)
-  const userSDDTierR = selectors.components.buySell.getUserSddEligibleTier(state)
   const sddLimitR = selectors.components.buySell.getUserLimit(state, BSPaymentTypes.PAYMENT_CARD)
   const cardsR = selectors.components.buySell.getBSCards(state) || []
   const bankTransferAccounts = selectors.components.brokerage
@@ -22,6 +21,7 @@ const getData = (state: RootState) => {
     .getOrElse([])
   const limitsR = selectors.components.buySell.getLimits(state)
   const hasFiatBalance = selectors.components.buySell.hasFiatBalances(state)
+  const isSddFlowR = getIsSddFlow(state)
 
   const isRecurringBuy = selectors.core.walletOptions
     .getFeatureFlagRecurringBuys(state)
@@ -38,10 +38,9 @@ const getData = (state: RootState) => {
       rates: ExtractSuccess<typeof ratesR>,
       sbBalances: ExtractSuccess<typeof sbBalancesR>,
       userData: ExtractSuccess<typeof userDataR>,
-      sddEligible: ExtractSuccess<typeof sddEligibleR>,
       sddLimit: ExtractSuccess<typeof sddLimitR>,
-      userSDDTier: ExtractSuccess<typeof userSDDTierR>,
-      products: ExtractSuccess<typeof productsR>
+      products: ExtractSuccess<typeof productsR>,
+      isSddFlow: ExtractSuccess<typeof isSddFlowR>
     ) => ({
       bankTransferAccounts,
       cards,
@@ -50,17 +49,16 @@ const getData = (state: RootState) => {
       hasFiatBalance,
       hasPaymentAccount: hasFiatBalance || cards.length > 0 || bankTransferAccounts.length > 0,
       isRecurringBuy,
-      isSddFlow: sddEligible.eligible || userSDDTier === 3,
+      isSddFlow,
       limits: limitsR.getOrElse(undefined),
       payment: paymentR.getOrElse(undefined),
       products,
       rates,
       sbBalances,
-      sddEligible,
       sddLimit,
       userData
     })
-  )(cardsR, ratesR, sbBalancesR, userDataR, sddEligibleR, sddLimitR, userSDDTierR, productsR)
+  )(cardsR, ratesR, sbBalancesR, userDataR, sddLimitR, productsR, isSddFlowR)
 }
 
 export default getData
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/template.success.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/template.success.tsx
index 4250e9900ce..e703a9830b2 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/template.success.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/Checkout/template.success.tsx
@@ -541,7 +541,6 @@ const Success: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
           {!showLimitError && !showError && !isPaymentMethodBlocked && (
             <ActionButton
               {...props}
-              isSufficientEthForErc20={false}
               isDailyLimitExceeded={isDailyLimitExceeded || false}
               isAmountInBounds={amountInBounds}
             />
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/index.tsx
index 11375104bcd..0d9a7ec085f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/EnterAmount/index.tsx
@@ -43,7 +43,6 @@ const EnterAmount = (props: Props) => {
       })
       props.brokerageActions.fetchBankTransferAccounts()
       props.buySellActions.fetchCards(false)
-      props.buySellActions.fetchSDDEligibility()
       props.buySellActions.fetchOrders()
     }
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/OrderSummary/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/OrderSummary/index.tsx
index 26e8268d16a..7c36a4c041e 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/OrderSummary/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/OrderSummary/index.tsx
@@ -92,7 +92,6 @@ class OrderSummaryContainer extends PureComponent<Props> {
       NotAsked: () => <Loading />,
       Success: (val) => {
         const { interestEligible, interestRates, order } = val
-        const { state } = order
         const currencySymbol = getSymbol(getCounterCurrency(order))
         const [recurringBuy] = val.recurringBuyList.filter((rb) => {
           return rb.id === order.recurringBuyId
@@ -150,6 +149,17 @@ class OrderSummaryContainer extends PureComponent<Props> {
           }
         }
 
+        if (
+          order.state === 'PENDING_CONFIRMATION' &&
+          order.attributes?.cardCassy?.paymentState !== 'SETTLED' &&
+          order.attributes?.needCvv
+        ) {
+          // In case that it's in PENDING_CONFIRMATION state we need to and need tp update CVV we have t show modal
+          this.props.buySellActions.setStep({
+            step: 'UPDATE_SECURITY_CODE'
+          })
+        }
+
         const handleCompleteButton = () => {
           if (
             order.attributes?.cardProvider?.cardAcquirerName === 'EVERYPAY' ||
@@ -179,7 +189,7 @@ class OrderSummaryContainer extends PureComponent<Props> {
           }
         }
 
-        return state === 'FAILED' || state === 'CANCELED' || !order.paymentType ? (
+        return order.state === 'FAILED' || order.state === 'CANCELED' || !order.paymentType ? (
           <BaseError
             code='INTERNAL_SERVER_ERROR'
             handleRetry={this.handleErrorAction}
@@ -203,7 +213,7 @@ class OrderSummaryContainer extends PureComponent<Props> {
             interestEligible={interestEligible}
             interestRates={interestRates}
             lockTime={val.lockTime}
-            orderState={state}
+            orderState={order.state}
             orderType={getOrderType(order) as OrderType}
             outputCurrency={order.outputCurrency}
             paymentState={order.attributes?.everypay?.paymentState || null}
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/index.tsx
index 39a3da35a41..5f348f9cc1e 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/index.tsx
@@ -4,7 +4,6 @@ import { find, isEmpty, pathOr, propEq, propOr } from 'ramda'
 import { bindActionCreators } from 'redux'
 
 import {
-  BSPaymentTypes,
   CrossBorderLimitsPayload,
   ExtractSuccess,
   FiatType,
@@ -15,7 +14,6 @@ import { FlyoutOopsError } from 'components/Flyout/Errors'
 import { GenericNabuErrorFlyout } from 'components/GenericNabuErrorFlyout'
 import { actions, model, selectors } from 'data'
 import { PartialClientErrorProperties } from 'data/analytics/types/errors'
-import { getValidPaymentMethod } from 'data/components/buySell/model'
 import { RootState } from 'data/rootReducer'
 import {
   Analytics,
@@ -65,97 +63,16 @@ const Checkout = (props: Props) => {
       properties: {}
     })
 
-    // if the user is < tier 2 go to kyc but save order info
-    // if the user is tier 2 try to submit order, let BE fail
-    const { hasPaymentAccount, isSddFlow, userData } = data
-
     const buySellGoal = find(propEq('name', 'buySell'), goals)
-
     const id = propOr('', 'id', buySellGoal)
-
     if (!isEmpty(id)) {
       props.deleteGoal(String(id))
     }
 
-    const method = props.method || props.defaultMethod
-
-    // TODO: sell
-    // need to do kyc check
-    // SELL
-    if (formValues?.orderType === OrderType.SELL) {
-      return props.buySellActions.setStep({
-        sellOrderType: props.swapAccount?.type,
-        step: 'PREVIEW_SELL'
-      })
-    }
-
-    // BUY
-    if (isSddFlow) {
-      const currentTier = userData?.tiers?.current ?? 0
-
-      if (currentTier === 2 || currentTier === 1) {
-        // user in SDD but already completed eligibility check, continue to payment
-        props.buySellActions.createOrder({ paymentType: BSPaymentTypes.PAYMENT_CARD })
-      } else {
-        // user in SDD but needs to confirm KYC and SDD eligibility
-        props.identityVerificationActions.verifyIdentity({
-          checkSddEligibility: true,
-          needMoreInfo: false,
-          onCompletionCallback: () =>
-            props.buySellActions.createOrder({ paymentType: BSPaymentTypes.PAYMENT_CARD }),
-          origin: 'BuySell',
-          tier: 2
-        })
-      }
-    } else if (!method) {
-      const nextStep = hasPaymentAccount ? 'LINKED_PAYMENT_ACCOUNTS' : 'PAYMENT_METHODS'
-      props.buySellActions.setStep({
-        cryptoCurrency: props.cryptoCurrency,
-        fiatCurrency: props.fiatCurrency,
-        order: props.order,
-        pair: props.pair,
-        step: nextStep
-      })
-    } else if (userData.tiers.current < 2) {
-      props.buySellActions.createOrder({ paymentMethodId: getValidPaymentMethod(method.type) })
-    } else if (formValues && method) {
-      switch (method.type) {
-        case BSPaymentTypes.PAYMENT_CARD:
-          if (props.mobilePaymentMethod) {
-            props.buySellActions.createOrder({
-              mobilePaymentMethod: props.mobilePaymentMethod,
-              paymentMethodId: method.id,
-              paymentType: BSPaymentTypes.PAYMENT_CARD
-            })
-
-            break
-          }
-
-          props.buySellActions.setStep({
-            step: 'DETERMINE_CARD_PROVIDER'
-          })
-          break
-        case BSPaymentTypes.USER_CARD:
-          props.buySellActions.createOrder({
-            paymentMethodId: method.id,
-            paymentType: BSPaymentTypes.PAYMENT_CARD
-          })
-          break
-        case BSPaymentTypes.FUNDS:
-          props.buySellActions.createOrder({ paymentType: BSPaymentTypes.FUNDS })
-          break
-        case BSPaymentTypes.BANK_TRANSFER:
-          props.buySellActions.createOrder({
-            paymentMethodId: method.id,
-            paymentType: BSPaymentTypes.BANK_TRANSFER
-          })
-          break
-        case BSPaymentTypes.BANK_ACCOUNT:
-          break
-        default:
-          break
-      }
-    }
+    return props.buySellActions.setStep({
+      sellOrderType: props.swapAccount?.type,
+      step: 'PREVIEW_SELL'
+    })
   }
 
   const errorCallback = () => {
@@ -190,7 +107,6 @@ const Checkout = (props: Props) => {
     }
 
     if (!data) {
-      props.buySellActions.fetchSDDEligibility()
       props.brokerageActions.fetchBankTransferAccounts()
     }
     // we fetch limits as part of home banners logic at that point we had only fiatCurrency
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/selectors.ts
index eba24a887ec..293f117142a 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/Checkout/selectors.ts
@@ -2,6 +2,7 @@ import { lift } from 'ramda'
 
 import { BSPaymentTypes, CrossBorderLimits, ExtractSuccess } from '@core/types'
 import { model, selectors } from 'data'
+import { getIsSddFlow } from 'data/components/buySell/selectors/getIsSddFlow'
 import { RootState } from 'data/rootReducer'
 
 import { OwnProps } from '.'
@@ -20,8 +21,6 @@ const getData = (state: RootState, ownProps: OwnProps) => {
   const ratesR = selectors.core.data.misc.getRatesSelector(coin, state)
   const sbBalancesR = selectors.components.buySell.getBSBalances(state)
   const userDataR = selectors.modules.profile.getUserData(state)
-  const sddEligibleR = selectors.components.buySell.getSddEligible(state)
-  const userSDDTierR = selectors.components.buySell.getUserSddEligibleTier(state)
   const sddLimitR = selectors.components.buySell.getUserLimit(state, BSPaymentTypes.PAYMENT_CARD)
   const cardsR = selectors.components.buySell.getBSCards(state) || []
   const bankTransferAccounts = selectors.components.brokerage
@@ -29,6 +28,7 @@ const getData = (state: RootState, ownProps: OwnProps) => {
     .getOrElse([])
   const limitsR = selectors.components.buySell.getLimits(state)
   const hasFiatBalance = selectors.components.buySell.hasFiatBalances(state)
+  const isSddFlowR = getIsSddFlow(state)
 
   const isRecurringBuy = selectors.core.walletOptions
     .getFeatureFlagRecurringBuys(state)
@@ -46,10 +46,9 @@ const getData = (state: RootState, ownProps: OwnProps) => {
       rates: ExtractSuccess<typeof ratesR>,
       sbBalances: ExtractSuccess<typeof sbBalancesR>,
       userData: ExtractSuccess<typeof userDataR>,
-      sddEligible: ExtractSuccess<typeof sddEligibleR>,
       sddLimit: ExtractSuccess<typeof sddLimitR>,
-      userSDDTier: ExtractSuccess<typeof userSDDTierR>,
-      products: ExtractSuccess<typeof productsR>
+      products: ExtractSuccess<typeof productsR>,
+      isSddFlow: ExtractSuccess<typeof isSddFlowR>
     ) => ({
       bankTransferAccounts,
       cards,
@@ -58,28 +57,17 @@ const getData = (state: RootState, ownProps: OwnProps) => {
       hasFiatBalance,
       hasPaymentAccount: hasFiatBalance || cards.length > 0 || bankTransferAccounts.length > 0,
       isRecurringBuy,
-      isSddFlow: sddEligible.eligible || userSDDTier === 3,
+      isSddFlow,
       limits: limitsR.getOrElse(undefined),
       payment: paymentR.getOrElse(undefined),
       products,
       quote,
       rates,
       sbBalances,
-      sddEligible,
       sddLimit,
       userData
     })
-  )(
-    cardsR,
-    quoteR,
-    ratesR,
-    sbBalancesR,
-    userDataR,
-    sddEligibleR,
-    sddLimitR,
-    userSDDTierR,
-    productsR
-  )
+  )(cardsR, quoteR, ratesR, sbBalancesR, userDataR, sddLimitR, productsR, isSddFlowR)
 }
 
 export default getData
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/index.tsx
index 11375104bcd..0d9a7ec085f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/SellEnterAmount/index.tsx
@@ -43,7 +43,6 @@ const EnterAmount = (props: Props) => {
       })
       props.brokerageActions.fetchBankTransferAccounts()
       props.buySellActions.fetchCards(false)
-      props.buySellActions.fetchSDDEligibility()
       props.buySellActions.fetchOrders()
     }
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerEverypay/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerEverypay/index.tsx
index 12fe8df32e9..25fd8137c15 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerEverypay/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerEverypay/index.tsx
@@ -89,7 +89,7 @@ const ThreeDSHandlerEverypay = (props: Props) => {
   )
 
   if (order.hasError && order.error) {
-    renderError(order.error)
+    return renderError(order.error)
   }
 
   if (order.isLoading) {
@@ -115,7 +115,7 @@ const ThreeDSHandlerEverypay = (props: Props) => {
   }
 
   if (!paymentLink) {
-    renderError(CARD_ERROR_CODE.CREATE_FAILED)
+    return renderError(CARD_ERROR_CODE.CREATE_FAILED)
   }
 
   return (
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerFakeCardAcquirer/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerFakeCardAcquirer/index.tsx
index 64d58eeb772..ea7a615345f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerFakeCardAcquirer/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/ThreeDSHandlerFakeCardAcquirer/index.tsx
@@ -89,7 +89,7 @@ const ThreeDSHandlerFakeCardAcquirer = (props: Props) => {
   )
 
   if (order.hasError && order.error) {
-    renderError(order.error)
+    return renderError(order.error)
   }
 
   if (order.isLoading) {
@@ -115,7 +115,7 @@ const ThreeDSHandlerFakeCardAcquirer = (props: Props) => {
   }
 
   if (!paymentLink) {
-    renderError(CARD_ERROR_CODE.CREATE_FAILED)
+    return renderError(CARD_ERROR_CODE.CREATE_FAILED)
   }
 
   return (
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/UpdateSecurityCode/UpdateSecurityCode.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/UpdateSecurityCode/UpdateSecurityCode.tsx
index 82ca39a7575..8798d8f38b4 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/UpdateSecurityCode/UpdateSecurityCode.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/UpdateSecurityCode/UpdateSecurityCode.tsx
@@ -18,16 +18,20 @@ import {
 } from '@blockchain-com/constellation'
 
 import { Card } from 'components/Card'
+import { FlyoutOopsError } from 'components/Flyout/Errors'
 import {
   FlyoutContainer,
   FlyoutContent,
   FlyoutFooter,
   FlyoutHeader
 } from 'components/Flyout/Layout'
+import { GenericNabuErrorFlyout } from 'components/GenericNabuErrorFlyout'
 import { StandardRow } from 'components/Rows'
 import { actions, selectors } from 'data'
 import { useRemote } from 'hooks'
+import { isNabuError } from 'services/errors'
 
+import Loading from '../template.loading'
 import { UpdateSecurityCodeComponent } from './types'
 
 const UpdateSecurityCode: UpdateSecurityCodeComponent = ({ backToEnterAmount }) => {
@@ -35,6 +39,7 @@ const UpdateSecurityCode: UpdateSecurityCodeComponent = ({ backToEnterAmount })
   const [cvv, setCvv] = useState<string | null>(null)
   const { data: order } = useRemote(selectors.components.buySell.getBSOrder)
   const {
+    error,
     hasData: cvvHasData,
     hasError: cvvHasError,
     isLoading: cvvLoading
@@ -43,22 +48,44 @@ const UpdateSecurityCode: UpdateSecurityCodeComponent = ({ backToEnterAmount })
 
   const updateCvv = () => {
     const paymentId = order?.attributes?.paymentId || order?.depositPaymentId
-    if (cvv && paymentId) {
+    if (cvv && paymentId && !cvvHasData) {
       dispatch(actions.components.buySell.updateCardCvvAndPollOrder({ cvv, paymentId }))
     }
   }
 
+  const errorCallback = () => {
+    backToEnterAmount()
+  }
+
   useEffect(() => {
     return () => {
       dispatch(actions.components.buySell.cvvStatusReset())
     }
   }, [])
 
+  if (error) {
+    if (isNabuError(error)) {
+      return <GenericNabuErrorFlyout error={error} onDismiss={errorCallback} />
+    }
+
+    return (
+      <FlyoutOopsError
+        action='retry'
+        data-e2e='sbUpdateSecurityCodeSectionAgain'
+        handler={errorCallback}
+      />
+    )
+  }
+
   if (!method) {
     backToEnterAmount()
     return null
   }
 
+  if (cvvHasData) {
+    return <Loading />
+  }
+
   return (
     <FlyoutContainer>
       <FlyoutHeader data-e2e='update-security-code-flyout' mode='back' onClick={backToEnterAmount}>
@@ -92,7 +119,7 @@ const UpdateSecurityCode: UpdateSecurityCodeComponent = ({ backToEnterAmount })
               <Text as='p' variant='body1' textAlign='center' color={SemanticColors.overlay}>
                 <FormattedMessage
                   id='copy.re_enter_security_code'
-                  defaultMessage='Please re-enter the 3 digit CVV code associated with the card below'
+                  defaultMessage='Please re-enter the CVV code associated with the card below'
                 />
               </Text>
             </Padding>
@@ -108,24 +135,8 @@ const UpdateSecurityCode: UpdateSecurityCodeComponent = ({ backToEnterAmount })
                   autoComplete='cc-csc'
                   aria-label='Card Security Code'
                   aria-placeholder='CVC'
-                  postfix={
-                    cvvHasData ? (
-                      <IconCheckCircle color={SemanticColors.success} size='medium' />
-                    ) : (
-                      <IconLockClosed color={SemanticColors.muted} size='medium' />
-                    )
-                  }
+                  postfix={<IconLockClosed color={SemanticColors.muted} size='medium' />}
                   onChange={(e) => setCvv(e.currentTarget.value)}
-                  helperText={
-                    cvvHasError ? (
-                      <FormattedMessage
-                        id='copy.invalid_cvv_code'
-                        defaultMessage='The code entered is either invalid or expired. Try Again.'
-                      />
-                    ) : (
-                      <></>
-                    )
-                  }
                 />
               </div>
             </Padding>
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/index.tsx
deleted file mode 100644
index 92c13a1badb..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/index.tsx
+++ /dev/null
@@ -1,102 +0,0 @@
-import React, { PureComponent } from 'react'
-import { connect, ConnectedProps } from 'react-redux'
-import { bindActionCreators, Dispatch } from 'redux'
-
-import { actions, model, selectors } from 'data'
-import { getEnterAmountStepType } from 'data/components/buySell/utils'
-import { RootState } from 'data/rootReducer'
-import { BSVerifyEmailFormValuesType } from 'data/types'
-
-import Loading from '../template.loading'
-import { getData } from './selectors'
-import Success from './template.success'
-
-const { FORM_BS_CHANGE_EMAIL } = model.components.buySell
-
-class VerifyEmail extends PureComponent<Props> {
-  componentDidMount() {
-    this.props.buySellActions.fetchSDDEligibility()
-  }
-
-  componentDidUpdate(prevProps: Props) {
-    if (
-      prevProps.isEmailVerified !== this.props.isEmailVerified &&
-      this.props.isEmailVerified &&
-      this.props.cryptoCurrency &&
-      this.props.fiatCurrency &&
-      this.props.pair
-    ) {
-      this.props.buySellActions.setStep({
-        cryptoCurrency: this.props.cryptoCurrency,
-        fiatCurrency: this.props.fiatCurrency,
-        orderType: this.props.orderType,
-        pair: this.props.pair,
-        step: getEnterAmountStepType(this.props.orderType)
-      })
-    }
-  }
-
-  handleSubmit = () => {
-    const { formValues, identityVerificationActions } = this.props
-    if (formValues) {
-      identityVerificationActions.updateEmail({ email: formValues.email })
-    }
-  }
-
-  onResendEmail = (email: string) => {
-    const { securityCenterActions } = this.props
-    securityCenterActions.resendVerifyEmail(email, 'VERIFICATION')
-  }
-
-  render() {
-    return this.props.data.cata({
-      Failure: () => null,
-      Loading: () => <Loading />,
-      NotAsked: () => <Loading />,
-      Success: (val) => (
-        <Success
-          {...this.props}
-          {...val}
-          resendEmail={this.onResendEmail}
-          onSubmit={this.handleSubmit}
-          initialValues={{
-            email: val.email
-          }}
-        />
-      )
-    })
-  }
-}
-
-const mapStateToProps = (state: RootState) => ({
-  cryptoCurrency: selectors.components.buySell.getCryptoCurrency(state),
-  data: getData(state),
-  fiatCurrency: selectors.components.buySell.getFiatCurrency(state),
-  formValues: selectors.form.getFormValues(FORM_BS_CHANGE_EMAIL)(state) as
-    | BSVerifyEmailFormValuesType
-    | undefined,
-  isEmailVerified: selectors.core.settings.getEmailVerified(state).getOrElse(false),
-  orderType: selectors.components.buySell.getOrderType(state),
-  pair: selectors.components.buySell.getBSPair(state)
-})
-
-const mapDispatchToProps = (dispatch: Dispatch) => ({
-  buySellActions: bindActionCreators(actions.components.buySell, dispatch),
-  formActions: bindActionCreators(actions.form, dispatch),
-  identityVerificationActions: bindActionCreators(
-    actions.components.identityVerification,
-    dispatch
-  ),
-  profileActions: bindActionCreators(actions.modules.profile, dispatch),
-  securityCenterActions: bindActionCreators(actions.modules.securityCenter, dispatch),
-  settingsActions: bindActionCreators(actions.core.settings, dispatch)
-})
-
-const connector = connect(mapStateToProps, mapDispatchToProps)
-
-export type OwnProps = {
-  handleClose: () => void
-}
-export type Props = OwnProps & ConnectedProps<typeof connector>
-export type LinkDispatchPropsType = ReturnType<typeof mapDispatchToProps>
-export default connector(VerifyEmail)
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/selectors.ts
deleted file mode 100644
index 9efa11126fc..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/selectors.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { Remote } from '@core'
-import { model, selectors } from 'data'
-import { RootState } from 'data/rootReducer'
-
-const { FORM_BS_CHANGE_EMAIL } = model.components.buySell
-
-export const getData = (state: RootState) => {
-  const formErrors = selectors.form.getFormSyncErrors(FORM_BS_CHANGE_EMAIL)(state)
-
-  const emailAuth = selectors.signup.getRegisterEmail(state)
-  const emailFromSettings = selectors.core.settings.getEmail(state).getOrElse(null)
-  const isUserSddEligibleR = selectors.components.buySell.isUserSddEligible(state)
-
-  // compare if user changed email from auth
-  const email = emailFromSettings && emailAuth !== emailFromSettings ? emailFromSettings : emailAuth
-
-  const isUserSddEligible = isUserSddEligibleR.getOrElse(false)
-
-  return Remote.Success({
-    email,
-    formErrors,
-    isUserSddEligible
-  })
-}
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/template.success.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/template.success.tsx
deleted file mode 100644
index 1d1e63c317f..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/VerifyEmail/template.success.tsx
+++ /dev/null
@@ -1,220 +0,0 @@
-import React, { useState } from 'react'
-import { FormattedMessage } from 'react-intl'
-import { Field, InjectedFormProps, reduxForm } from 'redux-form'
-import styled, { DefaultTheme } from 'styled-components'
-
-import { Button, HeartbeatLoader, Icon, Link, Text } from 'blockchain-info-components'
-import { FlyoutWrapper } from 'components/Flyout'
-import Form from 'components/Form/Form'
-import FormGroup from 'components/Form/FormGroup'
-import FormItem from 'components/Form/FormItem'
-import TextBox from 'components/Form/TextBox'
-import { model } from 'data'
-import { required, validEmail } from 'services/forms'
-
-import { Props as OwnProps } from '.'
-
-const { FORM_BS_CHANGE_EMAIL } = model.components.buySell
-
-const Wrapper = styled.div`
-  width: 100%;
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-`
-
-const IconWrapper = styled.div<{ color: keyof DefaultTheme }>`
-  display: flex;
-  background: ${(props) => props.theme[props.color]};
-  height: 40px;
-  width: 40px;
-  justify-content: center;
-  align-items: center;
-  border-radius: 50%;
-  margin-right: 20px;
-`
-
-const CloseContainer = styled.div`
-  display: flex;
-  align-items: right;
-  justify-content: flex-end;
-`
-const ContentWrapper = styled.div`
-  display: flex;
-  text-align: center;
-  align-items: center;
-  flex-direction: column;
-  padding: 0 40px;
-  flex: 1;
-  justify-content: center;
-`
-
-const Content = styled.div`
-  display: flex;
-  text-align: center;
-  align-items: center;
-  flex-direction: column;
-  height: 250px;
-  width: 100%;
-`
-
-const ResendContiner = styled.span`
-  display: inline;
-  padding: 40px;
-  text-align: center;
-`
-const CustomForm = styled(Form)`
-  display: flex;
-  flex-direction: column;
-  margin-top: 16px;
-`
-
-export const Label = styled.label`
-  font-size: 16px;
-  font-weight: 400;
-  margin-bottom: 12px;
-  display: block;
-  text-align: left;
-`
-
-const Template: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
-  const [changeEmail, setChangeEmail] = useState(false)
-
-  return (
-    <Wrapper>
-      <FlyoutWrapper>
-        <CloseContainer>
-          <Icon
-            cursor
-            data-e2e='sbCloseModalIcon'
-            name='close'
-            size='20px'
-            color='grey600'
-            role='button'
-            onClick={props.handleClose}
-          />
-        </CloseContainer>
-      </FlyoutWrapper>
-
-      <ContentWrapper>
-        <Content>
-          <IconWrapper color='blue600'>
-            <Icon color='white' name='email' size='24px' />
-          </IconWrapper>
-          <Text size='20px' weight={600} color='black' style={{ marginTop: '8px' }}>
-            {changeEmail ? (
-              <FormattedMessage
-                id='modals.simplebuy.verifyemail.change_your_email'
-                defaultMessage='Change Your Email Address'
-              />
-            ) : (
-              <FormattedMessage id='scenes.verifyemail.title' defaultMessage='Verify Your Email' />
-            )}
-          </Text>
-
-          {changeEmail ? (
-            <CustomForm onSubmit={props.handleSubmit}>
-              <FormGroup>
-                <FormItem>
-                  <Label htmlFor='email'>
-                    <Text weight={500} size='14px'>
-                      <FormattedMessage
-                        id='modals.simplebuy.verifyemail.email_address'
-                        defaultMessage='Email Address'
-                      />
-                    </Text>
-                  </Label>
-                  <Field
-                    name='email'
-                    component={TextBox}
-                    validate={[required, validEmail]}
-                    verified={props.isEmailVerified}
-                    errorBottom
-                  />
-                </FormItem>
-              </FormGroup>
-              <Button
-                data-e2e='submitBSInforAndResidential'
-                height='48px'
-                size='16px'
-                nature='primary'
-                type='submit'
-                fullwidth
-              >
-                {props.submitting ? (
-                  <HeartbeatLoader height='16px' width='16px' color='white' />
-                ) : (
-                  <FormattedMessage
-                    id='modals.simplebuy.verifyemail.save_and_verify'
-                    defaultMessage='Save & Verify'
-                  />
-                )}
-              </Button>
-            </CustomForm>
-          ) : (
-            <>
-              <Text color='grey900' style={{ marginTop: '8px' }} size='16px' weight={500}>
-                <FormattedMessage
-                  id='scenes.verifyemail.description'
-                  defaultMessage='We sent a verification email to <b>{email}</b>. Please click the link in the email to continue.'
-                  values={{
-                    email: props.email
-                  }}
-                />
-              </Text>
-              <Link
-                onClick={() => setChangeEmail(true)}
-                size='16px'
-                style={{ marginTop: '40px' }}
-                weight={500}
-                data-e2e='changeVerifyEmail'
-                color='blue600'
-              >
-                <FormattedMessage
-                  id='modals.simplebuy.verifyemail.change_email'
-                  defaultMessage='Change Email Address'
-                />
-              </Link>
-            </>
-          )}
-        </Content>
-      </ContentWrapper>
-      {!changeEmail && (
-        <ResendContiner>
-          <Text
-            color='grey900'
-            style={{ display: 'inline-block', marginRight: '2px' }}
-            size='16px'
-            weight={500}
-          >
-            <FormattedMessage
-              id='modals.simplebuy.verifyemail.dint_get'
-              defaultMessage='Didn’t get the email?'
-            />
-          </Text>
-
-          <Link
-            onClick={() => props.resendEmail(props.email)}
-            size='16px'
-            style={{ marginTop: '40px' }}
-            weight={500}
-            data-e2e='resendVerifyEmail'
-            color='blue600'
-          >
-            <FormattedMessage id='modals.simplebuy.verifyemail.resend' defaultMessage='Resend' />
-          </Link>
-        </ResendContiner>
-      )}
-    </Wrapper>
-  )
-}
-
-type Props = OwnProps & {
-  email: string
-  resendEmail: (email: string) => void
-}
-
-export default reduxForm<{}, Props>({
-  destroyOnUnmount: false,
-  form: FORM_BS_CHANGE_EMAIL
-})(Template)
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/index.tsx
index c8049e49c7b..cc869585433 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/index.tsx
@@ -31,7 +31,6 @@ import {
 import ModalEnhancer from 'providers/ModalEnhancer'
 
 import { Loading as StdLoading, LoadingTextEnum } from '../components'
-import Rejected from '../components/Rejected'
 import { ModalPropsType } from '../types'
 import AddCardCheckoutDotCom from './AddCardCheckoutDotCom'
 import AddCardVgs from './AddCardVgs'
@@ -52,14 +51,12 @@ import getData from './selectors'
 import SellEnterAmount from './SellEnterAmount'
 import SellOrderSummary from './SellOrderSummary'
 import Loading from './template.loading'
-import Pending from './template.pending'
 import ThreeDSHandlerCheckoutDotCom from './ThreeDSHandlerCheckoutDotCom'
 import ThreeDSHandlerEverypay from './ThreeDSHandlerEverypay'
 import ThreeDSHandlerFakeCardAcquirer from './ThreeDSHandlerFakeCardAcquirer'
 import ThreeDSHandlerStripe from './ThreeDSHandlerStripe'
 import UpdateSecurityCode from './UpdateSecurityCode'
 import UpgradeToGold from './UpgradeToGold'
-import VerifyEmail from './VerifyEmail'
 
 const { FORM_BS_CHECKOUT, FORMS_BS_BILLING_ADDRESS } = model.components.buySell
 
@@ -155,196 +152,160 @@ class BuySell extends PureComponent<Props, State> {
           <Loading />
         </Flyout>
       ),
-      Success: (val) => {
-        const { userData } = val
-        const { kycState } = userData
-        const isUserRejectedOrExpired = kycState === 'REJECTED' || kycState === 'EXPIRED'
-        const isUserPending = kycState === 'UNDER_REVIEW' || kycState === 'PENDING'
-
-        return isUserRejectedOrExpired ? (
-          <Flyout
-            {...this.props}
-            onClose={this.handleClose}
-            isOpen={this.state.show}
-            data-e2e='buySellModal'
-          >
-            <Rejected handleClose={this.handleClose} />
-          </Flyout>
-        ) : isUserPending ? (
-          <Flyout
-            {...this.props}
-            onClose={this.handleClose}
-            isOpen={this.state.show}
-            data-e2e='buySellModal'
-          >
-            <Pending
-              handleClose={this.handleClose}
-              handleRefresh={() => {
-                this.props.profileActions.fetchUserDataLoading()
-                this.props.profileActions.fetchUser()
-              }}
-            />
-          </Flyout>
-        ) : (
-          <Flyout
-            {...this.props}
-            onClose={this.handleClose}
-            isOpen={this.state.show}
-            data-e2e='buySellModal'
-          >
-            {this.props.step === 'ENTER_AMOUNT' && (
-              <FlyoutChild>
-                <EnterAmount {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'SELL_ENTER_AMOUNT' && (
-              <FlyoutChild>
-                <SellEnterAmount {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'UPDATE_SECURITY_CODE' && (
-              <FlyoutChild>
-                <UpdateSecurityCode
-                  backToEnterAmount={this.backToEnterAmount}
-                  handleClose={this.handleClose}
-                />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'CRYPTO_SELECTION' && (
-              <FlyoutChild>
-                <CryptoSelection {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'PAYMENT_METHODS' && (
-              <FlyoutChild>
-                <PaymentMethods {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'LINKED_PAYMENT_ACCOUNTS' && (
-              <FlyoutChild>
-                <LinkedPaymentAccounts {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'DETERMINE_CARD_PROVIDER' && (
-              <FlyoutChild>
-                <Loading />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'ADD_CARD_VGS' && (
-              <FlyoutChild>
-                <AddCardVgs handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'ADD_CARD_CHECKOUTDOTCOM' && (
-              <FlyoutChild>
-                <AddCardCheckoutDotCom {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === '3DS_HANDLER_FAKE_CARD_ACQUIRER' && (
-              <FlyoutChild>
-                <ThreeDSHandlerFakeCardAcquirer {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === '3DS_HANDLER_EVERYPAY' && (
-              <FlyoutChild>
-                <ThreeDSHandlerEverypay {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === '3DS_HANDLER_CHECKOUTDOTCOM' && (
-              <FlyoutChild>
-                <ThreeDSHandlerCheckoutDotCom {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === '3DS_HANDLER_STRIPE' && (
-              <FlyoutChild>
-                <ThreeDSHandlerStripe {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'BILLING_ADDRESS' && (
-              <FlyoutChild>
-                <BillingAddress {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'AUTHORIZE_PAYMENT' && (
-              <FlyoutChild>
-                <Authorize {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'CHECKOUT_CONFIRM' && (
-              <FlyoutChild>
-                <CheckoutConfirm {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'ORDER_SUMMARY' && (
-              <FlyoutChild>
-                <OrderSummary {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {/*
+      Success: () => (
+        <Flyout
+          {...this.props}
+          onClose={this.handleClose}
+          isOpen={this.state.show}
+          data-e2e='buySellModal'
+        >
+          {this.props.step === 'ENTER_AMOUNT' && (
+            <FlyoutChild>
+              <EnterAmount {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'SELL_ENTER_AMOUNT' && (
+            <FlyoutChild>
+              <SellEnterAmount {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'UPDATE_SECURITY_CODE' && (
+            <FlyoutChild>
+              <UpdateSecurityCode
+                backToEnterAmount={this.backToEnterAmount}
+                handleClose={this.handleClose}
+              />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'CRYPTO_SELECTION' && (
+            <FlyoutChild>
+              <CryptoSelection {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'PAYMENT_METHODS' && (
+            <FlyoutChild>
+              <PaymentMethods {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'LINKED_PAYMENT_ACCOUNTS' && (
+            <FlyoutChild>
+              <LinkedPaymentAccounts {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'DETERMINE_CARD_PROVIDER' && (
+            <FlyoutChild>
+              <Loading />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'ADD_CARD_VGS' && (
+            <FlyoutChild>
+              <AddCardVgs handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'ADD_CARD_CHECKOUTDOTCOM' && (
+            <FlyoutChild>
+              <AddCardCheckoutDotCom {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === '3DS_HANDLER_FAKE_CARD_ACQUIRER' && (
+            <FlyoutChild>
+              <ThreeDSHandlerFakeCardAcquirer {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === '3DS_HANDLER_EVERYPAY' && (
+            <FlyoutChild>
+              <ThreeDSHandlerEverypay {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === '3DS_HANDLER_CHECKOUTDOTCOM' && (
+            <FlyoutChild>
+              <ThreeDSHandlerCheckoutDotCom {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === '3DS_HANDLER_STRIPE' && (
+            <FlyoutChild>
+              <ThreeDSHandlerStripe {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'BILLING_ADDRESS' && (
+            <FlyoutChild>
+              <BillingAddress {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'AUTHORIZE_PAYMENT' && (
+            <FlyoutChild>
+              <Authorize {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'CHECKOUT_CONFIRM' && (
+            <FlyoutChild>
+              <CheckoutConfirm {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'ORDER_SUMMARY' && (
+            <FlyoutChild>
+              <OrderSummary {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {/*
                 used for sell only now, eventually buy as well
                 TODO: use swap2 quote for buy AND sell
             */}
-            {this.props.step === 'PREVIEW_SELL' && (
-              <FlyoutChild>
-                <PreviewSell {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'SELL_ORDER_SUMMARY' && (
-              <FlyoutChild>
-                <SellOrderSummary {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'BANK_WIRE_DETAILS' && (
-              <FlyoutChild>
-                <BankWireDetails {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'OPEN_BANKING_CONNECT' && (
-              <FlyoutChild>
-                <OpenBankingConnect {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'KYC_REQUIRED' && (
-              <FlyoutChild>
-                <KycRequired {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'VERIFY_EMAIL' && (
-              <FlyoutChild>
-                <VerifyEmail {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'UPGRADE_TO_GOLD' && (
-              <FlyoutChild>
-                <UpgradeToGold {...this.props} handleClose={this.handleClose} />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'FREQUENCY' && (
-              <FlyoutChild>
-                <Frequency
-                  {...this.props}
-                  backToEnterAmount={this.backToEnterAmount}
-                  handleClose={this.handleClose}
-                />
-              </FlyoutChild>
-            )}
-            {this.props.step === 'LOADING' && (
-              <FlyoutChild>
-                <StdLoading text={LoadingTextEnum.GETTING_READY} />
-              </FlyoutChild>
-            )}
-            {/** Only Plaid errors for now */}
-            {this.props.step === 'PAYMENT_ACCOUNT_ERROR' && (
-              <FlyoutChild>
-                <PaymentAccountError
-                  reason={this.props.reason}
-                  buttonHandler={this.paymentErrorHandler}
-                />
-              </FlyoutChild>
-            )}
-          </Flyout>
-        )
-      }
+          {this.props.step === 'PREVIEW_SELL' && (
+            <FlyoutChild>
+              <PreviewSell {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'SELL_ORDER_SUMMARY' && (
+            <FlyoutChild>
+              <SellOrderSummary {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'BANK_WIRE_DETAILS' && (
+            <FlyoutChild>
+              <BankWireDetails {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'OPEN_BANKING_CONNECT' && (
+            <FlyoutChild>
+              <OpenBankingConnect {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'KYC_REQUIRED' && (
+            <FlyoutChild>
+              <KycRequired {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'UPGRADE_TO_GOLD' && (
+            <FlyoutChild>
+              <UpgradeToGold {...this.props} handleClose={this.handleClose} />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'FREQUENCY' && (
+            <FlyoutChild>
+              <Frequency
+                {...this.props}
+                backToEnterAmount={this.backToEnterAmount}
+                handleClose={this.handleClose}
+              />
+            </FlyoutChild>
+          )}
+          {this.props.step === 'LOADING' && (
+            <FlyoutChild>
+              <StdLoading text={LoadingTextEnum.GETTING_READY} />
+            </FlyoutChild>
+          )}
+          {/** Only Plaid errors for now */}
+          {this.props.step === 'PAYMENT_ACCOUNT_ERROR' && (
+            <FlyoutChild>
+              <PaymentAccountError
+                reason={this.props.reason}
+                buttonHandler={this.paymentErrorHandler}
+              />
+            </FlyoutChild>
+          )}
+        </Flyout>
+      )
     })
   }
 }
@@ -456,7 +417,7 @@ type LinkStatePropsType =
       order?: BSOrderType
       orderType: BSOrderActionType
       pair: BSPairType
-      step: 'ENTER_AMOUNT' | 'SELL_ENTER_AMOUNT' | 'VERIFY_EMAIL'
+      step: 'ENTER_AMOUNT' | 'SELL_ENTER_AMOUNT'
     }
   | {
       orderType: BSOrderActionType
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/template.pending.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/template.pending.tsx
deleted file mode 100644
index dc4b5600d32..00000000000
--- a/packages/blockchain-wallet-v4-frontend/src/modals/BuySell/template.pending.tsx
+++ /dev/null
@@ -1,83 +0,0 @@
-import React from 'react'
-import { FormattedMessage } from 'react-intl'
-import styled from 'styled-components'
-
-import { BlockchainLoader, Button, Icon, Text } from 'blockchain-info-components'
-import { FlyoutWrapper } from 'components/Flyout'
-
-const Top = styled(FlyoutWrapper)`
-  padding-bottom: 0px;
-  position: relative;
-  height: 100%;
-`
-const Container = styled.div`
-  width: 100%;
-  height: 100%;
-`
-const MainText = styled(Text)`
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-`
-const Subcontent = styled(Text)`
-  margin: 38px 0 46px 0;
-  display: flex;
-  justify-content: center;
-`
-const Title = styled(Text)`
-  margin: 16px 0;
-  text-align: left;
-`
-
-const Pending: React.FC<{
-  handleClose: () => void
-  handleRefresh: () => void
-}> = (props) => {
-  return (
-    <Top>
-      <MainText color='grey800' size='20px' weight={600}>
-        <Icon cursor data-e2e='sbCloseModalIcon' name='user' size='22px' color='blue600' />
-        <Icon
-          cursor
-          data-e2e='sbCloseModalIcon'
-          name='close'
-          size='20px'
-          color='grey600'
-          role='button'
-          onClick={props.handleClose}
-        />
-      </MainText>
-      <Container>
-        <Title color='textBlack' size='24px' weight={600}>
-          <FormattedMessage
-            id='modals.simplebuy.underreview'
-            defaultMessage='ID Verification Pending'
-          />
-        </Title>
-        <Title color='grey800' size='16px' weight={500}>
-          <FormattedMessage
-            id='scenes.exchange.getstarted.status.pending.description'
-            defaultMessage='We are currently reviewing your application. Hang tight! In just a few minutes you will be all set to trade cryptocurrency. You should receive an update within 5 minutes.'
-          />
-        </Title>
-        <Subcontent>
-          <BlockchainLoader height='80px' width='80px' />
-        </Subcontent>
-        <Button
-          jumbo
-          nature='primary'
-          data-e2e='refreshKyc'
-          onClick={props.handleRefresh}
-          fullwidth
-        >
-          <FormattedMessage
-            id='scenes.exchange.exchangeform.refreshlatest'
-            defaultMessage='Refresh status.'
-          />
-        </Button>
-      </Container>
-    </Top>
-  )
-}
-
-export default Pending
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/EthWalletBalances.selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/EthWalletBalances.selectors.ts
index f86b7c6ddb0..debeab7737d 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/EthWalletBalances.selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/EthWalletBalances.selectors.ts
@@ -1,51 +1,31 @@
 import { lift } from 'ramda'
 
 import { convertCoinToFiat } from '@core/exchange'
-import { AccountTokensBalancesResponseType } from '@core/types'
+import { ExtractSuccess, RatesType } from '@core/types'
 import { createDeepEqualSelector } from '@core/utils'
 import { selectors } from 'data'
-import { RootState } from 'data/rootReducer'
 
 export const getData = createDeepEqualSelector(
-  [
-    selectors.balances.getCoinNonCustodialBalance('ETH'),
-    selectors.core.settings.getCurrency,
-    selectors.core.data.eth.getErc20AccountTokenBalances,
-    // @ts-ignore
-    (state) => selectors.core.data.coins.getRates('ETH', state),
-    (state) => state
-  ],
-  (ethBalanceR, currencyR, erc20BalancesR, ethRatesR, state: RootState) => {
-    const transform = (
-      ethBalance,
-      currency,
-      ethRates,
-      erc20Balances: AccountTokensBalancesResponseType['tokenAccounts']
-    ) => {
+  [selectors.core.data.coins.getUnifiedBalances, selectors.core.settings.getCurrency],
+  (unifiedBalancesR, currencyR) => {
+    const transform = (unifiedBalances: ExtractSuccess<typeof unifiedBalancesR>, currency) => {
+      const ethBalance = unifiedBalances.find(({ ticker }) => ticker === 'ETH')
+      const ethBalanceAmt = ethBalance?.amount?.amount || 0
+      const ethRates: RatesType = { price: ethBalance?.price || 0, timestamp: 0, volume24h: 0 }
       let total = Number(
-        convertCoinToFiat({ coin: 'ETH', currency, rates: ethRates, value: ethBalance })
+        convertCoinToFiat({ coin: 'ETH', currency, rates: ethRates, value: ethBalanceAmt })
       )
-      erc20Balances
-        .filter((curr) => !!window.coins[curr.tokenSymbol])
-        .map((curr) => {
-          const symbol = Object.keys(window.coins).find(
-            (coin) =>
-              window.coins[coin].coinfig.type?.erc20Address?.toLowerCase() ===
-              curr.tokenHash.toLowerCase()
-          )
-          if (!symbol) return
-
-          const transform2 = (rates) => {
-            if (!rates.price) return 0
-
-            total += Number(
-              convertCoinToFiat({ coin: symbol, currency, rates, value: curr.balance })
-            )
-          }
-
-          const ratesR = selectors.core.data.coins.getRates(symbol, state)
-          return lift(transform2)(ratesR)
+      const erc20Balances = unifiedBalances
+        .filter((balance) => {
+          return !!window.coins[balance.ticker]
         })
+        .filter((balance) => !!window.coins[balance.ticker].coinfig.type.erc20Address)
+
+      erc20Balances.forEach((erc20Balance) => {
+        const value = erc20Balance.amount?.amount || 0
+        const rates: RatesType = { price: erc20Balance.price, timestamp: 0, volume24h: 0 }
+        total += Number(convertCoinToFiat({ coin: erc20Balance.ticker, currency, rates, value }))
+      })
 
       return {
         currency,
@@ -55,6 +35,6 @@ export const getData = createDeepEqualSelector(
       }
     }
 
-    return lift(transform)(ethBalanceR, currencyR, ethRatesR, erc20BalancesR)
+    return lift(transform)(unifiedBalancesR, currencyR)
   }
 )
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/index.tsx
index 0202e3375bf..b466a19de07 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/EthWalletBalances/index.tsx
@@ -48,9 +48,7 @@ class EthWalletBalance extends PureComponent<Props, State> {
   }
 
   refresh = () => {
-    this.props.fetchErc20Balances()
-    this.props.ethActions.fetchDataLoading()
-    this.props.ethActions.fetchData()
+    this.props.coinsActions.fetchUnifiedBalances()
   }
 
   render() {
@@ -188,35 +186,30 @@ class EthWalletBalance extends PureComponent<Props, State> {
                   </Flex>
                 </Row>
                 {erc20Balances
-                  .filter(({ tokenSymbol }) => !!window.coins[tokenSymbol])
-                  .map(({ balance, tokenSymbol }) => (
-                    <Row key={tokenSymbol}>
+                  .filter(({ ticker }) => !!window.coins[ticker])
+                  .map(({ amount, ticker }) => (
+                    <Row key={ticker}>
                       <Flex justifyContent='space-between' alignItems='center'>
                         <Flex gap={16} alignItems='center'>
-                          <BlockchainIcon size='24px' name={tokenSymbol} />
+                          <BlockchainIcon size='24px' name={ticker} />
                           <Flex gap={2} flexDirection='column'>
                             <Text color='black' weight={600}>
-                              {window.coins[tokenSymbol].coinfig.name}
+                              {window.coins[ticker].coinfig.name}
                             </Text>
                             <Text size='14px' color='grey500' weight={500}>
-                              {window.coins[tokenSymbol].coinfig.displaySymbol} Private Key Wallet
+                              {window.coins[ticker].coinfig.displaySymbol} Private Key Wallet
                             </Text>
                           </Flex>
                         </Flex>
                         <Flex gap={2} flexDirection='column'>
                           <Flex justifyContent='flex-end'>
-                            <FiatDisplay coin={tokenSymbol} color='black' weight={600}>
-                              {balance}
+                            <FiatDisplay coin={ticker} color='black' weight={600}>
+                              {amount}
                             </FiatDisplay>
                           </Flex>
                           <Flex justifyContent='flex-end'>
-                            <CoinDisplay
-                              coin={tokenSymbol}
-                              size='14px'
-                              color='grey500'
-                              weight={500}
-                            >
-                              {balance}
+                            <CoinDisplay coin={ticker} size='14px' color='grey500' weight={500}>
+                              {amount}
                             </CoinDisplay>
                           </Flex>
                         </Flex>
@@ -257,8 +250,7 @@ const mapStateToProps = (state) => ({
 
 const mapDispatchToProps = (dispatch) => ({
   buySellActions: bindActionCreators(actions.components.buySell, dispatch),
-  ethActions: bindActionCreators(actions.core.data.eth, dispatch),
-  fetchErc20Balances: bindActionCreators(actions.core.data.eth.fetchErc20Data, dispatch)
+  coinsActions: bindActionCreators(actions.core.data.coins, dispatch)
 })
 
 const connector = connect(mapStateToProps, mapDispatchToProps)
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/selectors.js b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/selectors.js
index 57206254856..321c6d1a8c7 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/selectors.js
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/selectors.js
@@ -16,7 +16,7 @@ const getData = createDeepEqualSelector(
     (state, coin) => {
       const { coinfig } = window.coins[coin]
       return coinfig.type.erc20Address
-        ? selectors.core.data.eth.getErc20CurrentBalance(state, coin)
+        ? selectors.core.data.coins.getCoinUnifiedBalance(coin)(state)
         : selectors.core.data.eth.getCurrentBalance(state)
     },
     (state) => selectors.core.common.eth.getErc20AccountBalances(state, 'PAX').map(head),
@@ -46,7 +46,6 @@ const getData = createDeepEqualSelector(
       const priorityFee = path(['fees', 'priority'], payment)
       const minFee = path(['fees', 'limits', 'min'], payment)
       const maxFee = path(['fees', 'limits', 'max'], payment)
-      const isSufficientEthForErc20 = path(['isSufficientEthForErc20'], payment)
       const isRetryAttempt = path(['isRetryAttempt'], payment)
       const minFeeRequiredForRetry = path(['minFeeRequiredForRetry'], payment)
       const isContractChecked = Remote.Success.is(isContractR)
@@ -88,7 +87,6 @@ const getData = createDeepEqualSelector(
         isContractChecked,
         isMnemonicVerified,
         isRetryAttempt,
-        isSufficientEthForErc20,
         maxFee,
         minFee,
         minFeeRequiredForRetry,
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/template.success.js b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/template.success.js
index b1c373e5433..52c50d60d08 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/template.success.js
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Eth/SendEth/FirstStep/template.success.js
@@ -80,7 +80,6 @@ const FirstStep = (props) => {
     isContractChecked,
     isMnemonicVerified,
     isRetryAttempt,
-    isSufficientEthForErc20,
     minFeeRequiredForRetry,
     priorityFee,
     pristine,
@@ -91,7 +90,6 @@ const FirstStep = (props) => {
     verifyIdentity
   } = props
   const isFromCustody = from && from.type === 'CUSTODIAL'
-  const disableDueToLowEth = coin !== 'ETH' && !isSufficientEthForErc20 && !isFromCustody
   const disableRetryAttempt =
     isRetryAttempt && new BigNumber(fee).isLessThanOrEqualTo(minFeeRequiredForRetry)
   const disableCustodySend = isFromCustody && !isMnemonicVerified
@@ -285,7 +283,6 @@ const FirstStep = (props) => {
         </CustomFeeAlertBanner>
       ) : null}
       {disableRetryAttempt && <MinFeeForRetryInvalid />}
-      {disableDueToLowEth && <LowEthWarningForErc20 coin={coin} />}
       {isFromCustody && !isMnemonicVerified ? <MnemonicRequiredForCustodySend /> : null}
       {isFromCustody &&
       !isEmpty(sendLimits) &&
@@ -304,7 +301,6 @@ const FirstStep = (props) => {
             invalid ||
             !amount ||
             !isContractChecked ||
-            disableDueToLowEth ||
             disableRetryAttempt ||
             disableCustodySend ||
             Remote.Loading.is(balanceStatus)
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Interest/DepositForm/template.success.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Interest/DepositForm/template.success.tsx
index 5f3fe9182e7..75713def4eb 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Interest/DepositForm/template.success.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Interest/DepositForm/template.success.tsx
@@ -44,7 +44,6 @@ import {
   CustomField,
   CustomForm,
   CustomFormLabel,
-  ErrorText,
   FiatMaxContainer,
   FORM_NAME,
   GreyBlueCartridge,
@@ -95,7 +94,6 @@ const DepositForm: React.FC<InjectedFormProps<{ form: string }, Props> & Props>
     interestLimits,
     interestRates,
     invalid,
-    payment,
     rates,
     rewardsEDDDepositLimits,
     submitting,
@@ -128,12 +126,6 @@ const DepositForm: React.FC<InjectedFormProps<{ form: string }, Props> & Props>
   const depositAmountError =
     typeof formErrors.depositAmount === 'string' && formErrors.depositAmount
   const isErc20 = !!window.coins[coin].coinfig.type.erc20Address
-  const insufficientEth =
-    payment &&
-    isErc20 &&
-    !!window.coins[coin].coinfig.type.erc20Address &&
-    // @ts-ignore
-    !payment.isSufficientEthForErc20
 
   const showEDDDepositLimit =
     checkIsAmountUnderDepositLimit(rewardsEDDDepositLimits, coin, depositAmountFiat) &&
@@ -230,58 +222,46 @@ const DepositForm: React.FC<InjectedFormProps<{ form: string }, Props> & Props>
                 rate: interestRates[coin]
               }}
             />{' '}
-            {!insufficientEth && (
-              <>
-                <FormattedMessage
-                  id='modals.interest.deposit.youcantransfer'
-                  defaultMessage='You can transfer up to'
-                  values={{
-                    coin
-                  }}
-                />{' '}
-                <FiatMaxContainer
-                  onClick={() =>
-                    formActions.change(
-                      FORM_NAME,
-                      'depositAmount',
-                      displayCoin ? earnDepositLimits.maxCoin : earnDepositLimits.maxFiat
-                    )
-                  }
-                >
-                  {displayCoin ? (
-                    <Text color='blue600' size='14px' weight={500}>
-                      {earnDepositLimits.maxCoin}{' '}
-                    </Text>
-                  ) : (
-                    <Text color='blue600' size='14px' weight={500}>
-                      {maxDepositFiat}{' '}
-                    </Text>
-                  )}
-                </FiatMaxContainer>{' '}
-                <FormattedMessage
-                  id='modals.interest.deposit.uptoamount2'
-                  defaultMessage='of {coin} from this wallet.'
-                  values={{
-                    coin: coinfig.displaySymbol
-                  }}
-                />
-                <TooltipHost id='modals.interest.depositmax.tooltip'>
-                  <TooltipIcon name='info' size='12px' />
-                </TooltipHost>
-              </>
-            )}
+            <>
+              <FormattedMessage
+                id='modals.interest.deposit.youcantransfer'
+                defaultMessage='You can transfer up to'
+                values={{
+                  coin
+                }}
+              />{' '}
+              <FiatMaxContainer
+                onClick={() =>
+                  formActions.change(
+                    FORM_NAME,
+                    'depositAmount',
+                    displayCoin ? earnDepositLimits.maxCoin : earnDepositLimits.maxFiat
+                  )
+                }
+              >
+                {displayCoin ? (
+                  <Text color='blue600' size='14px' weight={500}>
+                    {earnDepositLimits.maxCoin}{' '}
+                  </Text>
+                ) : (
+                  <Text color='blue600' size='14px' weight={500}>
+                    {maxDepositFiat}{' '}
+                  </Text>
+                )}
+              </FiatMaxContainer>{' '}
+              <FormattedMessage
+                id='modals.interest.deposit.uptoamount2'
+                defaultMessage='of {coin} from this wallet.'
+                values={{
+                  coin: coinfig.displaySymbol
+                }}
+              />
+              <TooltipHost id='modals.interest.depositmax.tooltip'>
+                <TooltipIcon name='info' size='12px' />
+              </TooltipHost>
+            </>
           </Text>
         </InfoText>
-        {isErc20 && insufficientEth && (
-          <ErrorText>
-            <Icon name='alert-filled' color='red600' style={{ marginRight: '4px' }} />
-            <FormattedMessage
-              id='modals.interest.deposit.notenougheth'
-              defaultMessage='ETH is required to send {coinTicker}. You do not have enough ETH to perform a transaction.'
-              values={{ coinTicker: coin }}
-            />
-          </ErrorText>
-        )}
         <CoinBalanceDropdown
           {...props}
           includeCustodial
@@ -319,8 +299,6 @@ const DepositForm: React.FC<InjectedFormProps<{ form: string }, Props> & Props>
             coin={coin}
             component={NumberBox}
             data-e2e='depositAmount'
-            // @ts-ignore
-            disabled={insufficientEth}
             displayCoin={displayCoin}
             name='depositAmount'
             validate={[required, minDepositAmount, maxDepositAmount]}
@@ -620,7 +598,7 @@ const DepositForm: React.FC<InjectedFormProps<{ form: string }, Props> & Props>
         <ButtonContainer>
           <Button
             data-e2e='interestDepositSubmit'
-            disabled={invalid || insufficientEth}
+            disabled={invalid}
             fullwidth
             height='48px'
             nature='primary'
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/Buy/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/Buy/index.tsx
index 55d9793d93c..a1fef8e6b7b 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/Buy/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/Buy/index.tsx
@@ -179,11 +179,10 @@ const Buy: React.FC<Props> = (props) => {
   )
 }
 const mapStateToProps = (state) => ({
-  erc20BalanceR: selectors.core.data.eth.getErc20Balance(
-    state,
+  erc20BalanceR: selectors.core.data.coins.getCoinUnifiedBalance(
     // @ts-ignore
     selectors.form.getFormValues('nftBuy')(state)?.coin || 'WETH'
-  ),
+  )(state),
   ethBalancesR: selectors.balances.getCoinBalancesTypeSeparated('ETH')(state),
   formValues: selectors.form.getFormValues('nftBuy')(state) as {
     amount: string
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/index.tsx
index bf8513ee41f..fc8adc57d8e 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/index.tsx
@@ -85,7 +85,7 @@ const MakeOffer: React.FC<Props> = (props) => {
   const wrapFees = wrapEthFees.getOrElse({ gasPrice: 0, totalFees: 0 } as GasDataI)
   const offerFees = fees.getOrElse({ gasPrice: 0, totalFees: 0 } as GasDataI)
   const ethBalance = new BigNumber(selfCustodyBalance)
-  const erc20Balance = erc20BalanceR.getOrElse(0)
+  const erc20Balance = erc20BalanceR.getOrElse(new BigNumber(0))
   const maxWrapPossible = ethBalance
     .minus(wrapFees.totalFees * wrapFees.gasPrice)
     .minus(offerFees.totalFees * offerFees.gasPrice)
@@ -97,7 +97,7 @@ const MakeOffer: React.FC<Props> = (props) => {
   // Standard Values
   const standardErc20Balance = convertCoinToCoin({
     coin: formValues.coin || 'WETH',
-    value: erc20Balance
+    value: erc20Balance.toString()
   })
   const standardMaxWrapPossible = convertCoinToCoin({
     coin: 'ETH',
@@ -288,7 +288,9 @@ const mapStateToProps = (state) => {
   const formValues = selectors.form.getFormValues('nftMakeOffer')(state) as NftMakeOfferFormValues
 
   return {
-    erc20BalanceR: selectors.core.data.eth.getErc20Balance(state, formValues?.coin || 'WETH'),
+    erc20BalanceR: selectors.core.data.coins.getCoinUnifiedBalance(formValues?.coin || 'WETH')(
+      state
+    ),
     ethBalancesR: selectors.balances.getCoinBalancesTypeSeparated('ETH')(state),
     formErrors: selectors.form.getFormSyncErrors('nftMakeOffer')(state) as { amount: boolean },
     formValues,
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/validation.ts b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/validation.ts
index d652a1c17c1..2c1c60cb0bc 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/validation.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Nfts/NftOrder/MakeOffer/validation.ts
@@ -1,9 +1,11 @@
+import BigNumber from 'bignumber.js'
+
 import { convertCoinToCoin } from '@core/exchange'
 
 import { NftMakeOfferFormValues, Props } from '.'
 
 export const validate = (formValues: NftMakeOfferFormValues, props: Props) => {
-  const erc20Balance = props.erc20BalanceR.getOrElse(0)
+  const erc20Balance = props.erc20BalanceR.getOrElse(new BigNumber(0))
   const [selfCustodyBalance] = props.ethBalancesR.getOrElse([0, 0])
 
   // let index.tsx handle this
@@ -16,7 +18,11 @@ export const validate = (formValues: NftMakeOfferFormValues, props: Props) => {
   if (formValues.amount) {
     const standardAmt = Number(formValues.amount)
     const standardBalance = Number(
-      convertCoinToCoin({ baseToStandard: true, coin: formValues.coin, value: erc20Balance })
+      convertCoinToCoin({
+        baseToStandard: true,
+        coin: formValues.coin,
+        value: erc20Balance.toString()
+      })
     )
 
     if (standardAmt > standardBalance) {
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/InsufficientBalanceError/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/InsufficientBalanceError/index.tsx
index 13d16956a3b..4a54f80bda1 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/InsufficientBalanceError/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/InsufficientBalanceError/index.tsx
@@ -34,7 +34,7 @@ const InsufficientBalanceError: React.FC<Props> = ({ handleMax, tryAgain }) => {
           data-e2e='sendMax'
           nature='primary'
         >
-          Send Max
+          <FormattedMessage id='copy.send_max' defaultMessage='Send Max' />
         </Button>
         <Text style={{ marginTop: '8px' }} size='12px' weight={500}>
           <FormattedMessage defaultMessage='or' id='copy.or' />
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/index.tsx
index 08b8b3f4a22..5e0444d3fc0 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/Confirm/index.tsx
@@ -87,6 +87,7 @@ const Confirm: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
       rates,
       walletCurrency
     })
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   return (
@@ -212,7 +213,7 @@ const Confirm: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
                   </FiatDisplay>
                 </div>
               </CustomRow>
-              {tx.rawTx?.payload.payload.memo.content ? (
+              {tx.rawTx?.payload.payload?.memo.content ? (
                 <CustomRow>
                   <div>
                     <Text size='16px' weight={500} color='black'>
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/EnterAmount/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/EnterAmount/index.tsx
index 81dc65038e1..9e3cddb8482 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/EnterAmount/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/EnterAmount/index.tsx
@@ -27,6 +27,7 @@ import { selectors } from 'data'
 import { convertBaseToStandard } from 'data/components/exchange/services'
 import { SendCryptoStepType } from 'data/components/sendCrypto/types'
 import { SwapBaseCounterTypes } from 'data/types'
+import { useCoinConfig } from 'hooks'
 import { getEffectiveLimit, getEffectivePeriod } from 'services/custodial'
 import { media } from 'services/styles'
 import { hexToRgb } from 'utils/helpers'
@@ -107,6 +108,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
   const { amount, fix, selectedAccount, to } = formValues
   const { coin, type } = selectedAccount
   const isAccount = type === SwapBaseCounterTypes.ACCOUNT
+  const { data: coinfig } = useCoinConfig({ coin })
 
   const max = Number(convertCoinToCoin({ coin, value: selectedAccount.balance }))
   const min = minR.getOrElse(0)
@@ -180,7 +182,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
           <Text size='14px' color='grey600' weight={600}>
             <FormattedMessage defaultMessage='From' id='copy.from' />
             {': '}
-            {selectedAccount.label} ({max} {coin})
+            {selectedAccount.label} ({max} {coinfig?.displaySymbol || coin})
           </Text>
           <Text size='16px' color='grey900' weight={600} style={{ marginTop: '6px' }}>
             <FormattedMessage defaultMessage='To:' id='copy.to:' />{' '}
@@ -286,7 +288,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
               size='14px'
               style={{ marginTop: '4px', textAlign: 'right' }}
             >
-              {isAccount ? max : maxMinusFee} {coin}
+              {isAccount ? max : maxMinusFee} {coinfig?.displaySymbol}
             </Text>
           </Text>
           <div style={{ width: '30%' }}>
@@ -418,7 +420,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
                 defaultMessage='The max you can send from this wallet is {coin} {amount}. Buy {coin} {amount} now to send this amount.'
                 values={{
                   amount: max,
-                  coin
+                  coin: coinfig?.displaySymbol || coin
                 }}
               />
             </Text>
@@ -433,7 +435,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
                 amount:
                   fix === 'FIAT'
                     ? `${Currencies[walletCurrency].units[walletCurrency].symbol}${min}`
-                    : `${coin}${min}`
+                    : `${coinfig?.displaySymbol || coin}${min}`
               }}
             />
           </AlertButton>
@@ -452,7 +454,7 @@ const SendEnterAmount: React.FC<InjectedFormProps<{}, Props> & Props> = (props)
                 origin: 'Send'
               })
             }
-            buyAmount={`${coin} ${amount}`}
+            buyAmount={`${coinfig?.displaySymbol || coin} ${amount}`}
             coin={coin}
           />
         )}
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/types.ts b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/types.ts
index 21cbba022fc..02968130b02 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/SendCrypto/types.ts
@@ -1,4 +1,4 @@
-import { BuildTxFeeType } from '@core/network/api/coin/types'
+import { BuildTxFeeType } from '@core/network/api/coins/types'
 import { SwapAccountType } from 'data/types'
 
 export type SendFormType = {
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/index.tsx
index 8aa76296d57..781e442863d 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/index.tsx
@@ -5,6 +5,7 @@ import AutoSizer from 'react-virtualized-auto-sizer'
 import { FixedSizeList as List } from 'react-window'
 import { equals } from 'ramda'
 
+import { WalletAccountSuperAppType } from '@core/types'
 import { Text } from 'blockchain-info-components'
 import {
   FlyoutContainer,
@@ -149,6 +150,7 @@ const mapStateToProps = (state: RootState, ownProps: OwnProps) => ({
 const connector = connect(mapStateToProps)
 
 export type OwnProps = BaseProps & {
+  fromType?: WalletAccountSuperAppType
   handleClose: () => void
   side: 'BASE' | 'COUNTER'
 }
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/selectors.ts
index 191d77d6be5..83986ba22c6 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/CoinSelection/selectors.ts
@@ -1,6 +1,6 @@
 import { uniq } from 'ramda'
 
-import { CoinType } from '@core/types'
+import { CoinType, WalletAccountSuperAppEnum } from '@core/types'
 import { selectors } from 'data'
 import { SWAP_ACCOUNTS_SELECTOR } from 'data/coins/model/swap'
 import { getCoinAccounts } from 'data/coins/selectors'
@@ -14,7 +14,7 @@ import { RootState } from 'data/rootReducer'
 
 import { OwnProps } from '.'
 
-export const getData = (state: RootState, { side }: OwnProps) => {
+export const getData = (state: RootState, { fromType, side }: OwnProps) => {
   const coins = selectors.components.swap.getCoins()
   const accounts = getCoinAccounts(state, { coins, ...SWAP_ACCOUNTS_SELECTOR })
   const pairs = selectors.components.swap.getPairs(state).getOrElse([])
@@ -60,6 +60,20 @@ export const getData = (state: RootState, { side }: OwnProps) => {
     return !(account.type === SwapBaseCounterTypes.CUSTODIAL && !custodialEligibility)
   }
 
+  // TODO temp placeholder name
+  const _checkFromTypeSuperApp = (account: SwapAccountType) => {
+    if (side === 'BASE') {
+      if (fromType === WalletAccountSuperAppEnum.DEFI) {
+        return account.type === SwapBaseCounterTypes.ACCOUNT
+      }
+      if (fromType === WalletAccountSuperAppEnum.ACCOUNT) {
+        return account.type === SwapBaseCounterTypes.CUSTODIAL
+      }
+    } else {
+      return true
+    }
+  }
+
   const sideF = side === 'BASE' ? getInputFromPair : getOutputFromPair
   let coinsForSide = uniq(pairs.map(sideF))
 
@@ -92,9 +106,19 @@ export const getData = (state: RootState, { side }: OwnProps) => {
     const hideCustodialToAccount = _checkBaseCustodial(account)
     const isBaseAccountZero = _checkBaseAccountZero(account)
     const isCustodialEligible = _checkCustodialEligibility(account)
-
-    return !isBaseAccountZero && !isCoinSelected && !hideCustodialToAccount && isCustodialEligible
+    const showDefiOrAccount = _checkFromTypeSuperApp(account)
+
+    return (
+      !isBaseAccountZero &&
+      !isCoinSelected &&
+      !hideCustodialToAccount &&
+      isCustodialEligible &&
+      showDefiOrAccount
+    )
   })
 
-  return { accounts: accountsForSide, filteredAccounts }
+  return {
+    accounts: accountsForSide,
+    filteredAccounts
+  }
 }
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/EnterAmount/Checkout/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/EnterAmount/Checkout/index.tsx
index 8b78f8c857a..9aa38bcfc01 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Swap/EnterAmount/Checkout/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Swap/EnterAmount/Checkout/index.tsx
@@ -454,7 +454,7 @@ const Checkout: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
             jumbo
             fullwidth
             style={{ marginTop: '24px' }}
-            disabled={props.invalid || isQuoteFailed || disableInsufficientEth}
+            disabled={props.invalid || isQuoteFailed}
           >
             <FormattedMessage id='buttons.preview_swap' defaultMessage='Preview Swap' />
           </Button>
@@ -615,17 +615,6 @@ const Checkout: React.FC<InjectedFormProps<{}, Props> & Props> = (props) => {
             })}
           </ErrorCartridge>
         )}
-        {disableInsufficientEth && (
-          <ErrorCartridge style={{ marginTop: '16px' }}>
-            <FormattedMessage
-              id='copy.not_enough_eth1'
-              defaultMessage='ETH is required to send {coin}. You do not have enough ETH in your Ether Wallet to perform a transaction. Note, ETH must be held in your Ether Wallet for this transaction, not Ether Trading Account.'
-              values={{
-                coin: baseCoinfig.displaySymbol
-              }}
-            />
-          </ErrorCartridge>
-        )}
       </StyledForm>
     </FlyoutWrapper>
   )
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/index.tsx b/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/index.tsx
index 326cdbe95b5..040008ea55f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/index.tsx
@@ -106,7 +106,12 @@ const mapDispatchToProps = (dispatch: Dispatch, { coin }: OwnProps) => {
   const { erc20Address, parentChain = coin } = window.coins[coin].coinfig.type
   const coinCode = parentChain.toLowerCase()
   return {
-    clearTransactions: () => dispatch(actions.core.data[coinCode].clearTransactionHistory()),
+    clearTransactions: () => {
+      if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
+        return dispatch(actions.core.data.coins.clearTransactionHistory({ coin }))
+      }
+      return dispatch(actions.core.data[coinCode].clearTransactionHistory())
+    },
     fetchTransactions: (address, startDate, endDate) => {
       if (erc20Address) {
         return dispatch(
@@ -114,6 +119,10 @@ const mapDispatchToProps = (dispatch: Dispatch, { coin }: OwnProps) => {
         )
       }
 
+      if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
+        return dispatch(actions.core.data.coins.fetchTransactionHistory({ coin }))
+      }
+
       return dispatch(
         actions.core.data[coinCode].fetchTransactionHistory(address, startDate, endDate)
       )
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/selectors.ts
index 5e6823bd520..021a980bd03 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Transactions/DownloadTransactions/selectors.ts
@@ -33,6 +33,7 @@ const getErc20Data = createSelector(
       return [reportHeaders].concat(transformedData)
     }
     return {
+      // @ts-ignore
       csvData: dataR.map(transform).getOrElse([])
     }
   }
@@ -40,6 +41,7 @@ const getErc20Data = createSelector(
 
 const getEthData = createSelector(
   [selectors.core.data.eth.getTransactionHistory],
+  // @ts-ignore
   (dataR: selectors.core.data.eth.getTransactionHistory) => {
     const transform = (data) => {
       const transformedData = map((tx) => formatTxData(tx, 'ETH'), data)
@@ -105,6 +107,18 @@ const getXlmData = createSelector([selectors.core.data.xlm.getTransactionHistory
   }
 })
 
+const getSelfCustodyData = createSelector(
+  [(state, coin) => selectors.core.data.coins.getTransactionHistory(coin, state)],
+  (dataR) => {
+    const transform = (data) => {
+      return data
+    }
+    return {
+      csvData: dataR.map(transform).getOrElse([])
+    }
+  }
+)
+
 export const getData = (state, coin) => {
   switch (coin) {
     case 'BTC':
@@ -116,6 +130,9 @@ export const getData = (state, coin) => {
     case 'XLM':
       return getXlmData(state)
     default:
+      if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
+        return getSelfCustodyData(state, coin)
+      }
       return getErc20Data(state, coin)
   }
 }
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/FirstStep/selectors.js b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/FirstStep/selectors.js
index 1fed8a06daf..0f3b2d59bc6 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/FirstStep/selectors.js
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/FirstStep/selectors.js
@@ -9,7 +9,7 @@ const getData = createDeepEqualSelector(
     selectors.components.sendXlm.getPayment,
     selectors.components.sendXlm.getCheckDestination,
     selectors.components.sendXlm.getIsDestinationExchange,
-    selectors.core.data.xlm.getTotalBalance,
+    selectors.core.data.coins.getCoinUnifiedBalance('XLM'),
     selectors.core.settings.getCurrency,
     selectors.core.wallet.isMnemonicVerified,
     selectors.form.getFormValues(model.components.sendXlm.FORM),
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/SecondStep/index.js b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/SecondStep/index.js
index 1c8e1404efc..ae15a7c9797 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/SecondStep/index.js
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/SecondStep/index.js
@@ -17,7 +17,7 @@ class SecondStepContainer extends React.PureComponent {
   render() {
     const { actions, data } = this.props
     return data.cata({
-      Failure: (message) => <Error>{message}</Error>,
+      Failure: (message) => <Error>{JSON.stringify(message)}</Error>,
       Loading: () => <Loading />,
       NotAsked: () => <Loading />,
       Success: (value) => (
diff --git a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/index.js b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/index.js
index 5ac4f8420e5..a3cdcac2d6f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/index.js
+++ b/packages/blockchain-wallet-v4-frontend/src/modals/Xlm/SendXlm/index.js
@@ -44,7 +44,7 @@ const mapStateToProps = (state) => ({
 
 const mapDispatchToProps = (dispatch) => ({
   actions: bindActionCreators(actions.components.sendXlm, dispatch),
-  fetchData: bindActionCreators(actions.core.data.xlm.fetchData, dispatch)
+  fetchData: () => {}
 })
 
 const enhance = compose(
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/ChartBalancePanel/ChartBalancePanel.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/ChartBalancePanel/ChartBalancePanel.tsx
index 996d818c52f..fd3c5872fe9 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/ChartBalancePanel/ChartBalancePanel.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/ChartBalancePanel/ChartBalancePanel.tsx
@@ -42,7 +42,7 @@ export const ChartBalancePanel: ChartBalancePanelComponent = ({
           id='chart-view.chart-balance-panel.price'
           defaultMessage='{coinCode} Price'
           values={{
-            coinCode
+            coinCode: window.coins[coinCode].coinfig.displaySymbol
           }}
         />
       </Text>
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.stories.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.stories.tsx
index f5d964e922d..323b60b32bf 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.stories.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.stories.tsx
@@ -13,15 +13,13 @@ const Template: ComponentStory<CoinHeaderComponent> = (args) => <CoinHeader {...
 export const Bitcoin = Template.bind({})
 Bitcoin.args = {
   coinCode: 'BTC',
-  coinDescription: 'The internet’s first and largest crypto currency.',
-  coinName: 'Bitcoin'
+  coinDescription: 'The internet’s first and largest crypto currency.'
 }
 
 export const Ethereum = Template.bind({})
 Ethereum.args = {
   coinCode: 'ETH',
-  coinDescription: 'The internet’s first and largest crypto currency.',
-  coinName: 'Ethereum'
+  coinDescription: 'The internet’s first and largest crypto currency.'
 }
 
 export default coinHeaderStory
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.tsx
index 3c479c61ccd..c2507083a46 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/CoinHeader.tsx
@@ -5,7 +5,7 @@ import { Icon, Text } from 'blockchain-info-components'
 import { Flex } from '../../../../components/Flex'
 import { CoinHeaderComponent } from './types'
 
-export const CoinHeader: CoinHeaderComponent = ({ coinCode, coinDescription, coinName }) => {
+export const CoinHeader: CoinHeaderComponent = ({ coinCode, coinDescription, coinfig }) => {
   return (
     <Flex gap={16}>
       <Icon name={coinCode} size='48' />
@@ -13,11 +13,11 @@ export const CoinHeader: CoinHeaderComponent = ({ coinCode, coinDescription, coi
       <Flex flexDirection='column' gap={4} justifyContent='center'>
         <Flex gap={4}>
           <Text color='grey900' weight={600} size='20px'>
-            {coinName}
+            {coinfig?.name}
           </Text>
 
           <Text color='grey600' weight={600} size='20px'>
-            {coinCode}
+            {coinfig?.displaySymbol}
           </Text>
         </Flex>
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/types.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/types.ts
index 53b1be5a497..214a6f2e2e1 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinHeader/types.ts
@@ -1,9 +1,11 @@
 import { FC } from 'react'
 
+import { CoinfigType } from '@core/types'
+
 export type CoinHeaderProps = {
   coinCode: string
   coinDescription?: string
-  coinName: string
+  coinfig?: CoinfigType
 }
 
 export type CoinHeaderComponent = FC<CoinHeaderProps>
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/CoinPage.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/CoinPage.tsx
index 60c88d1d9bd..d3caa6dc36d 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/CoinPage.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/CoinPage.tsx
@@ -41,7 +41,11 @@ export const CoinPage: CoinPageComponent = ({
           {activity}
         </Flex>
 
-        <Flex flexDirection='column' gap={24}>
+        <Flex
+          flexDirection='column'
+          gap={24}
+          style={{ height: 'fit-content', position: 'sticky', top: '30px' }}
+        >
           {alertCard} {holdings} {wallets} {recurringBuys} {promoCard}
         </Flex>
       </Grid>
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useActivityFeed/useActivityFeed.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useActivityFeed/useActivityFeed.tsx
index b5764e43019..e8f45eed829 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useActivityFeed/useActivityFeed.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useActivityFeed/useActivityFeed.tsx
@@ -123,7 +123,7 @@ const useActivityFeed: ActivityFeedHook = ({ coin }) => {
             />
           </Button>
 
-          {!isLoadingAddressData && (
+          {!isLoadingAddressData && filterOptions.length > 1 && (
             <AccountSelectBox
               label={
                 <FormattedMessage
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useHoldingsCard/useHoldingsCard.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useHoldingsCard/useHoldingsCard.tsx
index e0964f09982..45eb1ef3813 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useHoldingsCard/useHoldingsCard.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/hooks/useHoldingsCard/useHoldingsCard.tsx
@@ -101,6 +101,7 @@ export const useHoldingsCard: HoldingsCardHook = ({ coin }) => {
     if (isLoading)
       return (
         <HoldingsCard
+          coinfig={coinfig}
           total={<TotalLoadingText />}
           coinCode={coin}
           coinTotal={<CoinTotalLoadingText />}
@@ -109,6 +110,7 @@ export const useHoldingsCard: HoldingsCardHook = ({ coin }) => {
     if (!rates || !coinBalance) {
       return (
         <HoldingsCard
+          coinfig={coinfig}
           total={formatFiat(0)}
           coinCode={coin}
           coinTotal={formatCoin(0)}
@@ -130,6 +132,7 @@ export const useHoldingsCard: HoldingsCardHook = ({ coin }) => {
 
     return (
       <HoldingsCard
+        coinfig={coinfig}
         total={totalFiatFormatted ?? ''}
         coinCode={coin}
         coinTotal={coinTotalAmount}
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/index.tsx
index 3ffecb591a4..608e8331247 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/CoinPage/index.tsx
@@ -49,7 +49,7 @@ const CoinPageContainer: FC<RouteComponentProps> = ({ computedMatch }) => {
       chartTabs={tabsNode}
       about={acoutSection}
       chart={chart}
-      header={<CoinHeader coinCode={coin} coinDescription='' coinName={coinfig?.name ?? ''} />}
+      header={<CoinHeader coinfig={coinfig} coinCode={coin} coinDescription='' />}
       chartBalancePanel={chartBalancePanel}
       recurringBuys={recurringBuyPanel}
       holdings={holdingsCard}
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/HoldingsCard.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/HoldingsCard.tsx
index 5eab86226b8..30a3a38c0b3 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/HoldingsCard.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/HoldingsCard.tsx
@@ -8,7 +8,13 @@ import { Padding } from 'components/Padding'
 
 import { HoldingsCardComponent } from './types'
 
-export const HoldingsCard: HoldingsCardComponent = ({ actions, coinCode, coinTotal, total }) => {
+export const HoldingsCard: HoldingsCardComponent = ({
+  actions,
+  coinCode,
+  coinTotal,
+  coinfig,
+  total
+}) => {
   return (
     <Card borderWidth={1} borderRadius='md'>
       <Padding all={16}>
@@ -18,7 +24,7 @@ export const HoldingsCard: HoldingsCardComponent = ({ actions, coinCode, coinTot
               id='scenes.coin.holdings_card.total'
               defaultMessage='Your Total {coinCode}'
               values={{
-                coinCode
+                coinCode: coinfig?.displaySymbol || coinCode
               }}
             />
           </Text>
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/types.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/types.ts
index 36df4b09022..bb0172328af 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/HoldingsCard/types.ts
@@ -1,9 +1,12 @@
 import { FC, ReactElement, ReactNode } from 'react'
 
+import { CoinfigType } from '@core/types'
+
 export type HoldingsCardProps = {
   actions?: ReactElement[]
   coinCode: ReactNode
   coinTotal: ReactNode
+  coinfig?: CoinfigType
   total: ReactNode
 }
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/TransactionListItem.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/TransactionListItem.tsx
index dc523d99e72..8867a04e431 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/TransactionListItem.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/TransactionListItem.tsx
@@ -1,6 +1,6 @@
 import React from 'react'
+import UnifiedActivityTx from 'blockchain-wallet-v4-frontend/src/scenes/Transactions/UnifiedActivityTx'
 
-import { Remote } from '@core'
 import { FiatBSAndSwapTransactionType } from '@core/types'
 import { useCoinConfig, useCurrency } from 'hooks'
 
@@ -33,7 +33,9 @@ const TransactionListItem: TransactionListItemComponent = ({ coin, transaction }
   ) : 'pair' in transaction ? (
     <BuySellListItem key={transaction.id} order={transaction} />
   ) : 'movements' in transaction ? (
-    <SelfCustodyTx key={transaction.txId} tx={transaction} />
+    <SelfCustodyTx coin={coin} key={transaction.txId} tx={transaction} />
+  ) : 'detail' in transaction ? (
+    <UnifiedActivityTx tx={transaction} coin={coin} />
   ) : (
     <CustodialTxListItem
       key={transaction.id}
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/utils/isIngestedSelfCustodyType/isIngestedSelfCustodyType.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/utils/isIngestedSelfCustodyType/isIngestedSelfCustodyType.ts
index ac13044a468..8cf08074da9 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/utils/isIngestedSelfCustodyType/isIngestedSelfCustodyType.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/CoinPage/components/TransactionListItem/utils/isIngestedSelfCustodyType/isIngestedSelfCustodyType.ts
@@ -1,4 +1,4 @@
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import { TransactionItem } from 'hooks'
 
 const isIngestedSelfCustodyType = (
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Banners/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Banners/index.tsx
index f9886b20b0f..ae63134dbfc 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Banners/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Banners/index.tsx
@@ -28,7 +28,7 @@ const BannerWrapper = styled.div`
 `
 
 const Banners = (props: Props) => {
-  const { buySellActions, interestActions } = props
+  const { buySellActions, fetchUnifiedActivityWS, interestActions } = props
   const { data, error, isLoading, isNotAsked } = useRemote(getData)
 
   useEffect(() => {
@@ -148,6 +148,7 @@ const Banners = (props: Props) => {
 
 const mapDispatchToProps = (dispatch: Dispatch) => ({
   buySellActions: bindActionCreators(actions.components.buySell, dispatch),
+  fetchUnifiedActivityWS: bindActionCreators(actions.activities, dispatch),
   interestActions: bindActionCreators(actions.components.interest, dispatch)
 })
 
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/CoinBalance/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/CoinBalance/index.tsx
index ab24110ef4f..9d63782ff68 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/CoinBalance/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/CoinBalance/index.tsx
@@ -1,37 +1,22 @@
 import React from 'react'
 import { connect, ConnectedProps } from 'react-redux'
-import { toLower } from 'ramda'
 import { bindActionCreators } from 'redux'
 
 import { SkeletonRectangle } from 'blockchain-info-components'
-import { actions, selectors } from 'data'
+import { actions } from 'data'
 
 import { getData } from './selectors'
 import Error from './template.error'
 import Success from './template.success'
 
 class CoinBalance extends React.PureComponent<Props> {
-  handleRefresh = (e?: KeyboardEvent) => {
-    if (e) {
-      e.preventDefault()
-    }
-    const { coin } = this.props
-    const { coinfig } = window.coins[coin]
-    if (selectors.core.data.coins.getDynamicSelfCustodyCoins().includes(coin)) {
-      this.props.coinActions.fetchData('', [coin])
-    } else if (coinfig.type.erc20Address) {
-      this.props.ethActions.fetchErc20Data(coin)
-    } else {
-      const coinLower = toLower(coin)
-      this.props[`${coinLower}Actions`].fetchData()
-    }
-  }
-
   render() {
     const { coin, data } = this.props
 
     return data.cata({
-      Failure: () => <Error coin={coin} onRefresh={(e) => this.handleRefresh(e)} />,
+      Failure: () => (
+        <Error coin={coin} onRefresh={() => this.props.coinsActions.fetchUnifiedBalances()} />
+      ),
       Loading: () => <SkeletonRectangle height='35px' width='60px' />,
       NotAsked: () => <SkeletonRectangle height='35px' width='60px' />,
       Success: (value) => <Success balance={value} coin={coin} />
@@ -44,12 +29,7 @@ const mapStateToProps = (state, ownProps: OwnProps) => ({
 })
 
 const mapDispatchToProps = (dispatch) => ({
-  bchActions: bindActionCreators(actions.core.data.bch, dispatch),
-  btcActions: bindActionCreators(actions.core.data.btc, dispatch),
-  coinActions: bindActionCreators(actions.core.data.coins, dispatch),
-  ethActions: bindActionCreators(actions.core.data.eth, dispatch),
-  stxActions: bindActionCreators(actions.core.data.stx, dispatch),
-  xlmActions: bindActionCreators(actions.core.data.xlm, dispatch)
+  coinsActions: bindActionCreators(actions.core.data.coins, dispatch)
 })
 
 const connector = connect(mapStateToProps, mapDispatchToProps)
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/index.tsx
index 83811de20d3..3b3d43f933a 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Home/Holdings/index.tsx
@@ -2,11 +2,13 @@ import React from 'react'
 import { FormattedMessage } from 'react-intl'
 import { connect, ConnectedProps } from 'react-redux'
 import { LinkContainer } from 'react-router-bootstrap'
+import { IconRefresh } from '@blockchain-com/icons'
 import { bindActionCreators } from 'redux'
 import styled from 'styled-components'
 
 import { ExtractSuccess } from '@core/remote/types'
-import { Icon, Link, Text } from 'blockchain-info-components'
+import { Icon, Link, SkeletonCircle, SkeletonRectangle, Text } from 'blockchain-info-components'
+import { Flex } from 'components/Flex'
 import { StandardRow } from 'components/Rows'
 import { actions, selectors } from 'data'
 import { media } from 'services/styles'
@@ -65,10 +67,31 @@ const HoldingsTableContainer = (props: Props) => (
       </LinkContainer>
     </TitleWrapper>
     {props.data.cata({
-      Failure: (e) => (
-        <Text size='16px' weight={500} color='grey400' capitalize>
-          {e?.toString() || 'Failed to load balances'}
-        </Text>
+      Failure: () => (
+        <>
+          <Flex alignItems='flex-end'>
+            <Text size='14px' weight={500} color='red600' capitalize>
+              <FormattedMessage
+                id='copy.failed_to_load_balances'
+                defaultMessage='Failed to load balances.'
+              />
+            </Text>{' '}
+            <Text
+              style={{ alignItems: 'center', display: 'flex', gap: '2px' }}
+              onClick={() => props.actions.refreshClicked()}
+              cursor='pointer'
+              color='blue600'
+              size='14px'
+              weight={600}
+              // @ts-ignore
+              role='button'
+            >
+              <FormattedMessage id='copy.try_again' defaultMessage='Try Again' />
+              <IconRefresh />
+            </Text>
+          </Flex>
+          <Loading />
+        </>
       ),
       Loading: () => <Loading />,
       NotAsked: () => <Loading />,
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Settings/Addresses/Xlm/selectors.js b/packages/blockchain-wallet-v4-frontend/src/scenes/Settings/Addresses/Xlm/selectors.js
index 652066a5da9..ebb1453c905 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Settings/Addresses/Xlm/selectors.js
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Settings/Addresses/Xlm/selectors.js
@@ -3,7 +3,7 @@ import { selectors } from 'data'
 
 export const getData = (state, props) => {
   const accountId = selectors.core.kvStore.xlm.getDefaultAccountId(state).getOrElse('')
-  const amount = selectors.core.data.xlm.getAccountBalance(accountId, state).getOrElse(0)
+  const amount = selectors.core.data.coins.getCoinUnifiedBalance('XLM')(state).getOrElse(0)
 
   return {
     addressInfo: {
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/index.tsx
new file mode 100644
index 00000000000..a5a9b8c1b7e
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/index.tsx
@@ -0,0 +1,30 @@
+import React from 'react'
+import { connect, ConnectedProps } from 'react-redux'
+import BigNumber from 'bignumber.js'
+
+import { CoinType } from '@core/types'
+import { selectors } from 'data'
+
+import CustodialTestBalances from './template'
+
+const AccountTestBalances: React.FC<Props> = (props: Props) => {
+  return <CustodialTestBalances />
+  //   return props.data.cata({
+  //     Failure: () => <>Failure</>,
+  //     Loading: () => <>Loading</>,
+  //     NotAsked: () => <>Not Asked</>,
+  //     Success: (val) => <>val</>
+  //   })
+}
+
+const mapStateToProps = (state) => ({})
+
+const connector = connect(mapStateToProps)
+
+export type OwnProps = {
+  coin: CoinType
+}
+
+type Props = ConnectedProps<typeof connector> & OwnProps
+
+export default connector(AccountTestBalances)
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/template.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/template.tsx
new file mode 100644
index 00000000000..96c2d172e85
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/TestAccountBalances/template.tsx
@@ -0,0 +1,32 @@
+import React from 'react'
+import { FormattedMessage } from 'react-intl'
+import { useDispatch } from 'react-redux'
+import { Button } from '@blockchain-com/constellation'
+import styled from 'styled-components'
+
+import { WalletAccountSuperAppEnum } from '@core/types'
+import { actions, selectors } from 'data'
+
+const CustodialTestBalances = (props) => {
+  //   console.log(props, 'ncTestBalanceProps')
+  const dispatch = useDispatch()
+
+  return (
+    <>
+      <Button
+        onClick={() =>
+          dispatch(
+            actions.components.swap.showModal({
+              fromType: WalletAccountSuperAppEnum.ACCOUNT,
+              origin: 'Trade'
+            })
+          )
+        }
+        variant='primary'
+        text={<FormattedMessage id='copy.swap' defaultMessage='Swap' />}
+      />
+    </>
+  )
+}
+
+export default CustodialTestBalances
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/index.tsx
new file mode 100644
index 00000000000..9879a4d8c03
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/index.tsx
@@ -0,0 +1,32 @@
+import React from 'react'
+import { connect, ConnectedProps } from 'react-redux'
+import BigNumber from 'bignumber.js'
+
+import { CoinType } from '@core/types'
+import { selectors } from 'data'
+
+import { getData } from './selectors'
+import NonCustodialTestBalances from './template'
+
+const NCTestBalances: React.FC<Props> = (props: Props) => {
+  return props.data.cata({
+    Failure: () => <>Failure</>,
+    Loading: () => <>Loading</>,
+    NotAsked: () => <>Not Asked</>,
+    Success: (val) => <NonCustodialTestBalances />
+  })
+}
+
+const mapStateToProps = (state) => ({
+  data: getData(state)
+})
+
+const connector = connect(mapStateToProps)
+
+export type OwnProps = {
+  coin: CoinType
+}
+
+type Props = ConnectedProps<typeof connector> & OwnProps
+
+export default connector(NCTestBalances)
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/selectors.ts
new file mode 100644
index 00000000000..5a41b8c8170
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/selectors.ts
@@ -0,0 +1,27 @@
+import BigNumber from 'bignumber.js'
+import { lift, mapObjIndexed, uniq, values } from 'ramda'
+
+import { ExtractSuccess } from '@core/types'
+import { selectors } from 'data'
+
+export const getData = (state) => {
+  const unifiedBalancesR = selectors.core.data.coins.getUnifiedBalances(state)
+
+  const transform = (unifiedBalances: ExtractSuccess<typeof unifiedBalancesR>) => {
+    const coinsInUnifiedBalances = uniq(unifiedBalances.map(({ ticker }) => ticker))
+    const balancesArray = []
+    coinsInUnifiedBalances.forEach((coin) => {
+      const eachCoinBalance = selectors.balances
+        .getCoinNonCustodialBalance(coin)(state)
+        .getOrElse(0)
+      const individualCoinBalance = { balance: new BigNumber(eachCoinBalance).toNumber(), coin }
+
+      // @ts-ignore
+      balancesArray.push(individualCoinBalance)
+
+      return balancesArray
+    })
+    // console.log(balancesArray, 'balances array')
+  }
+  return lift(transform)(unifiedBalancesR)
+}
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/template.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/template.tsx
new file mode 100644
index 00000000000..cbfe0ec8196
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/TestDefiBalances/template.tsx
@@ -0,0 +1,32 @@
+import React from 'react'
+import { FormattedMessage } from 'react-intl'
+import { useDispatch } from 'react-redux'
+import { Button } from '@blockchain-com/constellation'
+import styled from 'styled-components'
+
+import { WalletAccountSuperAppEnum } from '@core/types'
+import { actions, selectors } from 'data'
+
+const NonCustodialTestBalances = (props) => {
+  //   console.log(props, 'ncTestBalanceProps')
+  const dispatch = useDispatch()
+
+  return (
+    <>
+      <Button
+        onClick={() =>
+          dispatch(
+            actions.components.swap.showModal({
+              fromType: WalletAccountSuperAppEnum.DEFI,
+              origin: 'Trade'
+            })
+          )
+        }
+        variant='primary'
+        text={<FormattedMessage id='copy.swap' defaultMessage='Swap' />}
+      />
+    </>
+  )
+}
+
+export default NonCustodialTestBalances
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/NonCustodialTx/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/NonCustodialTx/selectors.ts
index 89319fb407f..d233b0bf280 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/NonCustodialTx/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/NonCustodialTx/selectors.ts
@@ -3,11 +3,11 @@ import { toLower } from 'ramda'
 import { selectors } from 'data'
 
 export const getBlockHeight = (state, coin) => {
-  const { coinfig } = window.coins[coin]
   if (selectors.core.data.coins.getCustodialCoins().includes(coin)) {
     return null
   }
   if (selectors.core.data.coins.getErc20Coins().includes(coin)) {
+    // @ts-ignore
     return selectors.core.data.eth.getHeight(state).getOrElse(0)
   }
   return selectors.core.data[toLower(coin)].getHeight(state).getOrElse(0)
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/SelfCustodyTxModel.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/SelfCustodyTxModel.tsx
index d4560535c4f..e0d44551536 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/SelfCustodyTxModel.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/SelfCustodyTxModel.tsx
@@ -1,7 +1,7 @@
 import React from 'react'
 import { FormattedMessage } from 'react-intl'
 
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { IngestedSelfCustodyType } from '@core/network/api/coins/types'
 
 export const TransactionType = ({
   txType
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/index.tsx
index 8bfcf17a85c..196d0ad6b27 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/SelfCustodyTx/index.tsx
@@ -1,7 +1,7 @@
 import React from 'react'
 import { FormattedMessage } from 'react-intl'
 
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import { Text } from 'blockchain-info-components'
 import { GreyCartridge } from 'components/Cartridge'
 
@@ -19,9 +19,8 @@ import {
 } from '../components'
 import { TransactionType } from './SelfCustodyTxModel'
 
-const SelfCustodyTx: React.FC<Props> = ({ tx }) => {
-  // TODO: SELF_CUSTODY
-  const coin = 'STX'
+const SelfCustodyTx: React.FC<Props> = ({ coin, tx }) => {
+  const { coinfig } = window.coins[coin]
 
   return (
     // TODO: SELF_CUSTODY
@@ -33,7 +32,7 @@ const SelfCustodyTx: React.FC<Props> = ({ tx }) => {
           <IconTx type={tx.type} coin={tx.type === 'RECEIVED' ? 'green400' : 'red500'} />
           <StatusAndType data-e2e='txStatusColumn'>
             <Text size='16px' color='grey800' weight={600} data-e2e='txTypeText'>
-              <TransactionType txType={tx.type} /> {coin}
+              <TransactionType txType={tx.type} /> {coinfig.displaySymbol}
             </Text>
             {tx.timestamp ? (
               <Timestamp time={tx.timestamp * 1000} />
@@ -46,8 +45,10 @@ const SelfCustodyTx: React.FC<Props> = ({ tx }) => {
         </Row>
         <Col width='50%'>
           <Addresses
-            from={tx.type === 'SENT' ? <>{coin} Private Key Wallet</> : <>{tx.from}</>}
-            to={tx.type === 'SENT' ? <>{tx.to}</> : <>{coin} Private Key Wallet</>}
+            from={
+              tx.type === 'SENT' ? <>{coinfig.displaySymbol} Private Key Wallet</> : <>{tx.from}</>
+            }
+            to={tx.type === 'SENT' ? <>{tx.to}</> : <>{coinfig.displaySymbol} Private Key Wallet</>}
           />
         </Col>
         <Col width='20%' style={{ textAlign: 'right' }} data-e2e='orderAmountColumn'>
@@ -69,6 +70,6 @@ const SelfCustodyTx: React.FC<Props> = ({ tx }) => {
   )
 }
 
-type Props = { tx: IngestedSelfCustodyType }
+type Props = { coin: string; tx: IngestedSelfCustodyType }
 
 export default SelfCustodyTx
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/TransactionList/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/TransactionList/index.tsx
index 913790d5ef4..1fd41b21e9f 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/TransactionList/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/TransactionList/index.tsx
@@ -1,7 +1,7 @@
 import React, { PureComponent } from 'react'
 import styled from 'styled-components'
 
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { ActivityResponseType, IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import {
   BSOrderType,
   BSTransactionType,
@@ -19,6 +19,7 @@ import CustodialTxListItem from '../CustodialTx'
 import NonCustodialTxListItem from '../NonCustodialTx'
 import SelfCustodyTx from '../SelfCustodyTx'
 import SwapOrderTx from '../SwapOrderTx'
+import UnifiedActivityTx from '../UnifiedActivityTx'
 import Loading from './template.loading'
 
 // width: 99%; to prevent scrolling weirdness
@@ -65,7 +66,9 @@ class TransactionList extends PureComponent<Props> {
             ) : 'pair' in tx ? (
               <BuySellListItem key={tx.id} order={tx} />
             ) : 'movements' in tx ? (
-              <SelfCustodyTx key={tx.txId} tx={tx} />
+              <SelfCustodyTx coin={coin} key={tx.txId} tx={tx} />
+            ) : 'detail' in tx ? (
+              <UnifiedActivityTx tx={tx} coin={coin} />
             ) : (
               <CustodialTxListItem
                 key={tx.id}
@@ -93,7 +96,11 @@ export type Props = {
 }
 
 export type SuccessStateType = Array<
-  BSOrderType | BSTransactionType | ProcessedTxType | IngestedSelfCustodyType
+  | BSOrderType
+  | BSTransactionType
+  | ProcessedTxType
+  | IngestedSelfCustodyType
+  | ActivityResponseType['activity'][0]
 >
 
 export default TransactionList
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/UnifiedActivityTx/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/UnifiedActivityTx/index.tsx
new file mode 100644
index 00000000000..5de3c0fc09f
--- /dev/null
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/UnifiedActivityTx/index.tsx
@@ -0,0 +1,78 @@
+import React, { useState } from 'react'
+
+import { ActivityResponseType } from '@core/network/api/coins/types'
+import { Text } from 'blockchain-info-components'
+
+import { Addresses, Col, Row, StatusAndType, Timestamp, TxRow, TxRowContainer } from '../components'
+
+const UnifiedActivityTx: React.FC<Props> = ({ coin, tx }) => {
+  const [isToggled, setIsToggled] = useState(false)
+
+  return (
+    <TxRowContainer
+      className={isToggled ? 'active' : ''}
+      onClick={() => window.open(`${tx.externalUrl}`, '_blank')}
+    >
+      <TxRow>
+        <Row width='30%'>
+          {/* <img alt='tx-type' src={tx.item.iconUrl} /> */}
+          <StatusAndType data-e2e='txStatusColumn'>
+            <Text size='16px' color='grey800' weight={600} data-e2e='txTypeText'>
+              {tx.item.startTitle}
+            </Text>
+            <Timestamp time={tx.timestamp * 1000} />
+          </StatusAndType>
+        </Row>
+        <Col width='50%'>
+          {tx.detail.itemGroups.find(({ itemGroup }) =>
+            itemGroup.find(({ key }) => key === 'From')
+          ) ? (
+            <Addresses
+              from={tx.detail.itemGroups.map(({ itemGroup }) => {
+                return itemGroup
+                  .filter(({ key }) => key === 'From')
+                  .map((from) => {
+                    return <>{from.value}</>
+                  })
+              })}
+              to={tx.detail.itemGroups.map(({ itemGroup }) => {
+                return itemGroup
+                  .filter(({ key }) => key === 'To')
+                  .map((to) => {
+                    return <>{to.value}</>
+                  })
+              })}
+            />
+          ) : null}
+        </Col>
+        {/* <Col /> */}
+        <Col width='20%' style={{ textAlign: 'right' }} data-e2e='orderAmountColumn'>
+          <Text
+            color='grey800'
+            style={{ display: 'flex', justifyContent: 'flex-end' }}
+            size='16px'
+            weight={600}
+          >
+            {tx.item.endTitle ||
+              tx.detail.itemGroups.find(
+                ({ itemGroup }) => itemGroup.find(({ key }) => key === 'Network fee')?.key
+              )}
+          </Text>
+          <Text size='14px' weight={500} color='grey600' data-e2e='orderFiatAmt'>
+            {tx.item.endSubtitle ||
+              tx.detail.itemGroups.find(
+                ({ itemGroup }) => itemGroup.find(({ key }) => key === 'Network fee')?.value
+              )}
+          </Text>
+        </Col>
+      </TxRow>
+    </TxRowContainer>
+  )
+}
+
+type Props = {
+  coin: string
+  tx: ActivityResponseType['activity'][0]
+}
+
+export default UnifiedActivityTx
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/index.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/index.tsx
index 2f6c214797f..6d0c4393394 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/index.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/index.tsx
@@ -365,7 +365,7 @@ const mapDispatchToProps = (dispatch: Dispatch, ownProps: OwnProps) => {
   if (selectors.core.data.coins.getErc20Coins().includes(coin)) {
     return {
       ...baseActions,
-      fetchData: () => dispatch(actions.core.data.eth.fetchErc20Data(coin)),
+      fetchData: () => dispatch(actions.core.data.coins.fetchUnifiedBalances()),
       initTxs: () => dispatch(actions.components.ethTransactions.initializedErc20(coin)),
       loadMoreTxs: () => dispatch(actions.components.ethTransactions.loadMoreErc20(coin))
     }
@@ -394,7 +394,7 @@ const mapDispatchToProps = (dispatch: Dispatch, ownProps: OwnProps) => {
   }
   return {
     ...baseActions,
-    fetchData: () => dispatch(actions.core.data[toLower(coin)].fetchData()),
+    fetchData: () => dispatch(actions.core.data.coins.fetchUnifiedBalances()),
     initTxs: () => dispatch(actions.components[`${toLower(coin)}Transactions`].initialized()),
     loadMoreTxs: () => dispatch(actions.components[`${toLower(coin)}Transactions`].loadMore()),
     setAddressArchived: (address) => dispatch(actions.core.wallet.setAddressArchived(address, true))
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/selectors.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/selectors.ts
index f6a388b96af..6ced5f59d1c 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/selectors.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/selectors.ts
@@ -17,7 +17,7 @@ import {
 } from 'ramda'
 import { createSelector } from 'reselect'
 
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import {
   AddressTypesType,
   BSOrderType,
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/types.ts b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/types.ts
index 520dcd7137a..008c6f7db58 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/types.ts
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/Transactions/types.ts
@@ -1,4 +1,4 @@
-import { IngestedSelfCustodyType } from '@core/network/api/coin/types'
+import { IngestedSelfCustodyType } from '@core/network/api/coins/types'
 import {
   BSOrderType,
   BSTransactionType,
diff --git a/packages/blockchain-wallet-v4-frontend/src/scenes/app.tsx b/packages/blockchain-wallet-v4-frontend/src/scenes/app.tsx
index 9665be8293d..454151602de 100644
--- a/packages/blockchain-wallet-v4-frontend/src/scenes/app.tsx
+++ b/packages/blockchain-wallet-v4-frontend/src/scenes/app.tsx
@@ -79,6 +79,10 @@ const TheExchange = React.lazy(() => import('./TheExchange'))
 const Transactions = React.lazy(() => import('./Transactions'))
 const DebitCard = React.lazy(() => import('./DebitCard'))
 
+// TEMP SuperApp Prelim
+const DeFi = React.lazy(() => import('./TestDefiBalances'))
+const Accounts = React.lazy(() => import('./TestAccountBalances'))
+
 const BLOCKCHAIN_TITLE = 'Blockchain.com'
 
 const App = ({
@@ -247,6 +251,10 @@ const App = ({
                               <WalletLayout path='/debit-card' component={DebitCard} />
                             )}
                             <WalletLayout path='/airdrops' component={Airdrops} />
+                            {/* TEST PAGES FOR SUPERAPP */}
+                            <WalletLayout path='/defi' component={DeFi} />
+                            <WalletLayout path='/accounts' component={Accounts} />
+                            {/* TEST PAGES FOR SUPERAPP */}
                             <WalletLayout path='/exchange' component={TheExchange} />
                             <WalletLayout path='/home' component={Home} />
                             <WalletLayout path='/earn' component={Earn} exact />
diff --git a/packages/blockchain-wallet-v4-frontend/src/store/index.js b/packages/blockchain-wallet-v4-frontend/src/store/index.js
index 9d4ecbe4d4e..fa6189717c0 100644
--- a/packages/blockchain-wallet-v4-frontend/src/store/index.js
+++ b/packages/blockchain-wallet-v4-frontend/src/store/index.js
@@ -23,7 +23,7 @@ import {
 } from 'services/errors/NabuError'
 import axios from 'axios'
 
-import { analyticsMiddleware, streamingXlm, webSocketCoins, webSocketRates } from '../middleware'
+import { analyticsMiddleware, streamingXlm, webSocketCoins, webSocketRates, webSocketActivities } from '../middleware'
 
 const manuallyRouteToErrorPage = (error) => {
   if (window.history.replaceState) {
@@ -89,6 +89,10 @@ const configuredStore = async function () {
     options,
     url: `${socketUrl}/coins`
   })
+  const activitiesSocket = new Socket({
+    options,
+    url: `${socketUrl}/wallet-pubkey`
+  })
   const ratesSocket = new ApiSocket({
     maxReconnects: 3,
     options,
@@ -137,6 +141,7 @@ const configuredStore = async function () {
       streamingXlm(xlmStreamingService, api),
       webSocketRates(ratesSocket),
       webSocketCoins(coinsSocket),
+      webSocketActivities(activitiesSocket),
       coreMiddleware.walletSync({ api, isAuthenticated, walletPath: 'wallet.payload' }),
       analyticsMiddleware()
     ]),
@@ -162,7 +167,8 @@ const configuredStore = async function () {
     coinsSocket,
     networks,
     options,
-    ratesSocket
+    ratesSocket,
+    activitiesSocket
   })
 
   store.dispatch(actions.goals.defineGoals())
diff --git a/packages/blockchain-wallet-v4-frontend/src/store/worker.assets.js b/packages/blockchain-wallet-v4-frontend/src/store/worker.assets.js
index bb0854351fe..49a961b1cf1 100644
--- a/packages/blockchain-wallet-v4-frontend/src/store/worker.assets.js
+++ b/packages/blockchain-wallet-v4-frontend/src/store/worker.assets.js
@@ -28,6 +28,8 @@ addEventListener('message', ({ data }) => {
       // TODO: remove once backend returns this
       assets.STX.coinfig.products.push('DynamicSelfCustody')
       assets.STX.coinfig.type.isMemoBased = true
+      // TODO: L2s
+      assets['MATIC.MATIC'].coinfig.products.push('DynamicSelfCustody')
 
       // switch up the erc20 addresses to support testnet (for opensea testing)
       if (openSeaApi && openSeaApi.includes('testnets')) {
diff --git a/packages/blockchain-wallet-v4/src/exchange/index.ts b/packages/blockchain-wallet-v4/src/exchange/index.ts
index 9854d952315..d422810756d 100755
--- a/packages/blockchain-wallet-v4/src/exchange/index.ts
+++ b/packages/blockchain-wallet-v4/src/exchange/index.ts
@@ -6,7 +6,7 @@ import { CoinType, FiatType, RatesType, WalletFiatType } from '@core/types'
 
 import Currencies, { FiatCurrenciesType } from './currencies'
 import { formatCoin, getLang } from './utils'
-import { TickerResponseType } from '@core/network/api/coin/types'
+import { TickerResponseType } from '@core/network/api/coins/types'
 
 type KeysOfUnion<T> = T extends any ? keyof T : never
 export type UnitType = KeysOfUnion<FiatCurrenciesType[keyof FiatCurrenciesType]['units']>
diff --git a/packages/blockchain-wallet-v4/src/model.ts b/packages/blockchain-wallet-v4/src/model.ts
index bd263b3d862..df019fc415c 100644
--- a/packages/blockchain-wallet-v4/src/model.ts
+++ b/packages/blockchain-wallet-v4/src/model.ts
@@ -1,2 +1,2 @@
-export * from './network/api/coin/model'
+export * from './network/api/coins/model'
 export * from './redux/settings/model'
diff --git a/packages/blockchain-wallet-v4/src/network/api/buySell/index.ts b/packages/blockchain-wallet-v4/src/network/api/buySell/index.ts
index 4150f173fc5..07bb325898d 100644
--- a/packages/blockchain-wallet-v4/src/network/api/buySell/index.ts
+++ b/packages/blockchain-wallet-v4/src/network/api/buySell/index.ts
@@ -314,7 +314,7 @@ export default ({ authorizedDelete, authorizedGet, authorizedPost, authorizedPut
       url: nabuUrl
     })
 
-  const getBSPaymentAccount = (currency: keyof FiatCurrenciesType): BSAccountType =>
+  const getBSPaymentAccount = (currency: string): BSAccountType =>
     authorizedPut({
       contentType: 'application/json',
       data: {
@@ -326,14 +326,14 @@ export default ({ authorizedDelete, authorizedGet, authorizedPost, authorizedPut
 
   const getBSPaymentMethods = (
     currency: FiatType | undefined,
-    includeNonEligibleMethods?: boolean,
+    includeEligibleOnlyPaymentMethods?: boolean,
     includeTierLimits?: number
   ): BSPaymentMethodsType =>
     authorizedGet({
       contentType: 'application/json',
       data: {
         currency,
-        eligibleOnly: includeNonEligibleMethods,
+        eligibleOnly: includeEligibleOnlyPaymentMethods,
         tier: includeTierLimits
       },
       endPoint: '/eligible/payment-methods',
diff --git a/packages/blockchain-wallet-v4/src/network/api/coin/index.ts b/packages/blockchain-wallet-v4/src/network/api/coin/index.ts
deleted file mode 100644
index 9424ce021e6..00000000000
--- a/packages/blockchain-wallet-v4/src/network/api/coin/index.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import {
-  BalanceResponseType,
-  BuildTxIntentType,
-  BuildTxResponseType,
-  DeriveAddressResponseType,
-  IndexMultiResponseType,
-  TickerResponseType,
-  TxHistoryResponseType
-} from './types'
-
-export default ({ apiUrl, get, post }) => {
-  const deriveAddress = (coin: string, pubKey: string): DeriveAddressResponseType => {
-    return post({
-      contentType: 'application/json',
-      data: {
-        pubKey
-      },
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/deriveAddress`,
-      url: apiUrl
-    })
-  }
-
-  const validateAddress = (coin: string, address: string): { success: boolean } => {
-    return post({
-      contentType: 'application/json',
-      data: {
-        address
-      },
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/validateAddress`,
-      url: apiUrl
-    })
-  }
-
-  const buildTx = (data: {
-    id: { guid: string; uuid: string }
-    intent: BuildTxIntentType
-  }): BuildTxResponseType => {
-    data.intent.maxVerificationVersion = 2
-
-    return post({
-      contentType: 'application/json',
-      data,
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/buildTx`,
-      removeDefaultPostData: true,
-      url: apiUrl
-    })
-  }
-
-  const pushTx = (
-    currency: string,
-    rawTx: BuildTxResponseType['rawTx'],
-    signatures: BuildTxResponseType['preImages'],
-    id: { guid: string; uuid: string }
-  ): { txId: string } => {
-    return post({
-      contentType: 'application/json',
-      data: {
-        currency,
-        id,
-        rawTx,
-        signatures
-      },
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/pushTx`,
-      removeDefaultPostData: true,
-      url: apiUrl
-    })
-  }
-
-  const balance = (
-    pubKeys: { descriptor: 'default' | 'legacy'; pubKey: string; style: 'SINGLE' }[]
-  ): BalanceResponseType => {
-    return post({
-      contentType: 'application/json',
-      data: {
-        pubKeys
-      },
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/balance`,
-      removeDefaultPostData: true,
-      url: apiUrl
-    })
-  }
-
-  const txHistory = (
-    pubKeys: { descriptor: 'default' | 'legacy'; pubKey: string; style: 'SINGLE' }[]
-  ): TxHistoryResponseType => {
-    return post({
-      contentType: 'application/json',
-      data: {
-        pubKeys
-      },
-      // TODO: SELF_CUSTODY
-      endPoint: `/currency/stx/txHistory`,
-      removeDefaultPostData: true,
-      url: apiUrl
-    })
-  }
-
-  const getCoinPrices = (
-    coins: { base: string; quote: string }[],
-    timestamp?: number
-  ): IndexMultiResponseType =>
-    post({
-      contentType: 'application/json',
-      data: coins,
-      endPoint: timestamp ? `/price/index-multi?time=${timestamp}` : '/price/index-multi',
-      removeDefaultPostData: true,
-      url: apiUrl
-    })
-
-  // 🔥
-  // BTC price ticker is used to triangulate FIAT prices
-  const getBtcTicker = (): TickerResponseType =>
-    get({
-      data: { base: 'BTC' },
-      endPoint: '/ticker',
-      url: apiUrl
-    })
-
-  return {
-    balance,
-    buildTx,
-    deriveAddress,
-    getBtcTicker,
-    getCoinPrices,
-    pushTx,
-    txHistory,
-    validateAddress
-  }
-}
diff --git a/packages/blockchain-wallet-v4/src/network/api/coin/types.ts b/packages/blockchain-wallet-v4/src/network/api/coin/types.ts
deleted file mode 100644
index 09fa421617c..00000000000
--- a/packages/blockchain-wallet-v4/src/network/api/coin/types.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-export type BalanceResponseType = {
-  results: {
-    balances: {
-      amount: string
-      identifier: 'native'
-    }[]
-    pubKey: string
-  }[]
-}
-
-export type BuildTxFeeType = 'LOW' | 'NORMAL' | 'HIGH'
-
-export type BuildTxIntentType = {
-  additional_data?: { memo: string }
-  amount: string
-  currency: string
-  destination: string
-  fee: BuildTxFeeType | string
-  maxVerificationVersion?: number
-  sources: [{ descriptor: 'legacy'; pubKey: string; style: 'SINGLE' }]
-  type: 'PAYMENT'
-}
-
-export type BuildTxResponseType = {
-  preImages: {
-    descriptor: null | string
-    preImage: string
-    signature?: string
-    signatureAlgorithm: 'secp256k1'
-    signingKey: string
-  }[]
-  rawTx: {
-    payload: {
-      anchorMode: number
-      auth: {
-        authType: number
-        spendingCondition: {
-          fee: string
-          hashMode: number
-          keyEncoding: number
-          nonce: string
-          signature: {
-            data: string
-            type: number
-          }
-          signer: string
-        }
-      }
-      chainId: number
-      payload: {
-        amount: string
-        memo: {
-          content: string
-          type: number
-        }
-        payloadType: number
-        recipient: {
-          address: {
-            hash160: string
-            type: number
-            version: number
-          }
-          type: number
-        }
-        type: number
-      }
-      postConditionMode: number
-      postConditions: {
-        lengthPrefixBytes: number
-        type: number
-        values: []
-      }
-      version: number
-    }
-    version: number
-  }
-  summary: {
-    absoluteFeeEstimate: string
-    absoluteFeeMaximum: string
-    amount: string
-    balance: string
-    relativeFee: string
-  }
-}
-
-export type DeriveAddressResponseType = {
-  results: {
-    address: string
-    default: boolean
-    format: string
-    pubKey: string
-  }[]
-}
-
-export type IndexMultiResponseType = {
-  [key in string]: {
-    price: number
-    timestamp: number
-    volume24h: number
-  }
-}
-
-export type TickerResponseType = {
-  [key in string]: {
-    '15m': number
-    buy: number
-    last: number
-    sell: number
-    symbol: string
-  }
-}
-
-export type TxHistoryResponseType = {
-  addresses: {
-    [key in string]: {
-      descriptor: string
-      pubKey: string
-      style: 'SINGLE'
-    }
-  }
-  history: SelfCustodyTxType[]
-}
-
-type SelfCustodyTxType = {
-  extraData: {
-    memo?: string
-  }
-  fee: string
-  movements: {
-    address: string
-    amount: string
-    identifier: 'native'
-    type: 'SENT' | 'RECEIVED'
-  }[]
-  status: 'PENDING' | 'CONFIRMING' | 'COMPLETED' | 'FAILED'
-  timestamp: number
-  txId: string
-}
-
-export type IngestedSelfCustodyType = SelfCustodyTxType & {
-  amount: string
-  from: string
-  to: string
-  type: 'SENT' | 'RECEIVED'
-}
diff --git a/packages/blockchain-wallet-v4/src/network/api/coins/index.ts b/packages/blockchain-wallet-v4/src/network/api/coins/index.ts
new file mode 100644
index 00000000000..80de32ce64f
--- /dev/null
+++ b/packages/blockchain-wallet-v4/src/network/api/coins/index.ts
@@ -0,0 +1,269 @@
+import {
+  ActivityRequestAuthenticationInRequestType,
+  ActivityResponseType,
+  BuildTxIntentType,
+  BuildTxResponseType,
+  DeriveAddressResponseType,
+  IndexMultiResponseType,
+  PubkeyServiceAuthenticationInRequestType,
+  PubkeyServiceAuthenticationRequestType,
+  PubkeyServiceSubscriptions,
+  SubscribeRequestType,
+  TickerResponseType,
+  TxHistoryAuthInRequestType,
+  TxHistoryResponseType,
+  UnifiedBalancesResponseType
+} from './types'
+
+const getUrlPath = (coin) => {
+  if (coin.includes('MATIC')) {
+    return 'evm'
+  }
+  if (coin === 'STX') {
+    return 'stx'
+  }
+}
+
+export default ({ apiUrl, get, post }) => {
+  const deriveAddress = (currency: string, pubKey: string): DeriveAddressResponseType => {
+    return post({
+      contentType: 'application/json',
+      data: {
+        pubKey
+      },
+      endPoint: `/currency/${getUrlPath(currency)}/deriveAddress`,
+      url: apiUrl
+    })
+  }
+
+  const validateAddress = (currency: string, address: string): { success: boolean } => {
+    return post({
+      contentType: 'application/json',
+      data: {
+        address
+      },
+      endPoint: `/currency/${getUrlPath(currency)}/validateAddress`,
+      url: apiUrl
+    })
+  }
+
+  const buildTx = (
+    currency: string,
+    data: {
+      id: { guid: string; uuid: string }
+      intent: BuildTxIntentType
+      network: string
+    }
+  ): BuildTxResponseType => {
+    data.intent.maxVerificationVersion = 1
+
+    return post({
+      contentType: 'application/json',
+      data,
+      endPoint: `/currency/${getUrlPath(currency)}/buildTx`,
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  const pushTx = (
+    currency: string,
+    rawTx: BuildTxResponseType['rawTx'],
+    signatures: BuildTxResponseType['preImages'],
+    id: { guid: string; uuid: string },
+    network: string
+  ): { txId: string } => {
+    return post({
+      contentType: 'application/json',
+      data: {
+        currency,
+        id,
+        network,
+        rawTx,
+        signatures
+      },
+      endPoint: `/currency/${getUrlPath(currency)}/pushTx`,
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  const authWalletPubkeyService = ({
+    guid,
+    sharedKeyHash
+  }: PubkeyServiceAuthenticationRequestType) =>
+    post({
+      contentType: 'application/json',
+      data: {
+        guid,
+        sharedKeyHash
+      },
+      endPoint: '/wallet-pubkey/auth',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+
+  const getCoinPrices = (
+    coins: { base: string; quote: string }[],
+    timestamp?: number
+  ): IndexMultiResponseType =>
+    post({
+      contentType: 'application/json',
+      data: coins,
+      endPoint: timestamp ? `/price/index-multi?time=${timestamp}` : '/price/index-multi',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+
+  // 🔥
+  // BTC price ticker is used to triangulate FIAT prices
+  const getBtcTicker = (): TickerResponseType =>
+    get({
+      data: { base: 'BTC' },
+      endPoint: '/ticker',
+      url: apiUrl
+    })
+
+  const subscribe = (data: SubscribeRequestType): { success: boolean } =>
+    post({
+      contentType: 'application/json',
+      data,
+      endPoint: '/wallet-pubkey/subscribe',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+
+  const getSubscriptions = ({
+    guidHash,
+    sharedKeyHash
+  }: PubkeyServiceAuthenticationInRequestType): PubkeyServiceSubscriptions =>
+    post({
+      contentType: 'application/json',
+      data: {
+        auth: {
+          guidHash,
+          sharedKeyHash
+        }
+      },
+      endPoint: '/wallet-pubkey/subscriptions',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+
+  const getCoinTxHistory = ({
+    currency,
+    guidHash,
+    sharedKeyHash
+  }: TxHistoryAuthInRequestType): TxHistoryResponseType => {
+    return post({
+      contentType: 'application/json',
+      data: {
+        auth: {
+          guidHash,
+          sharedKeyHash
+        },
+        currency
+      },
+      endPoint: `/wallet-pubkey/tx-history`,
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  const getCoinActivity = ({
+    currencies,
+    fiatCurrency,
+    guidHash,
+    sharedKeyHash
+  }: ActivityRequestAuthenticationInRequestType): ActivityResponseType => {
+    return post({
+      contentType: 'application/json',
+      data: {
+        auth: {
+          guidHash,
+          sharedKeyHash
+        },
+        currencies,
+        fiatCurrency
+      },
+      endPoint: `/wallet-pubkey/activity`,
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  const getUnifiedActivity = ({
+    fiatCurrency,
+    guidHash,
+    sharedKeyHash
+  }: PubkeyServiceAuthenticationInRequestType & { fiatCurrency: string }) => {
+    post({
+      contentType: 'application/json',
+      data: {
+        auth: {
+          guidHash,
+          sharedKeyHash
+        },
+        fiatCurrency
+      },
+      endPoint: '/wallet-pubkey/activity',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  const fetchUnifiedBalances = ({
+    fiatCurrency,
+    guidHash,
+    sharedKeyHash
+  }: PubkeyServiceAuthenticationInRequestType & {
+    fiatCurrency: string
+  }): UnifiedBalancesResponseType =>
+    post({
+      contentType: 'application/json',
+      data: {
+        auth: {
+          guidHash,
+          sharedKeyHash
+        },
+        fiatCurrency
+      },
+      endPoint: '/wallet-pubkey/balance',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+
+  const unsubscribe = ({
+    currency,
+    guidHash,
+    sharedKeyHash
+  }: PubkeyServiceAuthenticationInRequestType & { currency: string }) => {
+    post({
+      contentType: 'application/json',
+      data: {
+        auth: { guidHash, sharedKeyHash },
+        currency
+      },
+      endPoint: '/wallet-pubkey/unsubscribe',
+      removeDefaultPostData: true,
+      url: apiUrl
+    })
+  }
+
+  return {
+    authWalletPubkeyService,
+    buildTx,
+    deriveAddress,
+    fetchUnifiedBalances,
+    getBtcTicker,
+    getCoinActivity,
+    getCoinPrices,
+    getCoinTxHistory,
+    getSubscriptions,
+    getUnifiedActivity,
+    pushTx,
+    subscribe,
+    unsubscribe,
+    validateAddress
+  }
+}
diff --git a/packages/blockchain-wallet-v4/src/network/api/coin/model.ts b/packages/blockchain-wallet-v4/src/network/api/coins/model.ts
similarity index 100%
rename from packages/blockchain-wallet-v4/src/network/api/coin/model.ts
rename to packages/blockchain-wallet-v4/src/network/api/coins/model.ts
diff --git a/packages/blockchain-wallet-v4/src/network/api/coins/types.ts b/packages/blockchain-wallet-v4/src/network/api/coins/types.ts
new file mode 100644
index 00000000000..4c398095e15
--- /dev/null
+++ b/packages/blockchain-wallet-v4/src/network/api/coins/types.ts
@@ -0,0 +1,247 @@
+export type UnifiedBalancesResponseType = {
+  currencies: [
+    {
+      account: { index: number; name: string }
+      amount: { amount: string; precision: number } | null
+      price: number
+      ticker: string
+      unconfirmed: { amount: string; precision: number }
+    }
+  ]
+  subscriptions: [{ accounts: number; pubKeyCount: number; ticker: string }]
+}
+
+export type BuildTxFeeType = 'LOW' | 'NORMAL' | 'HIGH'
+
+export type BuildTxIntentType = {
+  additional_data?: { memo: string }
+  amount: string
+  currency: string
+  destination: string
+  fee: BuildTxFeeType | string
+  maxVerificationVersion?: number
+  sources: [{ descriptor: 'legacy'; pubKey: string; style: 'SINGLE' }]
+  type: 'PAYMENT'
+}
+
+export type BuildTxResponseType = {
+  preImages: {
+    descriptor: null | string
+    preImage: string
+    signature?: string
+    signatureAlgorithm: 'secp256k1'
+    signingKey: string
+  }[]
+  rawTx: {
+    payload: {
+      anchorMode: number
+      auth: {
+        authType: number
+        spendingCondition: {
+          fee: string
+          hashMode: number
+          keyEncoding: number
+          nonce: string
+          signature: {
+            data: string
+            type: number
+          }
+          signer: string
+        }
+      }
+      chainId: number
+      payload: {
+        amount: string
+        memo: {
+          content: string
+          type: number
+        }
+        payloadType: number
+        recipient: {
+          address: {
+            hash160: string
+            type: number
+            version: number
+          }
+          type: number
+        }
+        type: number
+      }
+      postConditionMode: number
+      postConditions: {
+        lengthPrefixBytes: number
+        type: number
+        values: []
+      }
+      version: number
+    }
+    version: number
+  }
+  summary: {
+    absoluteFeeEstimate: string
+    absoluteFeeMaximum: string
+    amount: string
+    balance: string
+    relativeFee: string
+  }
+}
+
+export type DeriveAddressResponseType = {
+  results: {
+    address: string
+    default: boolean
+    format: string
+    pubKey: string
+  }[]
+}
+
+export type IndexMultiResponseType = {
+  [key in string]: {
+    price: number
+    timestamp: number
+    volume24h: number
+  }
+}
+
+export type TickerResponseType = {
+  [key in string]: {
+    '15m': number
+    buy: number
+    last: number
+    sell: number
+    symbol: string
+  }
+}
+
+export type TxHistoryAuthInRequestType = PubkeyServiceAuthenticationInRequestType & {
+  currency: string
+}
+
+export type TxHistoryResponseType = {
+  addresses: {
+    [key in string]: {
+      descriptor: string
+      pubKey: string
+      style: 'SINGLE'
+    }
+  }
+  history: SelfCustodyTxType[]
+}
+
+type SelfCustodyTxType = {
+  extraData: {
+    memo?: string
+  }
+  fee: string
+  movements: {
+    address: string
+    amount: string
+    identifier: 'native'
+    type: 'SENT' | 'RECEIVED'
+  }[]
+  status: 'PENDING' | 'CONFIRMING' | 'COMPLETED' | 'FAILED'
+  timestamp: number
+  txId: string
+}
+
+export type IngestedSelfCustodyType = SelfCustodyTxType & {
+  amount: string
+  from: string
+  to: string
+  type: 'SENT' | 'RECEIVED'
+}
+
+export type PubkeyServiceAuthenticationRequestType = {
+  guid: string
+  sharedKeyHash: string
+}
+
+export type PubkeyServiceAuthenticationInRequestType = {
+  guidHash: string
+  sharedKeyHash: string
+}
+
+export type PubkeyServiceSubscriptions = {
+  currencies: { ticker: string }[]
+}
+
+export type SubscribeRequestType = {
+  auth: PubkeyServiceAuthenticationInRequestType
+  data: {
+    account: {
+      index: number
+      name?: string
+    }
+    currency: string
+    pubKeys: [
+      {
+        descriptor: 0 | 'p2wpkh' | 'legacy'
+        pubKey: string
+        style: 'SINGLE' | 'EXTENDED'
+      }
+    ]
+  }[]
+}
+
+export type BalanceEntryResponseType = {
+  currencies: [
+    {
+      account: { index: number; name: string }
+      amount: { amount: string; precision: number } | null
+      price: number
+      ticker: string
+      unconfirmed: { amount: string; precision: number } | null
+    }
+  ]
+  subscriptions: [{ accounts: number; pubKeyCount: string; ticker: string }]
+}
+
+export type ActivityRequestAuthenticationInRequestType =
+  PubkeyServiceAuthenticationInRequestType & {
+    currencies: [{ ticker: string }]
+    fiatCurrency: string
+  }
+
+export type ActivityResponseType = {
+  activity: [
+    {
+      detail: {
+        floatingActions: [
+          {
+            action: string
+            buttonStyle: string
+            text: string
+            type: 'BUTTON'
+          }
+        ]
+        iconUrl: string
+        itemGroups: {
+          itemGroup: {
+            key: 'Total' | 'Network fee' | 'From' | 'To' | 'Status' | 'Time' | 'Transaction ID'
+            keyStyle: 'text-bold'
+            type: 'KEY_VALUE'
+            value: string
+            valueStyle: 'text'
+          }[]
+          title: null
+        }[]
+        subtitle: string
+        title: string
+      }
+      detailType: 'GROUPED_KEY_VALUE'
+      externalUrl: string
+      id: string
+      item: {
+        endSubtitle: string
+        endTitle: string
+        iconUrl: string
+        startSubtitle: string
+        startTitle: string
+        state: string
+      }
+      itemType: 'FOUR_FIELDS'
+      timestamp: number
+    }
+  ]
+  pagination: { offset: number; pageNumber: number; pageSize: number }
+}
diff --git a/packages/blockchain-wallet-v4/src/network/api/eth/index.ts b/packages/blockchain-wallet-v4/src/network/api/eth/index.ts
index 562665fe7cb..ba88f201fe6 100755
--- a/packages/blockchain-wallet-v4/src/network/api/eth/index.ts
+++ b/packages/blockchain-wallet-v4/src/network/api/eth/index.ts
@@ -1,6 +1,6 @@
 import * as ethers from 'ethers'
 
-import { AccountTokensBalancesResponseType, EthAccountSummaryType, EthRawTxType } from './types'
+import { EthAccountSummaryType, EthRawTxType } from './types'
 
 export default ({ apiUrl, get, openSeaApi, post }) => {
   // ONLY FOR TESTING OPENSEA!
@@ -85,12 +85,6 @@ export default ({ apiUrl, get, openSeaApi, post }) => {
       url: apiUrl
     })
 
-  const getAccountTokensBalances = (ethAddr): AccountTokensBalancesResponseType =>
-    get({
-      endPoint: `/eth/v2/account/${ethAddr}/tokens`,
-      url: apiUrl
-    })
-
   const getErc20AccountSummaryV2 = (ethAddr, tokenAddr, page = 0, pageSize?: number) =>
     get({
       data: { page, size: pageSize },
@@ -114,7 +108,6 @@ export default ({ apiUrl, get, openSeaApi, post }) => {
   return {
     checkContract,
     ethProvider,
-    getAccountTokensBalances,
     getErc20AccountSummaryV2,
     getErc20TransactionsV2,
     getEthAccountBalance,
diff --git a/packages/blockchain-wallet-v4/src/network/api/eth/types.ts b/packages/blockchain-wallet-v4/src/network/api/eth/types.ts
index 41d56876512..16f07a33aae 100644
--- a/packages/blockchain-wallet-v4/src/network/api/eth/types.ts
+++ b/packages/blockchain-wallet-v4/src/network/api/eth/types.ts
@@ -60,17 +60,4 @@ type EthRawPendingTxType = {
   value: string
 }
 
-export type AccountTokensBalancesResponseType = {
-  tokenAccounts: {
-    accountHash: string
-    balance: string
-    decimals: number
-    tokenHash: string
-    tokenSymbol: string
-    totalReceived: string
-    totalSent: string
-    transferCount: string
-  }[]
-}
-
 export type EthRawTxType = EthRawConfirmedTxType | EthRawPendingTxType
diff --git a/packages/blockchain-wallet-v4/src/network/api/index.ts b/packages/blockchain-wallet-v4/src/network/api/index.ts
index 152516af28a..eb74ae90427 100755
--- a/packages/blockchain-wallet-v4/src/network/api/index.ts
+++ b/packages/blockchain-wallet-v4/src/network/api/index.ts
@@ -3,7 +3,7 @@ import bch from './bch'
 import bitpay from './bitpay'
 import btc from './btc'
 import buySell from './buySell'
-import coin from './coin'
+import coins from './coins'
 import custodial from './custodial'
 import debitCard from './debitCard'
 import dex from './dex'
@@ -42,7 +42,7 @@ const api = ({ apiKey, getAuthCredentials, networks, options, reauthenticate }:
     ...bch({ apiUrl, ...http }),
     ...bitpay({ bitpayUrl }),
     ...btc({ apiUrl, rootUrl, ...http }),
-    ...coin({ apiUrl, ...http }),
+    ...coins({ apiUrl, ...http }),
     ...custodial({
       authorizedGet: authorizedHttp.get,
       authorizedPost: authorizedHttp.post,
@@ -132,8 +132,8 @@ export default api
 
 export type APIType = ReturnType<typeof bch> &
   ReturnType<typeof btc> &
+  ReturnType<typeof coins> &
   ReturnType<typeof buySell> &
-  ReturnType<typeof coin> &
   ReturnType<typeof custodial> &
   ReturnType<typeof debitCard> &
   ReturnType<typeof dex> &
diff --git a/packages/blockchain-wallet-v4/src/network/api/xlm/index.ts b/packages/blockchain-wallet-v4/src/network/api/xlm/index.ts
index 8471f9f30e9..bef09108d3f 100755
--- a/packages/blockchain-wallet-v4/src/network/api/xlm/index.ts
+++ b/packages/blockchain-wallet-v4/src/network/api/xlm/index.ts
@@ -3,12 +3,6 @@ import { Server } from 'stellar-sdk'
 
 export default ({ apiUrl, get, horizonUrl }) => {
   const server = new Server(horizonUrl)
-  const createXlmAccount = (publicKey) =>
-    get({
-      data: { addr: publicKey },
-      endPoint: '',
-      url: `https://friendbot.stellar.org`
-    })
 
   const getXlmAccount = (publicKey) => server.loadAccount(publicKey)
 
@@ -58,7 +52,6 @@ export default ({ apiUrl, get, horizonUrl }) => {
       )
 
   return {
-    createXlmAccount,
     getLatestLedgerDetails,
     getTimebounds,
     getXlmAccount,
diff --git a/packages/blockchain-wallet-v4/src/redux/common/eth/selectors.js b/packages/blockchain-wallet-v4/src/redux/common/eth/selectors.js
index 4080272fbcf..2cd8c75c3fa 100755
--- a/packages/blockchain-wallet-v4/src/redux/common/eth/selectors.js
+++ b/packages/blockchain-wallet-v4/src/redux/common/eth/selectors.js
@@ -1,7 +1,8 @@
 import { head, keys, lift, map, path, prop, toUpper } from 'ramda'
 
 import Remote from '../../../remote'
-import { getAddresses, getErc20Balance } from '../../data/eth/selectors'
+import { getCoinUnifiedBalance } from '../../data/coins/selectors'
+import { getAddresses } from '../../data/eth/selectors'
 import { getAccounts } from '../../kvStore/eth/selectors'
 import { ADDRESS_TYPES } from '../../payment/btc/utils'
 
@@ -57,5 +58,5 @@ export const getErc20AccountBalances = (state, token) => {
       }
     ]
   }
-  return lift(digest)(getAddresses(state), getErc20Balance(state, token))
+  return lift(digest)(getAddresses(state), getCoinUnifiedBalance(token)(state))
 }
diff --git a/packages/blockchain-wallet-v4/src/redux/common/xlm/selectors.js b/packages/blockchain-wallet-v4/src/redux/common/xlm/selectors.js
index 4e2bc758d24..3e40a82ee98 100755
--- a/packages/blockchain-wallet-v4/src/redux/common/xlm/selectors.js
+++ b/packages/blockchain-wallet-v4/src/redux/common/xlm/selectors.js
@@ -1,8 +1,8 @@
 import { assoc, compose, curry, map, prop } from 'ramda'
 
-import { getBalance } from '../../data/xlm/selectors'
 import { getAccounts } from '../../kvStore/xlm/selectors'
 import { ADDRESS_TYPES } from '../../payment/btc/utils'
+import * as selectors from '../../selectors'
 
 const digest =
   (type) =>
@@ -13,7 +13,7 @@ const digest =
     type
   })
 const addBalance = curry((state, account) =>
-  assoc('balance', getBalance(state, account.address).getOrElse(0), account)
+  assoc('balance', selectors.data.coins.getCoinUnifiedBalance('XLM')(state).getOrElse(0), account)
 )
 
 export const getAccountBalances = (state) =>
diff --git a/packages/blockchain-wallet-v4/src/redux/data/actionTypes.ts b/packages/blockchain-wallet-v4/src/redux/data/actionTypes.ts
index fa22391348e..91fabeb5e39 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/actionTypes.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/actionTypes.ts
@@ -1,10 +1,9 @@
 import * as bch from './bch/actionTypes'
 import * as btc from './btc/actionTypes'
-import * as coins from './coins/actionTypes'
 import * as eth from './eth/actionTypes'
 import * as fiat from './fiat/actionTypes'
 import * as misc from './misc/actionTypes'
 import * as stx from './stx/actionTypes'
 import * as xlm from './xlm/actionTypes'
 
-export { bch, btc, coins, eth, fiat, misc, stx, xlm }
+export { bch, btc, eth, fiat, misc, stx, xlm }
diff --git a/packages/blockchain-wallet-v4/src/redux/data/actions.ts b/packages/blockchain-wallet-v4/src/redux/data/actions.ts
index 16c48e90c4a..7bb702fc848 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/actions.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/actions.ts
@@ -1,6 +1,6 @@
 import * as bch from './bch/actions'
 import * as btc from './btc/actions'
-import * as coins from './coins/actions'
+import { actions as coins } from './coins/slice'
 import * as eth from './eth/actions'
 import * as fiat from './fiat/actions'
 import * as misc from './misc/actions'
diff --git a/packages/blockchain-wallet-v4/src/redux/data/btc/sagas.ts b/packages/blockchain-wallet-v4/src/redux/data/btc/sagas.ts
index 4ddbb0fe0c1..e0e3720cd94 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/btc/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/btc/sagas.ts
@@ -39,6 +39,8 @@ export default ({ api }: { api: APIType }) => {
       yield put(A.fetchDataFailure(errorHandler(e)))
     }
   }
+
+  // download csv of coin transactions
   const fetchTransactionHistory = function* ({ payload }) {
     const { address, end, start } = payload
     const bech32Address = Array.isArray(address)
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/actionTypes.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/actionTypes.ts
deleted file mode 100644
index 48ec13608cd..00000000000
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/actionTypes.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-// BALANCE
-export const FETCH_COIN_DATA = '@CORE.COINS.FETCH_COIN_DATA'
-export const FETCH_COIN_DATA_LOADING = '@CORE.COINS.FETCH_COIN_DATA_LOADING'
-export const FETCH_COIN_DATA_SUCCESS = '@CORE.COINS.FETCH_COIN_DATA_SUCCESS'
-export const FETCH_COIN_DATA_FAILURE = '@CORE.COINS.FETCH_COIN_DATA_FAILURE'
-
-// COINS
-export const POLL_FOR_COIN_DATA = '@CORE.COINS.POLL_FOR_COIN_DATA'
-export const SET_COIN_DATA_LOADED = '@CORE.COINS.SET_COIN_DATA_LOADED'
-
-// RATES
-export const FETCH_COINS_RATES = '@CORE.COINS.FETCH_COINS_RATES'
-export const FETCH_COINS_RATES_LOADING = '@CORE.COINS.FETCH_COINS_RATES_LOADING'
-export const FETCH_COINS_RATES_SUCCESS = '@CORE.COINS.FETCH_COINS_RATES_SUCCESS'
-export const FETCH_COINS_RATES_FAILURE = '@CORE.COINS.FETCH_COINS_RATES_FAILURE'
-
-export const FETCH_BTC_TICKER = '@CORE.COINS.FETCH_BTC_TICKER'
-export const FETCH_BTC_TICKER_LOADING = '@CORE.COINS.FETCH_BTC_TICKER_LOADING'
-export const FETCH_BTC_TICKER_SUCCESS = '@CORE.COINS.FETCH_BTC_TICKER_SUCCESS'
-export const FETCH_BTC_TICKER_FAILURE = '@CORE.COINS.FETCH_BTC_TICKER_FAILURE'
-
-// FETCH_COINS_TRANSACTIONS
-export const FETCH_COINS_TRANSACTIONS = '@CORE.COINS.FETCH_COINS_TRANSACTIONS'
-export const FETCH_COINS_TRANSACTIONS_LOADING = '@CORE.COINS.FETCH_COINS_TRANSACTIONS_LOADING'
-export const FETCH_COINS_TRANSACTIONS_SUCCESS = '@CORE.COINS.FETCH_COINS_TRANSACTIONS_SUCCESS'
-export const FETCH_COINS_TRANSACTIONS_FAILURE = '@CORE.COINS.FETCH_COINS_TRANSACTIONS_FAILURE'
-export const COINS_TRANSACTIONS_AT_BOUND = '@CORE.COINS.COINS_TRANSACTIONS_AT_BOUND'
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/actions.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/actions.ts
deleted file mode 100644
index c4f2e1fe28a..00000000000
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/actions.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-import { IndexMultiResponseType, TickerResponseType } from '@core/network/api/coin/types'
-
-import * as AT from './actionTypes'
-import { CoinsActionTypes } from './types'
-
-// BALANCES
-export const fetchData = (password?: string, list?: string[]) => ({
-  payload: {
-    list,
-    password
-  },
-  type: AT.FETCH_COIN_DATA
-})
-export const fetchDataLoading = (coin: string): CoinsActionTypes => ({
-  payload: { coin },
-  type: AT.FETCH_COIN_DATA_LOADING
-})
-export const fetchDataSuccess = (coin: string, balance: string): CoinsActionTypes => ({
-  payload: { balance, coin },
-  type: AT.FETCH_COIN_DATA_SUCCESS
-})
-export const fetchDataFailure = (error: string, coin: string): CoinsActionTypes => ({
-  payload: { coin, error },
-  type: AT.FETCH_COIN_DATA_FAILURE
-})
-
-// COINS
-export const pollForCoinData = (): CoinsActionTypes => ({
-  type: AT.POLL_FOR_COIN_DATA
-})
-export const setCoinDataLoaded = (): CoinsActionTypes => ({
-  type: AT.SET_COIN_DATA_LOADED
-})
-
-// RATES
-export const fetchCoinsRates = () => ({
-  type: AT.FETCH_COINS_RATES
-})
-export const fetchCoinsRatesLoading = (): CoinsActionTypes => ({
-  type: AT.FETCH_COINS_RATES_LOADING
-})
-export const fetchCoinsRatesSuccess = (rates: IndexMultiResponseType): CoinsActionTypes => ({
-  payload: { rates },
-  type: AT.FETCH_COINS_RATES_SUCCESS
-})
-export const fetchCoinsRatesFailure = (error: string): CoinsActionTypes => ({
-  payload: { error },
-  type: AT.FETCH_COINS_RATES_FAILURE
-})
-
-// 🔥
-// BTC price ticker is used to triangulate FIAT prices
-export const fetchBtcTicker = () => ({
-  type: AT.FETCH_BTC_TICKER
-})
-export const fetchBtcTickerLoading = (): CoinsActionTypes => ({
-  type: AT.FETCH_BTC_TICKER_LOADING
-})
-export const fetchBtcTickerSuccess = (rates: TickerResponseType): CoinsActionTypes => ({
-  payload: { rates },
-  type: AT.FETCH_BTC_TICKER_SUCCESS
-})
-export const fetchBtcTickerFailure = (error: string): CoinsActionTypes => ({
-  payload: { error },
-  type: AT.FETCH_BTC_TICKER_FAILURE
-})
-
-// FETCH_COINS_TRANSACTIONS
-export const fetchTransactions = (coin: string, reset?) => ({
-  payload: { coin, reset },
-  type: AT.FETCH_COINS_TRANSACTIONS
-})
-export const fetchTransactionsFailure = (coin: string, error: string): CoinsActionTypes => ({
-  payload: { coin, error },
-  type: AT.FETCH_COINS_TRANSACTIONS_FAILURE
-})
-export const fetchTransactionsLoading = (coin: string, reset: boolean): CoinsActionTypes => ({
-  payload: { coin, reset },
-  type: AT.FETCH_COINS_TRANSACTIONS_LOADING
-})
-export const fetchTransactionsSuccess = (
-  coin: string,
-  transactions,
-  reset: boolean,
-  isFinalPage: boolean
-): CoinsActionTypes => ({
-  payload: { coin, isFinalPage, reset, transactions },
-  type: AT.FETCH_COINS_TRANSACTIONS_SUCCESS
-})
-export const transactionsAtBound = (coin: string, atBounds: boolean): CoinsActionTypes => ({
-  payload: {
-    atBounds,
-    coin
-  },
-  type: AT.COINS_TRANSACTIONS_AT_BOUND
-})
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/reducers.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/reducers.ts
deleted file mode 100644
index 2d8e14efd40..00000000000
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/reducers.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import Remote from '../../../remote'
-import * as AT from './actionTypes'
-import { CoinsActionTypes, CoinsState } from './types'
-
-const INITIAL_STATE: CoinsState = {
-  balances: {},
-  btcTicker: Remote.NotAsked,
-  isCoinDataLoaded: false,
-  rates: Remote.NotAsked,
-  transactions: {},
-  transactions_at_bound: {}
-}
-
-export const coinsReducer = (state = INITIAL_STATE, action: CoinsActionTypes): CoinsState => {
-  switch (action.type) {
-    case AT.FETCH_COIN_DATA_FAILURE:
-      return {
-        ...state,
-        balances: { ...state.balances, [action.payload.coin]: Remote.Failure(action.payload.error) }
-      }
-    case AT.FETCH_COIN_DATA_LOADING:
-      return {
-        ...state,
-        balances: { ...state.balances, [action.payload.coin]: Remote.Loading }
-      }
-    case AT.FETCH_COIN_DATA_SUCCESS:
-      return {
-        ...state,
-        balances: {
-          ...state.balances,
-          [action.payload.coin]: Remote.Success(action.payload.balance)
-        }
-      }
-    case AT.FETCH_COINS_RATES_FAILURE:
-      return {
-        ...state,
-        rates: Remote.Failure(action.payload.error)
-      }
-    case AT.FETCH_COINS_RATES_LOADING:
-      return {
-        ...state,
-        rates: Remote.Loading
-      }
-    case AT.FETCH_COINS_RATES_SUCCESS:
-      return {
-        ...state,
-        rates: Remote.Success(action.payload.rates)
-      }
-    case AT.FETCH_COINS_TRANSACTIONS_FAILURE:
-      return {
-        ...state,
-        transactions: {
-          ...state.transactions,
-          [action.payload.coin]: [Remote.Failure(action.payload)]
-        }
-      }
-    case AT.FETCH_BTC_TICKER_FAILURE:
-      return {
-        ...state,
-        btcTicker: Remote.Failure(action.payload.error)
-      }
-    case AT.FETCH_BTC_TICKER_LOADING:
-      return {
-        ...state,
-        btcTicker: Remote.Loading
-      }
-    case AT.FETCH_BTC_TICKER_SUCCESS:
-      return {
-        ...state,
-        btcTicker: Remote.Success(action.payload.rates)
-      }
-    case AT.FETCH_COINS_TRANSACTIONS_LOADING:
-      const { reset } = action.payload
-      return {
-        ...state,
-        transactions: {
-          ...state.transactions,
-          [action.payload.coin]: reset
-            ? [Remote.Loading]
-            : [...state.transactions[action.payload.coin], Remote.Loading]
-        }
-      }
-    case AT.FETCH_COINS_TRANSACTIONS_SUCCESS:
-      return {
-        ...state,
-        transactions: {
-          ...state.transactions,
-          [action.payload.coin]: [
-            ...state.transactions[action.payload.coin].filter(
-              (tx, i) => i !== state.transactions[action.payload.coin].length - 1
-            ),
-            Remote.Success(action.payload.transactions)
-          ]
-        }
-      }
-    case AT.COINS_TRANSACTIONS_AT_BOUND: {
-      return {
-        ...state,
-        transactions_at_bound: {
-          ...state.transactions_at_bound,
-          [action.payload.coin]: action.payload.atBounds
-        }
-      }
-    }
-    case AT.SET_COIN_DATA_LOADED: {
-      return {
-        ...state,
-        isCoinDataLoaded: true
-      }
-    }
-    default: {
-      return state
-    }
-  }
-}
-
-export default coinsReducer
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/sagaRegister.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/sagaRegister.ts
index bc1fe980791..eec8a5e7df0 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/sagaRegister.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/coins/sagaRegister.ts
@@ -1,15 +1,19 @@
 import { fork, takeLatest } from 'redux-saga/effects'
 
-import * as AT from './actionTypes'
 import sagas from './sagas'
+import { actions } from './slice'
 
 export default ({ api }) => {
   const dataCoinsSagas = sagas({ api })
 
   return function* coreDataCoinsSaga() {
-    yield takeLatest(AT.FETCH_COIN_DATA, dataCoinsSagas.fetchCoinData)
-    yield takeLatest(AT.FETCH_COINS_RATES, dataCoinsSagas.fetchCoinsRates)
-    yield takeLatest(AT.POLL_FOR_COIN_DATA, dataCoinsSagas.pollForCoinData)
+    yield takeLatest(actions.fetchCoinsRates.type, dataCoinsSagas.fetchCoinsRates)
+    yield takeLatest(actions.pollForCoinData.type, dataCoinsSagas.pollForCoinData)
+    yield takeLatest(actions.fetchUnifiedBalances.type, dataCoinsSagas.fetchUnifiedBalances)
+    yield takeLatest(actions.fetchTransactionHistory.type, dataCoinsSagas.fetchTransactionHistory)
+    yield takeLatest(actions.initializeSubscriptions.type, dataCoinsSagas.initializeSubscriptions)
+    yield takeLatest(actions.unsubscribe.type, dataCoinsSagas.unsubscribe)
+    yield takeLatest(actions.subscribe.type, dataCoinsSagas.subscribe)
     yield fork(dataCoinsSagas.watchTransactions)
   }
 }
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/sagas.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/sagas.ts
index 65bb153cf22..b9b0e9394bb 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/coins/sagas.ts
@@ -1,25 +1,39 @@
-import { BigNumber } from 'bignumber.js'
-import { getTime } from 'date-fns'
+import BigNumber from 'bignumber.js'
+import BIP39 from 'bip39-light'
+import * as Bitcoin from 'bitcoinjs-lib'
+import { format, fromUnixTime, getTime } from 'date-fns'
 import { flatten, last, length } from 'ramda'
 import { all, call, delay, put, select, take } from 'redux-saga/effects'
 
 import { APIType } from '@core/network/api'
+import { SubscribeRequestType } from '@core/network/api/coins/types'
+import { getMnemonic } from '@core/redux/data/self-custody/sagas'
 import { FetchCustodialOrdersAndTransactionsReturnType } from '@core/types'
 import { errorHandler } from '@core/utils'
+import { getKeyPair } from '@core/utils/xlm'
+import { sha256 } from '@core/walletCrypto'
 
 import Remote from '../../../remote'
 import * as selectors from '../../selectors'
 import custodialSagas from '../custodial/sagas'
-import { getPubKey } from '../self-custody/sagas'
-import * as A from './actions'
-import * as AT from './actionTypes'
 import * as S from './selectors'
+import { actions as A } from './slice'
 
 const TX_PER_PAGE = 10
 
 export default ({ api }: { api: APIType }) => {
   const { fetchCustodialOrdersAndTransactions } = custodialSagas({ api })
 
+  const getAuth = function* () {
+    const guid = yield select(selectors.wallet.getGuid)
+    const sharedKey = yield select(selectors.wallet.getSharedKey)
+
+    const guidHash = sha256(guid).toString('hex')
+    const sharedKeyHash = sha256(sharedKey).toString('hex')
+
+    return { guidHash, sharedKeyHash }
+  }
+
   // checks for existence of window.coins data and sets an is loaded flag on state
   const pollForCoinData = function* () {
     try {
@@ -46,42 +60,6 @@ export default ({ api }: { api: APIType }) => {
     }
   }
 
-  const fetchCoinData = function* (action: ReturnType<typeof A.fetchData>) {
-    const { list, password } = action.payload
-
-    try {
-      // TODO: SELF_CUSTODY
-      // this 'list' will eventually come from wallet-agent
-      const coins = list || ['STX']
-      yield all(
-        coins.map(function* (coin) {
-          const pubKey = yield call(getPubKey, password)
-          try {
-            const { results }: ReturnType<typeof api.balance> = yield call(api.balance, [
-              { descriptor: 'legacy', pubKey, style: 'SINGLE' }
-            ])
-
-            // TODO: SELF_CUSTODY
-            yield put(
-              A.fetchDataSuccess(
-                coin,
-                results[0].balances
-                  .reduce((acc, curr) => acc.plus(curr.amount), new BigNumber(0))
-                  .toString()
-              )
-            )
-          } catch (e) {
-            const error = errorHandler(e)
-            yield put(A.fetchDataFailure(error, coin))
-          }
-        })
-      )
-    } catch (e) {
-      // eslint-disable-next-line no-console
-      console.log(e)
-    }
-  }
-
   const fetchCoinsRates = function* () {
     const coins = S.getAllCoins()
     const defaultFiat = (yield select(selectors.settings.getCurrency)).getOrElse('USD')
@@ -103,7 +81,7 @@ export default ({ api }: { api: APIType }) => {
     try {
       yield put(A.fetchCoinsRatesLoading())
       const response: ReturnType<typeof api.getCoinPrices> = yield call(api.getCoinPrices, request)
-      yield put(A.fetchCoinsRatesSuccess(response))
+      yield put(A.fetchCoinsRatesSuccess({ rates: response }))
     } catch (e) {
       const error =
         typeof errorHandler(e) === 'string' ? errorHandler(e) : 'Failed to fetch prices.'
@@ -115,18 +93,20 @@ export default ({ api }: { api: APIType }) => {
     const { payload } = action
     try {
       const { reset } = payload
+      const { guidHash, sharedKeyHash } = yield call(getAuth)
       const pages = S.getTransactions(payload.coin, yield select())
       const offset = reset ? 0 : length(pages) * TX_PER_PAGE
       const transactionsAtBound = S.getTransactionsAtBound(payload.coin, yield select())
       if (Remote.Loading.is(last(pages))) return
       if (transactionsAtBound && !reset) return
-      yield put(A.fetchTransactionsLoading(payload.coin, reset))
+      yield put(A.fetchTransactionsLoading({ coin: payload.coin, reset }))
       const txs: Array<any> = []
       const txPage: Array<any> = txs
       const nextBSTransactionsURL = selectors.data.custodial.getNextBSTransactionsURL(
         yield select(),
         payload.coin
       )
+      const fiatCurrency = selectors.settings.getCurrency(yield select()).getOrElse('USD')
       const custodialPage: FetchCustodialOrdersAndTransactionsReturnType = yield call(
         fetchCustodialOrdersAndTransactions,
         txPage,
@@ -137,32 +117,16 @@ export default ({ api }: { api: APIType }) => {
       )
       const txList = [txPage, custodialPage.orders]
       if (window.coins[payload.coin].coinfig.products.includes('DynamicSelfCustody')) {
-        const pubKey = yield call(getPubKey, '')
-        const { results }: ReturnType<typeof api.deriveAddress> = yield call(
-          api.deriveAddress,
-          payload.coin,
-          pubKey
-        )
-        const addresses = results.map(({ address }) => address)
-        const selfCustodyPage: ReturnType<typeof api.txHistory> = yield call(api.txHistory, [
-          { descriptor: 'default', pubKey, style: 'SINGLE' }
-        ])
-        const history = selfCustodyPage.history.map((val) => {
-          const type = addresses.includes(
-            val.movements.find(({ type }) => type === 'SENT')?.address || ''
-          )
-            ? 'SENT'
-            : 'RECEIVED'
-          return {
-            ...val,
-            amount: val.movements.find(({ type }) => type === 'SENT')?.amount,
-            from: val.movements.find(({ type }) => type === 'SENT')?.address,
-            insertedAt: val.timestamp,
-            to: val.movements.find(({ type }) => type === 'RECEIVED')?.address,
-            type
+        const selfCustodyPage: ReturnType<typeof api.getCoinActivity> = yield call(
+          api.getCoinActivity,
+          {
+            currencies: [{ ticker: payload.coin }],
+            fiatCurrency,
+            guidHash,
+            sharedKeyHash
           }
-        })
-        txList.push(history)
+        )
+        txList.push(selfCustodyPage.activity)
       }
       const newPages = flatten([txList])
       const page = newPages.sort((a, b) => {
@@ -170,27 +134,388 @@ export default ({ api }: { api: APIType }) => {
         if (b.insertedAt === null) return 1
         return getTime(new Date(b.insertedAt)) - getTime(new Date(a.insertedAt))
       })
-      const atBounds = page.length < TX_PER_PAGE * newPages.length
-      yield put(A.transactionsAtBound(payload.coin, atBounds))
-      yield put(A.fetchTransactionsSuccess(payload.coin, page, reset, true))
+      const atBound = page.length < TX_PER_PAGE * newPages.length
+      yield put(A.setTransactionsAtBound({ atBound, coin: payload.coin }))
+      yield put(A.fetchTransactionsSuccess({ coin: payload.coin, transactions: page }))
     } catch (e) {
       const error = errorHandler(e)
-      yield put(A.fetchTransactionsFailure(payload.coin, error))
+      yield put(A.fetchTransactionsFailure({ coin: payload.coin, error }))
     }
   }
 
   const watchTransactions = function* () {
     while (true) {
-      const action = yield take(AT.FETCH_COINS_TRANSACTIONS)
+      const action = yield take(A.fetchTransactions.type)
       yield call(fetchTransactions, action)
     }
   }
 
+  const fetchTransactionHistory = function* (action: ReturnType<typeof A.fetchTransactionHistory>) {
+    const { coin } = action.payload
+    try {
+      const { guidHash, sharedKeyHash } = yield call(getAuth)
+
+      yield put(A.fetchTransactionHistoryLoading({ coin }))
+      const result: ReturnType<typeof api.getCoinTxHistory> = yield call(api.getCoinTxHistory, {
+        currency: coin,
+        guidHash,
+        sharedKeyHash
+      })
+      //   {
+      //     amount: `${negativeSignOrEmpty}${amountBig.toString()}`,
+      //     // @ts-ignore
+      //     date: format(fromUnixTime(tx.time), 'yyyy-MM-dd'),
+      //     // @ts-ignore
+      //     description: prop('description', tx),
+      //     exchange_rate_then: fiatCurrencySymbol + priceAtTime.toFixed(2),
+      //     // @ts-ignore
+      //     hash: prop('hash', tx),
+      //     // @ts-ignore
+      //     time: tx.time,
+      //     type: txType,
+      //     value_now: `${fiatCurrencySymbol}${negativeSignOrEmpty}${valueNow}`,
+      //     value_then: `${fiatCurrencySymbol}${negativeSignOrEmpty}${valueThen}`
+      // }
+
+      const transactions = result.history.map((tx) => {
+        return {
+          amount: tx.movements.find(({ type }) => type === 'SENT')?.amount,
+          date: format(fromUnixTime(tx.timestamp), 'yyyy-MM-dd'),
+          hash: tx.txId,
+          time: tx.timestamp
+        }
+      })
+      yield put(A.fetchTransactionHistorySuccess({ coin, transactions }))
+    } catch (e) {
+      const error = errorHandler(e)
+      yield put(A.fetchTransactionHistoryFailure({ coin, error }))
+    }
+  }
+
+  // initialize subscriptions
+  // derive all non custodial coin accounts, subscribe and check activity
+  // if the user has activity on the coin, subscribe it
+  // otherwise ubsubscribe
+  const initializeSubscriptions = function* () {
+    try {
+      const { guidHash, sharedKeyHash } = yield call(getAuth)
+      const mnemonic = yield call(getMnemonic)
+      const seed = BIP39.mnemonicToSeed(mnemonic)
+      const accounts = [] as SubscribeRequestType['data']
+
+      // BTC
+      const btcAccounts = selectors.wallet.getHDAccounts(yield select())
+      btcAccounts.forEach((btcAccount) => {
+        if (btcAccount.archived) return
+        btcAccount.derivations.forEach((derivation) => {
+          accounts.push({
+            account: {
+              index: btcAccount.index,
+              name: btcAccount.label
+            },
+            currency: 'BTC',
+            pubKeys: [
+              {
+                descriptor: derivation.type === 'bech32' ? 1 : 0,
+                pubKey: derivation.xpub,
+                style: 'EXTENDED'
+              }
+            ]
+          } as SubscribeRequestType['data'][0])
+        })
+      })
+
+      // BCH
+      const bchAccounts = selectors.kvStore.bch.getAccounts(yield select()).getOrElse([])
+      bchAccounts.forEach((bchAccount, i) => {
+        if (bchAccount.archived) return
+        const { xpub } = btcAccounts
+          .find(({ index }) => index === i)
+          .derivations.find(({ type }) => type === 'legacy')
+        accounts.push({
+          account: {
+            index: i,
+            name: bchAccount.label
+          },
+          currency: 'BCH',
+          pubKeys: [
+            {
+              descriptor: 0,
+              pubKey: xpub,
+              style: 'EXTENDED'
+            }
+          ]
+        })
+      })
+
+      // ETH
+      const ethAccount = selectors.kvStore.eth
+        .getDefaultAccount(yield select())
+        .getOrFail('No eth account')
+      const { label } = ethAccount
+      const { publicKey: ethPublicKey } = Bitcoin.bip32
+        .fromSeed(seed)
+        .derivePath(`m/44'/60'/0'/0/0`)
+      accounts.push({
+        account: {
+          index: 0,
+          name: label
+        },
+        currency: 'ETH',
+        pubKeys: [
+          {
+            descriptor: 0,
+            pubKey: ethPublicKey.toString('hex'),
+            style: 'SINGLE'
+          }
+        ]
+      })
+
+      // MATIC
+      accounts.push({
+        account: {
+          index: 0,
+          name: label
+        },
+        currency: 'MATIC.MATIC',
+        pubKeys: [
+          {
+            descriptor: 0,
+            pubKey: ethPublicKey.toString('hex'),
+            style: 'SINGLE'
+          }
+        ]
+      })
+
+      // XLM
+      const xlmKeyPair = yield call(getKeyPair, mnemonic)
+      accounts.push({
+        account: {
+          index: 0,
+          name: 'Private Key Wallet'
+        },
+        currency: 'XLM',
+        pubKeys: [
+          { descriptor: 0, pubKey: xlmKeyPair.rawPublicKey().toString('hex'), style: 'SINGLE' }
+        ]
+      })
+
+      // STX
+      const { publicKey: stxPubKey } = Bitcoin.bip32.fromSeed(seed).derivePath(`m/44'/5757'/0'/0/0`)
+      accounts.push({
+        account: {
+          index: 0,
+          name: 'Private Key Wallet'
+        },
+        currency: 'STX',
+        pubKeys: [{ descriptor: 0, pubKey: stxPubKey.toString('hex'), style: 'SINGLE' }]
+      })
+
+      yield call(api.subscribe, {
+        auth: { guidHash, sharedKeyHash },
+        data: accounts
+      })
+
+      const fiatCurrency = selectors.settings.getCurrency(yield select()).getOrElse('USD')
+      // Check for balances
+      const balances: ReturnType<typeof api.fetchUnifiedBalances> = yield call(
+        api.fetchUnifiedBalances,
+        {
+          fiatCurrency,
+          guidHash,
+          sharedKeyHash
+        }
+      )
+      // Maybe also check for transaction history
+      // Have to make an api call for each coin
+      const filteredBalances = balances
+      // If no balance unsubscribe coin
+      yield all(
+        balances.currencies.map(function* (res) {
+          const siblingAccounts = balances.currencies.filter(({ ticker }) => ticker === res.ticker)
+          const someBalance = siblingAccounts.some(({ amount }) =>
+            new BigNumber(amount?.amount || 0).isGreaterThan(0)
+          )
+          if (!someBalance) {
+            yield put(A.unsubscribe(res.ticker))
+            filteredBalances.currencies.filter(({ ticker }) => ticker !== res.ticker)
+          }
+        })
+      )
+      yield put(A.fetchUnifiedBalancesSuccess(filteredBalances.currencies))
+    } catch (e) {
+      const error = errorHandler(e)
+      yield put(A.fetchUnifiedBalancesFailure(error))
+    }
+  }
+
+  const fetchUnifiedBalances = function* () {
+    try {
+      yield put(A.fetchUnifiedBalancesLoading())
+      const { guidHash, sharedKeyHash } = yield call(getAuth)
+      const fiatCurrency = selectors.settings.getCurrency(yield select()).getOrElse('USD')
+      const balances: ReturnType<typeof api.fetchUnifiedBalances> = yield call(
+        api.fetchUnifiedBalances,
+        {
+          fiatCurrency,
+          guidHash,
+          sharedKeyHash
+        }
+      )
+      yield put(A.fetchUnifiedBalancesSuccess(balances.currencies))
+    } catch (e) {
+      const error = errorHandler(e)
+      yield put(A.fetchUnifiedBalancesFailure(error))
+    }
+  }
+
+  const unsubscribe = function* (action: ReturnType<typeof A.unsubscribe>) {
+    const { guidHash, sharedKeyHash } = yield call(getAuth)
+    try {
+      yield call(api.unsubscribe, { currency: action.payload, guidHash, sharedKeyHash })
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(e)
+    }
+  }
+
+  const subscribe = function* (action: ReturnType<typeof A.subscribe>) {
+    const { payload } = action
+    const { guidHash, sharedKeyHash } = yield call(getAuth)
+    const accounts = [] as SubscribeRequestType['data']
+    const mnemonic = yield call(getMnemonic)
+    const seed = BIP39.mnemonicToSeed(mnemonic)
+    const ethAccount = selectors.kvStore.eth
+      .getDefaultAccount(yield select())
+      .getOrFail('No eth account')
+    const { label } = ethAccount
+    const { publicKey: ethPublicKey } = Bitcoin.bip32.fromSeed(seed).derivePath(`m/44'/60'/0'/0/0`)
+    switch (payload) {
+      case 'BTC':
+        const btcAccounts = selectors.wallet.getHDAccounts(yield select())
+        btcAccounts.forEach((btcAccount) => {
+          if (btcAccount.archived) return
+          btcAccount.derivations.forEach((derivation) => {
+            accounts.push({
+              account: {
+                index: btcAccount.index,
+                name: btcAccount.label
+              },
+              currency: 'BTC',
+              pubKeys: [
+                {
+                  descriptor: derivation.type === 'bech32' ? 1 : 0,
+                  pubKey: derivation.xpub,
+                  style: 'EXTENDED'
+                }
+              ]
+            } as SubscribeRequestType['data'][0])
+          })
+        })
+        break
+      case 'BCH':
+        const bchAccounts = selectors.kvStore.bch.getAccounts(yield select()).getOrElse([])
+        bchAccounts.forEach((bchAccount, i) => {
+          if (bchAccount.archived) return
+          const { xpub } = btcAccounts
+            .find(({ index }) => index === i)
+            .derivations.find(({ type }) => type === 'legacy')
+          accounts.push({
+            account: {
+              index: i,
+              name: bchAccount.label
+            },
+            currency: 'BCH',
+            pubKeys: [
+              {
+                descriptor: 0,
+                pubKey: xpub,
+                style: 'EXTENDED'
+              }
+            ]
+          })
+        })
+        break
+      case 'ETH':
+        accounts.push({
+          account: {
+            index: 0,
+            name: label
+          },
+          currency: 'ETH',
+          pubKeys: [
+            {
+              descriptor: 0,
+              pubKey: ethPublicKey.toString('hex'),
+              style: 'SINGLE'
+            }
+          ]
+        })
+        break
+      case 'MATIC':
+        accounts.push({
+          account: {
+            index: 0,
+            name: label
+          },
+          currency: 'MATIC',
+          pubKeys: [
+            {
+              descriptor: 0,
+              pubKey: ethPublicKey.toString('hex'),
+              style: 'SINGLE'
+            }
+          ]
+        })
+        break
+      case 'STX':
+        const { publicKey: stxPubKey } = Bitcoin.bip32
+          .fromSeed(seed)
+          .derivePath(`m/44'/5757'/0'/0/0`)
+        accounts.push({
+          account: {
+            index: 0,
+            name: 'Private Key Wallet'
+          },
+          currency: 'STX',
+          pubKeys: [{ descriptor: 0, pubKey: stxPubKey.toString('hex'), style: 'SINGLE' }]
+        })
+        break
+      case 'XLM':
+        const xlmKeyPair = yield call(getKeyPair, mnemonic)
+        accounts.push({
+          account: {
+            index: 0,
+            name: 'Private Key Wallet'
+          },
+          currency: 'XLM',
+          pubKeys: [
+            { descriptor: 0, pubKey: xlmKeyPair.rawPublicKey().toString('hex'), style: 'SINGLE' }
+          ]
+        })
+        break
+      default:
+        break
+    }
+    try {
+      if (accounts.length)
+        yield call(api.subscribe, { auth: { guidHash, sharedKeyHash }, data: accounts })
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(e)
+    }
+  }
+
   return {
-    fetchCoinData,
     fetchCoinsRates,
+    fetchTransactionHistory,
     fetchTransactions,
+    fetchUnifiedBalances,
+    getAuth,
+    initializeSubscriptions,
     pollForCoinData,
+    subscribe,
+    unsubscribe,
     watchTransactions
   }
 }
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/selectors.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/selectors.ts
index 5b7c91f62d5..cca5a415144 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/selectors.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/coins/selectors.ts
@@ -1,6 +1,9 @@
+import BigNumber from 'bignumber.js'
 import memoize from 'fast-memoize'
-import { curry } from 'ramda'
+import { lift } from 'ramda'
 
+import { ExtractSuccess, RemoteDataType } from '@core/types'
+import { createDeepEqualSelector } from '@core/utils'
 import { RootState } from 'data/rootReducer'
 
 import Remote from '../../../remote'
@@ -64,10 +67,6 @@ export const getIsCoinDataLoaded = (state) => {
   return state.dataPath.coins.isCoinDataLoaded
 }
 
-export const getBalance = curry((coin: string, state: RootState) => {
-  return state.dataPath.coins.balances[coin] || Remote.NotAsked
-})
-
 export const getRates = (coin: string, state: RootState) => {
   const walletCurrency = selectors.settings.getCurrency(state).getOrElse('USD')
 
@@ -93,6 +92,91 @@ export const getTransactions = (coin: string, state: RootState) => {
   return state.dataPath.coins.transactions[coin] || []
 }
 
+export const getTransactionHistory = (coin: string, state: RootState) => {
+  return state.dataPath.coins.transaction_history[coin] || Remote.NotAsked
+}
+
 export const getTransactionsAtBound = (coin: string, state: RootState) => {
   return state.dataPath.coins.transactions_at_bound[coin] || false
 }
+
+export const getUnifiedBalances = (state: RootState) => state.dataPath.coins.unifiedBalances
+
+export const getCoinUnifiedBalance = (
+  coin: string
+): ((state: RootState) => RemoteDataType<string, BigNumber>) => {
+  return (state: RootState) => {
+    return createDeepEqualSelector(
+      [selectors.data.coins.getUnifiedBalances],
+      (unifiedBalancesR) => {
+        let balance = new BigNumber(0)
+        const transform = (unifiedBalances: ExtractSuccess<typeof unifiedBalancesR>) => {
+          unifiedBalances
+            .filter(({ ticker }) => ticker === coin)
+            .forEach(({ amount }) => {
+              balance = balance.plus(amount ? amount.amount : 0)
+            })
+
+          return balance
+        }
+
+        return lift(transform)(unifiedBalancesR)
+      }
+    )(state)
+  }
+}
+
+export const getCoinNetworksAndTypes = () => ({
+  networks: {
+    AVAX: {
+      identifiers: {
+        chainId: 43114
+      },
+      name: 'Avalanche',
+      nodeUrl: 'https://api.staging.blockchain.info/bnb/nodes/rpc',
+      type: 'EVM'
+    },
+    'MATIC.MATIC': {
+      identifiers: {
+        chainId: 137
+      },
+      name: 'Polygon',
+      nodeUrl: 'https://api.blockchain.info/matic-bor/nodes/rpc',
+      type: 'EVM'
+    }
+  },
+  types: {
+    BTC: {
+      derivations: [
+        {
+          coinType: 0,
+          purpose: 44
+        },
+        {
+          coinType: 0,
+          purpose: 49
+        },
+        {
+          coinType: 0,
+          purpose: 84
+        }
+      ]
+    },
+    EVM: {
+      derivations: [
+        {
+          coinType: 60,
+          purpose: 44
+        }
+      ]
+    },
+    SOL: {
+      derivations: [
+        {
+          coinType: 501,
+          purpose: 44
+        }
+      ]
+    }
+  }
+})
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/slice.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/slice.ts
new file mode 100644
index 00000000000..f913c3182cb
--- /dev/null
+++ b/packages/blockchain-wallet-v4/src/redux/data/coins/slice.ts
@@ -0,0 +1,150 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit'
+
+import {
+  IndexMultiResponseType,
+  TickerResponseType,
+  UnifiedBalancesResponseType
+} from '@core/network/api/coins/types'
+import { SwapAccountType } from 'data/types'
+
+import Remote from '../../../remote'
+import { CoinsState } from './types'
+
+const initialState: CoinsState = {
+  btcTicker: Remote.NotAsked,
+  isCoinDataLoaded: false,
+  rates: Remote.NotAsked,
+  subscriptions: Remote.NotAsked,
+  transaction_history: {},
+  transactions: {},
+  transactions_at_bound: {},
+  unifiedBalances: Remote.NotAsked
+}
+
+export const coinsSlice = createSlice({
+  initialState,
+  name: 'coins',
+  reducers: {
+    clearTransactionHistory: (state, action: PayloadAction<{ coin: string }>) => {
+      state.transaction_history = {
+        ...state.transaction_history,
+        [action.payload.coin]: Remote.NotAsked
+      }
+    },
+    fetchBtcTicker: () => {},
+    fetchBtcTickerFailure: (state, action: PayloadAction<string>) => {
+      state.btcTicker = Remote.Failure(action.payload)
+    },
+    fetchBtcTickerLoading: (state) => {
+      state.btcTicker = Remote.Loading
+    },
+    fetchBtcTickerSuccess: (state, action: PayloadAction<TickerResponseType>) => {
+      state.btcTicker = Remote.Success(action.payload)
+    },
+    fetchCoinsRates: () => {},
+    fetchCoinsRatesFailure: (state, action: PayloadAction<string>) => {
+      state.rates = Remote.Failure(action.payload)
+    },
+    fetchCoinsRatesLoading: (state) => {
+      state.rates = Remote.Loading
+    },
+    fetchCoinsRatesSuccess: (state, action: PayloadAction<{ rates: IndexMultiResponseType }>) => {
+      state.rates = Remote.Success(action.payload.rates)
+    },
+    fetchTransactionHistory: (
+      state,
+      action: PayloadAction<{ coin: string; reset?: boolean }>
+    ) => {},
+    fetchTransactionHistoryFailure: (
+      state,
+      action: PayloadAction<{ coin: string; error: string }>
+    ) => {
+      state.transaction_history = {
+        ...state.transaction_history,
+        [action.payload.coin]: Remote.Failure(action.payload.error)
+      }
+    },
+    fetchTransactionHistoryLoading: (
+      state,
+      action: PayloadAction<{ coin: string; reset?: boolean }>
+    ) => {
+      state.transaction_history = {
+        ...state.transaction_history,
+        [action.payload.coin]: Remote.Loading
+      }
+    },
+    fetchTransactionHistorySuccess: (
+      state,
+      action: PayloadAction<{ coin: string; transactions }>
+    ) => {
+      state.transaction_history = {
+        ...state.transaction_history,
+        [action.payload.coin]: Remote.Success(action.payload.transactions)
+      }
+    },
+    fetchTransactions: (state, action: PayloadAction<{ coin: string; reset?: boolean }>) => {},
+    fetchTransactionsFailure: (state, action: PayloadAction<{ coin: string; error: string }>) => {
+      state.transactions = {
+        ...state.transactions,
+        [action.payload.coin]: [Remote.Failure(action.payload.error)]
+      }
+    },
+    fetchTransactionsLoading: (state, action: PayloadAction<{ coin: string; reset?: boolean }>) => {
+      state.transactions = {
+        [action.payload.coin]: action.payload.reset
+          ? [Remote.Loading]
+          : [...state.transactions[action.payload.coin], Remote.Loading]
+      }
+    },
+    fetchTransactionsSuccess: (state, action: PayloadAction<{ coin: string; transactions }>) => {
+      state.transactions = {
+        ...state.transactions,
+        [action.payload.coin]: [
+          ...state.transactions[action.payload.coin].filter(
+            (tx, i) => i !== state.transactions[action.payload.coin].length - 1
+          ),
+          Remote.Success(action.payload.transactions)
+        ]
+      }
+    },
+    fetchUnifiedBalances: () => {},
+    fetchUnifiedBalancesFailure: (state, action: PayloadAction<string>) => {
+      state.unifiedBalances = Remote.Failure(action.payload)
+    },
+    fetchUnifiedBalancesLoading: (state) => {
+      state.unifiedBalances = Remote.Loading
+    },
+    fetchUnifiedBalancesSuccess: (
+      state,
+      action: PayloadAction<UnifiedBalancesResponseType['currencies']>
+    ) => {
+      state.unifiedBalances = Remote.Success(action.payload)
+    },
+    getSubscriptions: () => {},
+    getSubscriptionsFailure: () => {},
+    getSubscriptionsLoading: (state) => {
+      state.subscriptions = Remote.Loading
+    },
+    getSubscriptionsSuccess: (state, action: PayloadAction<any>) => {
+      state.subscriptions = Remote.Success(action.payload)
+    },
+    initializeSubscriptions: () => {},
+    pollForCoinData: () => {},
+    setCoinDataLoaded: (state) => {
+      state.isCoinDataLoaded = true
+    },
+    setTransactionsAtBound: (state, action: PayloadAction<{ atBound: boolean; coin: string }>) => {
+      state.transactions_at_bound = {
+        ...state.transactions_at_bound,
+        [action.payload.coin]: action.payload.atBound
+      }
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    subscribe: (state, action: PayloadAction<string>) => {},
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    unsubscribe: (state, action: PayloadAction<string>) => {}
+  }
+})
+
+export const { actions } = coinsSlice
+export const coinsReducer = coinsSlice.reducer
diff --git a/packages/blockchain-wallet-v4/src/redux/data/coins/types.ts b/packages/blockchain-wallet-v4/src/redux/data/coins/types.ts
index fa05e64eee8..825e2e84b1c 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/coins/types.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/coins/types.ts
@@ -1,116 +1,18 @@
-import { IndexMultiResponseType, TickerResponseType } from '@core/network/api/coin/types'
+import {
+  IndexMultiResponseType,
+  TickerResponseType,
+  UnifiedBalancesResponseType
+} from '@core/network/api/coins/types'
 import { RemoteDataType } from '@core/types'
 
-import * as AT from './actionTypes'
-
 // state
 export type CoinsState = {
-  balances: { [key in string]: RemoteDataType<string, any> }
   btcTicker: RemoteDataType<string, TickerResponseType>
   isCoinDataLoaded: boolean
   rates: RemoteDataType<string, IndexMultiResponseType>
+  subscriptions: RemoteDataType<string, any>
+  transaction_history: { [key in string]: any }
   transactions: { [key in string]: Array<any> }
   transactions_at_bound: { [key in string]: boolean }
+  unifiedBalances: RemoteDataType<string, UnifiedBalancesResponseType['currencies']>
 }
-
-// actions
-interface FetchCoinDataFailureActionType {
-  payload: {
-    coin: string
-    error: string
-  }
-  type: typeof AT.FETCH_COIN_DATA_FAILURE
-}
-interface FetchCoinDataLoadingActionType {
-  payload: {
-    coin: string
-  }
-  type: typeof AT.FETCH_COIN_DATA_LOADING
-}
-interface FetchCoinDataSuccessActionType {
-  payload: {
-    balance: string
-    coin: string
-  }
-  type: typeof AT.FETCH_COIN_DATA_SUCCESS
-}
-interface FetchCoinsRatesFailureActionType {
-  payload: {
-    error: string
-  }
-  type: typeof AT.FETCH_COINS_RATES_FAILURE
-}
-interface FetchCoinsRatesLoadingActionType {
-  type: typeof AT.FETCH_COINS_RATES_LOADING
-}
-interface FetchCoinsRatesSuccessActionType {
-  payload: {
-    rates: IndexMultiResponseType
-  }
-  type: typeof AT.FETCH_COINS_RATES_SUCCESS
-}
-interface FetchBtcTickerFailureActionType {
-  payload: {
-    error: string
-  }
-  type: typeof AT.FETCH_BTC_TICKER_FAILURE
-}
-interface FetchBtcTickerLoadingActionType {
-  type: typeof AT.FETCH_BTC_TICKER_LOADING
-}
-interface FetchBtcTickerSuccessActionType {
-  payload: {
-    rates: TickerResponseType
-  }
-  type: typeof AT.FETCH_BTC_TICKER_SUCCESS
-}
-interface FetchTransactionsFailureActionType {
-  payload: {
-    coin: string
-    error: string
-  }
-  type: typeof AT.FETCH_COINS_TRANSACTIONS_FAILURE
-}
-interface FetchTransactionsLoadingActionType {
-  payload: { coin: string; reset: boolean }
-  type: typeof AT.FETCH_COINS_TRANSACTIONS_LOADING
-}
-interface FetchTransactionsSuccessActionType {
-  payload: {
-    coin: string
-    isFinalPage: boolean
-    reset: boolean
-    transactions: CoinsState['transactions']
-  }
-  type: typeof AT.FETCH_COINS_TRANSACTIONS_SUCCESS
-}
-interface PollForCoinDataActionType {
-  type: typeof AT.POLL_FOR_COIN_DATA
-}
-interface SetCoinDataLoadedActionType {
-  type: typeof AT.SET_COIN_DATA_LOADED
-}
-interface SetTransactionsAtBoundActionType {
-  payload: {
-    atBounds: boolean
-    coin: string
-  }
-  type: typeof AT.COINS_TRANSACTIONS_AT_BOUND
-}
-
-export type CoinsActionTypes =
-  | FetchCoinDataFailureActionType
-  | FetchCoinDataLoadingActionType
-  | FetchCoinDataSuccessActionType
-  | FetchCoinsRatesFailureActionType
-  | FetchCoinsRatesLoadingActionType
-  | FetchCoinsRatesSuccessActionType
-  | FetchBtcTickerFailureActionType
-  | FetchBtcTickerLoadingActionType
-  | FetchBtcTickerSuccessActionType
-  | FetchTransactionsFailureActionType
-  | FetchTransactionsLoadingActionType
-  | FetchTransactionsSuccessActionType
-  | PollForCoinDataActionType
-  | SetCoinDataLoadedActionType
-  | SetTransactionsAtBoundActionType
diff --git a/packages/blockchain-wallet-v4/src/redux/data/eth/actions.ts b/packages/blockchain-wallet-v4/src/redux/data/eth/actions.ts
index 586343431ed..7dfd59b5a74 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/eth/actions.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/eth/actions.ts
@@ -1,5 +1,3 @@
-import { AccountTokensBalancesResponseType } from '@core/types'
-
 import * as AT from './actionTypes'
 
 //
@@ -135,26 +133,6 @@ export const checkLowEthBalanceSuccess = (payload) => ({
 // ERC20
 //
 
-// DATA
-export const fetchErc20Data = (coin?: string) => ({
-  payload: {
-    coin
-  },
-  type: AT.FETCH_ERC20_TOKEN_DATA
-})
-export const fetchErc20DataLoading = (token) => ({
-  payload: { token },
-  type: AT.FETCH_ERC20_TOKEN_DATA_LOADING
-})
-export const fetchErc20DataSuccess = (token, data) => ({
-  payload: { data, token },
-  type: AT.FETCH_ERC20_TOKEN_DATA_SUCCESS
-})
-export const fetchErc20DataFailure = (token, error) => ({
-  payload: { error, token },
-  type: AT.FETCH_ERC20_TOKEN_DATA_FAILURE
-})
-
 // TX FEES
 export const fetchErc20TxFee = (hash, token) => ({
   payload: { hash, token },
@@ -234,21 +212,3 @@ export const clearErc20TransactionHistory = (token) => ({
   payload: { token },
   type: AT.CLEAR_ERC20_TRANSACTION_HISTORY
 })
-
-// ERC20s w/ BALANCE
-export const fetchErc20AccountTokenBalances = () => ({
-  type: AT.FETCH_ERC20_ACCOUNT_TOKEN_BALANCES
-})
-export const fetchErc20AccountTokenBalancesLoading = () => ({
-  type: AT.FETCH_ERC20_ACCOUNT_TOKEN_BALANCES_LOADING
-})
-export const fetchErc20AccountTokenBalancesSuccess = (
-  data: AccountTokensBalancesResponseType['tokenAccounts']
-) => ({
-  payload: { data },
-  type: AT.FETCH_ERC20_ACCOUNT_TOKEN_BALANCES_SUCCESS
-})
-export const fetchErc20AccountTokenBalancesFailure = (error) => ({
-  payload: { error },
-  type: AT.FETCH_ERC20_ACCOUNT_TOKEN_BALANCES_FAILURE
-})
diff --git a/packages/blockchain-wallet-v4/src/redux/data/eth/sagaRegister.ts b/packages/blockchain-wallet-v4/src/redux/data/eth/sagaRegister.ts
index e776e6e3225..2b669ec7106 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/eth/sagaRegister.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/eth/sagaRegister.ts
@@ -10,7 +10,6 @@ export default ({ api }) => {
     yield fork(dataEthSagas.watchTransactions)
     yield fork(dataEthSagas.watchErc20Transactions)
     yield takeLatest(AT.FETCH_ETH_DATA, dataEthSagas.fetchData)
-    yield takeEvery(AT.FETCH_ERC20_TOKEN_DATA, dataEthSagas.fetchErc20Data)
     yield takeLatest(
       // @ts-ignore
       AT.FETCH_ETH_TRANSACTION_HISTORY,
@@ -18,7 +17,6 @@ export default ({ api }) => {
     )
     yield takeLatest(AT.FETCH_ETH_LEGACY_BALANCE, dataEthSagas.fetchLegacyBalance)
     yield takeLatest(AT.FETCH_ETH_LATEST_BLOCK, dataEthSagas.fetchLatestBlock)
-    yield takeLatest(AT.CHECK_LOW_ETH_BALANCE, dataEthSagas.checkForLowEthBalance)
     yield takeLatest(AT.FETCH_ERC20_TX_FEE, dataEthSagas.fetchErc20TransactionFee)
     yield takeLatest(AT.FETCH_ERC20_TRANSACTION_HISTORY, dataEthSagas.fetchErc20TransactionHistory)
   }
diff --git a/packages/blockchain-wallet-v4/src/redux/data/eth/sagas.ts b/packages/blockchain-wallet-v4/src/redux/data/eth/sagas.ts
index 1294278d64b..a8d564a4ad8 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/eth/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/eth/sagas.ts
@@ -1,6 +1,5 @@
 import BigNumber from 'bignumber.js'
 import { format, fromUnixTime, getTime, getUnixTime, isAfter, isBefore } from 'date-fns'
-import { Contract } from 'ethers'
 import {
   addIndex,
   equals,
@@ -13,10 +12,9 @@ import {
   path,
   pluck,
   prop,
-  toLower,
   toUpper
 } from 'ramda'
-import { all, call, put, select, take } from 'redux-saga/effects'
+import { call, put, select, take } from 'redux-saga/effects'
 
 import { APIType } from '@core/network/api'
 import { EthRawTxType } from '@core/network/api/eth/types'
@@ -33,7 +31,6 @@ import custodialSagas from '../custodial/sagas'
 import * as A from './actions'
 import * as AT from './actionTypes'
 import * as S from './selectors'
-import { constructDefaultErc20Data } from './utils'
 
 const { transformErc20Tx, transformTx } = transactions.eth
 const TX_PER_PAGE = 50
@@ -43,25 +40,6 @@ const CONTEXT_FAILURE = 'Could not get ETH context.'
 export default ({ api }: { api: APIType }) => {
   const { fetchCustodialOrdersAndTransactions } = custodialSagas({ api })
 
-  //
-  // ETH
-  //
-  const checkForLowEthBalance = function* () {
-    // TODO: ERC20 check for any erc20 balance in future
-    const erc20Balance = (yield select(S.getErc20Balance, 'PAX')).getOrElse(0)
-    const weiBalance = (yield select(S.getBalance)).getOrFail()
-    const ethRates = selectors.data.coins.getRates('ETH', yield select()).getOrFail('No rates')
-    const ethBalance = Exchange.convertCoinToFiat({
-      coin: 'ETH',
-      currency: 'USD',
-      rates: ethRates,
-      value: weiBalance
-    })
-    // less than $1 eth and has PAX, set warning flag to true
-    const showWarning = parseInt(ethBalance) < 1 && erc20Balance > 0
-    yield put(A.checkLowEthBalanceSuccess(showWarning))
-  }
-
   const fetchData = function* () {
     try {
       const context = kvStoreSelectors.getDefaultAddress(yield select()).getOrFail('No ETH address')
@@ -88,12 +66,6 @@ export default ({ api }: { api: APIType }) => {
       }
 
       yield put(A.fetchDataSuccess(ethData))
-      // eslint-disable-next-line
-      try {
-        yield call(checkForLowEthBalance)
-      } catch (e) {
-        // do nothing
-      }
     } catch (e) {
       yield put(A.fetchDataFailure(errorHandler(e)))
     }
@@ -299,93 +271,6 @@ export default ({ api }: { api: APIType }) => {
   //
   // ERC20
   //
-  const fetchErc20Data = function* (action: ReturnType<typeof A.fetchErc20Data>) {
-    const { coin } = action.payload
-    try {
-      const ethAddr = (yield select(kvStoreSelectors.getDefaultAddress)).getOrFail(
-        'No Default ETH Address.'
-      )
-      const data: ReturnType<typeof api.getAccountTokensBalances> = yield call(
-        api.getAccountTokensBalances,
-        ethAddr
-      )
-      yield all(
-        data.tokenAccounts.map(function* (val) {
-          const symbol = Object.keys(window.coins).find(
-            (coin: string) =>
-              window.coins[coin].coinfig.type?.erc20Address?.toLowerCase() ===
-              toLower(val.tokenHash)
-          )
-          if (!symbol) return
-          if (symbol === 'WETH') return
-          const { coinfig } = window.coins[symbol]
-          const contract = coinfig.type.erc20Address
-          const tokenData = data.tokenAccounts.find(
-            ({ tokenHash }) => toLower(tokenHash) === toLower(contract as string)
-          )
-          if (!contract) return
-
-          yield put(
-            A.fetchErc20DataSuccess(
-              symbol,
-              tokenData || constructDefaultErc20Data(ethAddr, contract, symbol)
-            )
-          )
-        })
-      )
-
-      yield put(
-        A.fetchErc20AccountTokenBalancesSuccess(
-          [...data.tokenAccounts.filter(({ tokenSymbol }) => tokenSymbol !== 'WETH')].sort((a, b) =>
-            a.balance < b.balance ? -1 : 1
-          )
-        )
-      )
-
-      try {
-        // Because there is a discrepancy between /eth/v2/<addr>/tokens
-        // and on chain data
-        const wethAddr = window.coins.WETH.coinfig.type.erc20Address || ''
-        const wethAbi = [
-          {
-            constant: true,
-            inputs: [
-              {
-                name: '_owner',
-                type: 'address'
-              }
-            ],
-            name: 'balanceOf',
-            outputs: [
-              {
-                name: 'balance',
-                type: 'uint256'
-              }
-            ],
-            payable: false,
-            type: 'function'
-          }
-        ]
-        const contract = new Contract(wethAddr, wethAbi, api.ethProvider)
-        const balance = yield call(contract.balanceOf, ethAddr)
-        const balanceString = balance.toString()
-        const wethTokenData = constructDefaultErc20Data(ethAddr, wethAddr, 'WETH', balanceString)
-        yield put(A.fetchErc20DataSuccess('WETH', wethTokenData))
-        yield put(
-          A.fetchErc20AccountTokenBalancesSuccess(
-            [
-              ...data.tokenAccounts.filter(({ tokenSymbol }) => tokenSymbol !== 'WETH'),
-              wethTokenData
-            ].sort((a, b) => (a.balance < b.balance ? -1 : 1))
-          )
-        )
-      } catch (e) {
-        // maybe an issue with rpc call, don't throw so balances still load
-      }
-    } catch (e) {
-      yield put(A.fetchErc20DataFailure(coin, prop('message', e)))
-    }
-  }
 
   const watchErc20Transactions = function* () {
     while (true) {
@@ -623,9 +508,7 @@ export default ({ api }: { api: APIType }) => {
   return {
     __processErc20Txs,
     __processTxs,
-    checkForLowEthBalance,
     fetchData,
-    fetchErc20Data,
     fetchErc20TransactionFee,
     fetchErc20TransactionHistory,
     fetchErc20Transactions,
diff --git a/packages/blockchain-wallet-v4/src/redux/data/eth/selectors.js b/packages/blockchain-wallet-v4/src/redux/data/eth/selectors.ts
similarity index 86%
rename from packages/blockchain-wallet-v4/src/redux/data/eth/selectors.js
rename to packages/blockchain-wallet-v4/src/redux/data/eth/selectors.ts
index b0514916e10..1e2c2ac7750 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/eth/selectors.js
+++ b/packages/blockchain-wallet-v4/src/redux/data/eth/selectors.ts
@@ -11,15 +11,20 @@ import { dataPath } from '../../paths'
 export const getContext = createDeepEqualSelector(
   [kvStoreSelectors.getContext],
   (walletContextR) => {
+    // @ts-ignore
     return walletContextR.map((x) => x).getOrElse([])
   }
 )
 export const getAddresses = path([dataPath, 'eth', 'addresses'])
 export const getLatestBlock = path([dataPath, 'eth', 'latest_block'])
 export const getFee = path([dataPath, 'eth', 'fee'])
+// @ts-ignore
 export const getFeeRegular = (state) => getFee(state).map(prop('regular'))
+// @ts-ignore
 export const getFeePriority = (state) => getFee(state).map(prop('priority'))
+// @ts-ignore
 export const getGasLimit = (state) => getFee(state).map(prop('gasLimit'))
+// @ts-ignore
 export const getAddress = (state, address) => getAddresses(state).map(prop(address))
 export const getDefaultAddressBalance = (state) => {
   const defaultAddr = kvStoreSelectors
@@ -29,11 +34,14 @@ export const getDefaultAddressBalance = (state) => {
   return getAddress(state, defaultAddr).map(prop('balance'))
 }
 export const getLegacyBalance = path([dataPath, 'eth', 'legacy_balance'])
+// @ts-ignore
 export const getHeight = (state) => getLatestBlock(state).map(path(['number']))
+// @ts-ignore
 export const getNonce = (state, address) => getAddresses(state).map(path([address, 'nonce']))
 
 export const getBalance = (state) => {
   const ethData = path([dataPath, 'eth', 'info', 'eth'])(state)
+  // @ts-ignore
   return ethData ? ethData.map(prop('final_balance')) : Remote.NotAsked
 }
 export const getCurrentBalance = () => path([dataPath, 'eth', 'current_balance', 'eth'])
@@ -43,17 +51,6 @@ export const getLowEthBalanceWarning = () => path([dataPath, 'eth', 'warn_low_et
 
 export const getTransactionHistory = path([dataPath, 'eth', 'transaction_history', 'eth'])
 
-//
-// ERC20
-//
-export const getErc20Balance = (state, token) => {
-  const tokenData = path([dataPath, 'eth', 'info', token])(state)
-  return tokenData
-    ? tokenData.map(prop('balance'))
-    : // TODO: erc20 phase 2, default to Remote.NotAsked
-      // Remote.NotAsked
-      Remote.Success('0')
-}
 export const getErc20CurrentBalance = (state, token) => {
   return path([dataPath, 'eth', 'current_balance', token])(state) || Remote.NotAsked
 }
@@ -66,6 +63,3 @@ export const getErc20TransactionsAtBound = (state, token) => {
 export const getErc20TransactionHistory = (state, token) => {
   return path([dataPath, 'eth', 'transaction_history', token])(state) || Remote.NotAsked
 }
-export const getErc20AccountTokenBalances = (state) => {
-  return state.dataPath.eth.erc20s
-}
diff --git a/packages/blockchain-wallet-v4/src/redux/data/reducers.ts b/packages/blockchain-wallet-v4/src/redux/data/reducers.ts
index 9c814aec3fa..6b3e8f28055 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/reducers.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/reducers.ts
@@ -2,7 +2,7 @@ import { combineReducers } from 'redux'
 
 import bch from './bch/reducers'
 import btc from './btc/reducers'
-import { coinsReducer } from './coins/reducers'
+import { coinsReducer } from './coins/slice'
 import { custodialReducer } from './custodial/reducers'
 import eth from './eth/reducers'
 import { fiatReducer } from './fiat/reducers'
diff --git a/packages/blockchain-wallet-v4/src/redux/data/self-custody/sagas.ts b/packages/blockchain-wallet-v4/src/redux/data/self-custody/sagas.ts
index 13f523d2d49..37c7c776deb 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/self-custody/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/self-custody/sagas.ts
@@ -6,6 +6,22 @@ import * as selectors from '../../selectors'
 
 const taskToPromise = (t) => new Promise((resolve, reject) => t.fork(reject, resolve))
 
+// this should ideally come from a backend service
+// if we want to expand the functionality of
+// the pubkey service for building transactions
+// we need to know the correct derivation paths
+// for each coin that the service supports.
+const getPath = (coin) => {
+  if (coin.includes('MATIC')) {
+    return `m/44'/60'/0'/0/0`
+  }
+  if (coin === 'STX') {
+    return `m/44'/5757'/0'/0/0`
+  }
+
+  throw new Error('Could not get path for coin.')
+}
+
 export const getSeed = function* (password?: string) {
   const getMnemonic = (state) => selectors.wallet.getMnemonic(state, password)
   const mnemonicT = yield select(getMnemonic)
@@ -16,19 +32,26 @@ export const getSeed = function* (password?: string) {
   return seed
 }
 
-export const getPubKey = function* (password?: string) {
+export const getMnemonic = function* (password?: string) {
+  const getMnemonic = (state) => selectors.wallet.getMnemonic(state, password)
+  const mnemonicT = yield select(getMnemonic)
+  // // @ts-ignore
+  const mnemonic = yield call(() => taskToPromise(mnemonicT))
+
+  return mnemonic
+}
+
+export const getPubKey = function* (coin: string, password?: string) {
   const seed = yield call(getSeed, password)
-  // TODO: SELF_CUSTODY
-  const { publicKey } = Bitcoin.bip32.fromSeed(seed).derivePath(`m/44'/5757'/0'/0/0`)
+  const { publicKey } = Bitcoin.bip32.fromSeed(seed).derivePath(getPath(coin))
   const pubkey = publicKey.toString('hex')
 
   return pubkey
 }
 
-export const getPrivKey = function* (password?: string) {
+export const getPrivKey = function* (coin: string, password?: string) {
   const seed = yield call(getSeed, password)
-  // TODO: SELF_CUSTODY
-  const { privateKey } = Bitcoin.bip32.fromSeed(seed).derivePath(`m/44'/5757'/0'/0/0`)
+  const { privateKey } = Bitcoin.bip32.fromSeed(seed).derivePath(getPath(coin))
   const privkey = privateKey?.toString('hex')
 
   return privkey
diff --git a/packages/blockchain-wallet-v4/src/redux/data/xlm/sagaRegister.js b/packages/blockchain-wallet-v4/src/redux/data/xlm/sagaRegister.js
index 2472d58f178..c6ddd75f2aa 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/xlm/sagaRegister.js
+++ b/packages/blockchain-wallet-v4/src/redux/data/xlm/sagaRegister.js
@@ -8,7 +8,6 @@ export default ({ api, networks }) => {
 
   return function* coreDataXlmSaga() {
     yield takeLatest(AT.FETCH_LEDGER_DETAILS, dataXlmSagas.fetchLedgerDetails)
-    yield takeLatest(AT.FETCH_DATA, dataXlmSagas.fetchData)
     yield takeEvery(AT.FETCH_TRANSACTIONS, dataXlmSagas.fetchTransactions)
     yield takeLatest(AT.FETCH_TRANSACTION_HISTORY, dataXlmSagas.fetchTransactionHistory)
   }
diff --git a/packages/blockchain-wallet-v4/src/redux/data/xlm/sagas.ts b/packages/blockchain-wallet-v4/src/redux/data/xlm/sagas.ts
index 4df6fc0ba72..fad7f5b76a7 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/xlm/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/data/xlm/sagas.ts
@@ -16,10 +16,9 @@ import {
   prop,
   reduce,
   takeLast,
-  unnest,
-  values
+  unnest
 } from 'ramda'
-import { all, call, put, select } from 'redux-saga/effects'
+import { call, put, select } from 'redux-saga/effects'
 
 import { APIType } from '@core/network/api'
 import { XlmTxType } from '@core/transactions/types'
@@ -46,14 +45,6 @@ export const sumBigNumbers = reduce(
   '0'
 )
 
-const sumBalance = compose(
-  sumBigNumbers,
-  // @ts-ignore
-  map((account) => account.map(S.selectBalanceFromAccount).getOrElse('0')),
-  // @ts-ignore
-  values
-)
-
 export default ({ api, networks }: { api: APIType; networks: any }) => {
   const { fetchCustodialOrdersAndTransactions } = buySellSagas({ api })
 
@@ -67,36 +58,6 @@ export default ({ api, networks }: { api: APIType; networks: any }) => {
     }
   }
 
-  const fetchAccount = function* (id) {
-    try {
-      yield put(A.fetchAccountLoading(id))
-      const account = yield call(api.getXlmAccount, id)
-      yield put(A.fetchAccountSuccess(id, account))
-    } catch (e) {
-      yield put(A.fetchAccountFailure(id, e))
-    }
-  }
-
-  const fetchData = function* () {
-    const accountIds = yield select(S.getContext)
-    yield all(accountIds.map((id) => call(fetchAccount, id)))
-    const accounts = yield select(S.getAccounts)
-    // @ts-ignore
-    const data = { info: { final_balance: sumBalance(accounts) } }
-    yield put(A.fetchDataSuccess(data))
-  }
-
-  const createAccounts = function* () {
-    if (networks.xlm !== 'testnet') return
-    try {
-      const accountIds = yield select(S.getContext)
-      yield all(accountIds.map((id) => call(api.createXlmAccount, id)))
-      yield call(fetchData)
-    } catch (e) {
-      // some catch
-    }
-  }
-
   const __processTxs = function* (txList) {
     const walletAccounts = (yield select(getAccounts)).getOrElse([])
     const txNotes = (yield select(getXlmTxNotes)).getOrElse({})
@@ -279,8 +240,6 @@ export default ({ api, networks }: { api: APIType; networks: any }) => {
 
   return {
     __processTxs,
-    createAccounts,
-    fetchData,
     fetchLedgerDetails,
     fetchTransactionHistory,
     fetchTransactions
diff --git a/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.js b/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.js
index 7e23b3704da..8afbed59359 100755
--- a/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.js
+++ b/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.js
@@ -1,6 +1,5 @@
-import { compose, curry, find, lift, map, path, prop, propEq, propOr, sum, uniq } from 'ramda'
+import { compose, curry, find, lift, path, prop, propEq, propOr, uniq } from 'ramda'
 
-import * as Exchange from '../../../exchange'
 import Remote from '../../../remote'
 import { createDeepEqualSelector } from '../../../utils'
 import * as kvStoreSelectors from '../../kvStore/xlm/selectors'
@@ -30,36 +29,15 @@ export const getHeight = compose(lift(prop('sequence')), getLedgerDetails)
 
 export const getNumberOfEntries = curry(compose(lift(prop('subentry_count')), getAccount))
 
-export const selectBalanceFromAccount = compose(
-  prop('balance'),
-  find(propEq('asset_type', 'native')),
-  propOr([], 'balances')
-)
-
-export const getAccountBalance = compose(lift(selectBalanceFromAccount), getAccount)
-
-const calculateBalance = (balance) =>
-  Exchange.convertCoinToCoin({
-    baseToStandard: false,
-    coin: 'XLM',
-    value: balance
-  })
-
-export const getBalance = curry((state, accountId) =>
-  compose(lift(compose(calculateBalance, selectBalanceFromAccount)), getAccount)(accountId, state)
-)
-
-export const getTotalBalance = (state) =>
-  compose(
-    Remote.of,
-    sum,
-    map((accountId) => getBalance(state, accountId).getOrElse(0)),
-    getContext
-  )(state)
-
 export const getTransactionsAtBound = path([dataPath, 'xlm', 'transactions_at_bound'])
 
 export const getTransactions = path([dataPath, 'xlm', 'transactions'])
 export const getOperations = path([dataPath, 'xlm', 'operations'])
 
 export const getTransactionHistory = path([dataPath, 'xlm', 'transaction_history'])
+
+export const selectBalanceFromAccount = compose(
+  prop('balance'),
+  find(propEq('asset_type', 'native')),
+  propOr([], 'balances')
+)
diff --git a/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.spec.js b/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.spec.js
index f159fefb000..de9d6f18129 100644
--- a/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.spec.js
+++ b/packages/blockchain-wallet-v4/src/redux/data/xlm/selectors.spec.js
@@ -2,15 +2,12 @@ import { Remote } from '@core'
 
 import { XLM } from '../../kvStore/config'
 import { dataPath, kvStorePath } from '../../paths'
-import { getBalance, getContext, getTotalBalance } from './selectors'
+import { getContext } from './selectors'
 
 const id1 = 'GDXM5GK655MW2LGM6RV5DAYPO6U6RQ5KHR5Z43KBZAE265WGZGNFCD75'
 const id2 = 'GAIVP73R2Z7F6XIAUH7L6M2U4BCOMHILYNPAJYQBJYA5K87LQIJD6DSP'
-const id3 = 'GAIVP73R2Z7F6XIAUH7L6M2U4BCOMHILYNPAJYQBJYA5K87LQIJD6DSL'
 const balance1 = '2.9999999'
-const balance1Stroops = '29999999'
 const balance2 = '2.0000001'
-const totalBalanceStroopsNumber = 29999999
 const state = {
   [dataPath]: {
     xlm: {
@@ -51,21 +48,6 @@ const state = {
   }
 }
 
-describe('getBalance', () => {
-  it('should get xlm account native balance in stroops by id', () => {
-    expect(getBalance(state)(id1)).toEqual(Remote.of(balance1Stroops))
-  })
-  it('should return Remote.NotAsked if account was not found', () => {
-    expect(getBalance(state)(id3)).toEqual(Remote.NotAsked)
-  })
-})
-
-describe('getTotalBalance', () => {
-  it('should get sum balance for all unique accounts in stroops as number', () => {
-    expect(getTotalBalance(state)).toEqual(Remote.of(totalBalanceStroopsNumber))
-  })
-})
-
 describe('getContext', () => {
   it('should get all unique wallet accounts', () => {
     expect(getContext(state)).toEqual([id1])
diff --git a/packages/blockchain-wallet-v4/src/redux/payment/eth/sagas.ts b/packages/blockchain-wallet-v4/src/redux/payment/eth/sagas.ts
index 4cf2d8e82b2..25e381d4636 100755
--- a/packages/blockchain-wallet-v4/src/redux/payment/eth/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/payment/eth/sagas.ts
@@ -225,7 +225,6 @@ export default ({ api }: { api: APIType }) => {
             ? path(['fees', 'gasLimitContract'], p)
             : path(['fees', 'gasLimit'], p)
         const fee = calculateFee(feeInGwei, gasLimit as string, true, extraGasForMemo)
-        const isSufficientEthForErc20 = yield call(calculateIsSufficientEthForErc20, fee)
 
         const data = p.isErc20
           ? yield call(api.getErc20AccountSummaryV2, account, contract)
@@ -240,8 +239,7 @@ export default ({ api }: { api: APIType }) => {
           mergeRight(p, {
             effectiveBalance,
             fee,
-            feeInGwei,
-            isSufficientEthForErc20
+            feeInGwei
           })
         )
       },
@@ -268,7 +266,9 @@ export default ({ api }: { api: APIType }) => {
           const ethData = yield call(api.getEthBalances, account)
           const nonce = path([account, 'nonce'], ethData)
           const balance = p.isErc20
-            ? (yield select(S.data.eth.getErc20Balance, p.coin)).getOrFail('missing_erc20_balance')
+            ? S.data.coins
+                .getCoinUnifiedBalance(p.coin)(yield select())
+                .getOrFail('missing_balance')
             : path([account, 'balance'], ethData)
 
           effectiveBalance = calculateEffectiveBalance(balance, prop('fee', p), prop('isErc20', p))
@@ -298,7 +298,6 @@ export default ({ api }: { api: APIType }) => {
         const gasPrice = prop('regular', fees)
         const gasLimit = isErc20 ? prop('gasLimitContract', fees) : prop('gasLimit', fees)
         const fee = calculateFee(gasPrice, gasLimit, true)
-        const isSufficientEthForErc20 = yield call(calculateIsSufficientEthForErc20, fee)
 
         return makePayment(
           mergeRight(p, {
@@ -306,8 +305,7 @@ export default ({ api }: { api: APIType }) => {
             fee,
             feeInGwei: gasPrice,
             fees,
-            isErc20,
-            isSufficientEthForErc20
+            isErc20
           })
         )
       },
diff --git a/packages/blockchain-wallet-v4/src/redux/payment/types.ts b/packages/blockchain-wallet-v4/src/redux/payment/types.ts
index 10d4deee114..7976ce56166 100644
--- a/packages/blockchain-wallet-v4/src/redux/payment/types.ts
+++ b/packages/blockchain-wallet-v4/src/redux/payment/types.ts
@@ -54,7 +54,6 @@ type EthPaymentValue = IPaymentValue & {
     type: AddressTypesType
   }
   isRetryAttempt: boolean | undefined
-  isSufficientEthForErc20: boolean
   minFee?: string
   to?: EthAccountFromType | EthAddressFromType
   txId?: string
diff --git a/packages/blockchain-wallet-v4/src/redux/payment/xlm/sagas.ts b/packages/blockchain-wallet-v4/src/redux/payment/xlm/sagas.ts
index 380a2bf8d1b..39bbb448ee3 100755
--- a/packages/blockchain-wallet-v4/src/redux/payment/xlm/sagas.ts
+++ b/packages/blockchain-wallet-v4/src/redux/payment/xlm/sagas.ts
@@ -98,30 +98,32 @@ export default ({ api }) => {
   }
 
   const getReserve = function* (accountId) {
-    const baseReserve = (yield select(S.data.xlm.getBaseReserve)).getOrFail(
-      new Error(NO_LEDGER_ERROR)
-    )
-    const entriesNumber = (yield select(S.data.xlm.getNumberOfEntries(accountId))).getOrFail(
-      new Error(NO_ACCOUNT_ERROR)
-    )
-    return yield call(calculateReserve, baseReserve, entriesNumber)
+    try {
+      const baseReserve = (yield select(S.data.xlm.getBaseReserve)).getOrFail(
+        new Error(NO_LEDGER_ERROR)
+      )
+      const account = yield call(api.getXlmAccount, accountId)
+      const entriesNumber = account.subentry_count
+      return yield call(calculateReserve, baseReserve, entriesNumber)
+    } catch (e) {
+      throw new Error(NO_ACCOUNT_ERROR)
+    }
   }
 
   const getEffectiveBalance = function* (accountId, fee, reserve) {
-    const balance = (yield select(S.data.xlm.getBalance))(accountId).getOrFail(
-      new Error(NO_ACCOUNT_ERROR)
-    )
+    const balance = S.data.coins
+      .getCoinUnifiedBalance('XLM')(yield select())
+      .getOrFail(new Error(NO_ACCOUNT_ERROR))
 
     return calculateEffectiveBalance(balance, fee, reserve)
   }
 
   // Required when *build is called more than once on a payment
-  const getAccountAndSequenceNumber = function* (account) {
+  const getAccountAndSequenceNumber = function* (accountId: string) {
     try {
-      const { id } = account
-      const data = yield call(api.getXlmAccount, id)
+      const data = yield call(api.getXlmAccount, accountId)
       const { sequence } = data
-      return new Account(id, sequence)
+      return new Account(accountId, sequence)
     } catch (e) {
       throw new Error(e)
     }
@@ -142,18 +144,17 @@ export default ({ api }) => {
 
       *build() {
         const fromData = prop('from', p)
+        const address = prop('address', fromData)
         const to = path(['to', 'address'], p)
         const amount = prop('amount', p)
         const fee = prop('fee', p)
         const destinationAccountExists = prop('destinationAccountExists', p)
         const memo = prop('memo', p)
         const memoType = prop('memoType', p)
-        let account = prop('account', fromData)
         if (fromData.type === 'CUSTODIAL') return makePayment(p)
-        if (!account) throw new Error(NO_SOURCE_ERROR)
         if (!to) throw new Error(NO_DESTINATION_ERROR)
         if (!amount) throw new Error(NO_AMOUNT_ERROR)
-        account = yield call(getAccountAndSequenceNumber, account)
+        const account = yield call(getAccountAndSequenceNumber, address)
         const timeout = (yield select(S.walletOptions.getXlmSendTimeOutSeconds)).getOrElse(300)
         const timebounds = yield call(api.getTimebounds, timeout)
         const txBuilder = new TransactionBuilder(account, {
@@ -236,15 +237,11 @@ export default ({ api }) => {
           (yield select(S.kvStore.xlm.getDefaultAccountId)).getOrFail(
             new Error(NO_DEFAULT_ACCOUNT_ERROR)
           )
-        const account = (yield select(S.data.xlm.getAccount(accountId))).getOrFail(
-          new Error(NO_ACCOUNT_ERROR)
-        )
         const fromType = type || ADDRESS_TYPES.ACCOUNT
 
         if (!contains(fromType, values(ADDRESS_TYPES))) throw new Error(INVALID_ADDRESS_TYPE_ERROR)
 
         from = {
-          account,
           address: accountId,
           type: fromType
         }
diff --git a/packages/blockchain-wallet-v4/src/types/index.ts b/packages/blockchain-wallet-v4/src/types/index.ts
index 844db1dbbd8..b240e0244e6 100755
--- a/packages/blockchain-wallet-v4/src/types/index.ts
+++ b/packages/blockchain-wallet-v4/src/types/index.ts
@@ -100,7 +100,7 @@ export type BtcAccountType = {
   type: 'ACCOUNT' | 'CUSTODIAL'
   xpub: string
 }
-
+// TODO: change all this from to defi/account
 export enum WalletAccountEnum {
   CUSTODIAL = 'CUSTODIAL',
   NON_CUSTODIAL = 'NON_CUSTODIAL'
@@ -108,6 +108,14 @@ export enum WalletAccountEnum {
 
 export type WalletAccountType = keyof typeof WalletAccountEnum
 
+// TODO: Placeholder account types, we'll change above
+export enum WalletAccountSuperAppEnum {
+  ACCOUNT = 'ACCOUNT',
+  DEFI = 'DEFI'
+}
+
+export type WalletAccountSuperAppType = keyof typeof WalletAccountSuperAppEnum
+
 export type HDDerivationType = 'bech32' | 'legacy'
 
 export type AccountTypes = BtcAccountType
diff --git a/tsconfig.json b/tsconfig.json
index d5da344bd5c..b7a34c3558c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -15,6 +15,7 @@
     "sourceMap": true,
     "strict": true,
     "strictNullChecks": true,
+    "strictPropertyInitialization": false,
     "target": "es6",
     "useUnknownInCatchVariables": false,
     "paths": {