diff --git a/src/composables/fungibleTokens.ts b/src/composables/fungibleTokens.ts
new file mode 100644
index 000000000..673a22cae
--- /dev/null
+++ b/src/composables/fungibleTokens.ts
@@ -0,0 +1,317 @@
+import { watch } from 'vue';
+import camelCaseKeysDeep from 'camelcase-keys-deep';
+import BigNumber from 'bignumber.js';
+import { Encoded, Encoding } from '@aeternity/aepp-sdk';
+import { fetchAllPages, handleUnknownError, toShiftedBigNumber } from '@/utils';
+import type {
+  BigNumberPublic,
+  IDefaultComposableOptions,
+  IToken,
+  ITokenBalanceResponse,
+  ITokenList,
+  ITransaction,
+  TokenPair,
+} from '@/types';
+import { PROTOCOL_AETERNITY, STORAGE_KEYS, TX_DIRECTION } from '@/constants';
+import FungibleTokenFullInterfaceACI from '@/lib/contracts/FungibleTokenFullInterfaceACI.json';
+import AedexV2PairACI from '@/lib/contracts/AedexV2PairACI.json';
+import ZeitTokenACI from '@/lib/contracts/FungibleTokenFullACI.json';
+
+import { aettosToAe, calculateSupplyAmount, categorizeContractCallTxObject } from '@/protocols/aeternity/helpers';
+import { AE_SYMBOL } from '@/protocols/aeternity/config';
+
+import { useAccounts } from './accounts';
+import { useAeSdk } from './aeSdk';
+import { useMiddleware } from './middleware';
+import { useTippingContracts } from './tippingContracts';
+import { createNetworkWatcher } from './networks';
+import { createPollingBasedOnMountedComponents } from './composablesHelpers';
+import { useStorageRef } from './storageRef';
+
+/**
+ * List of all custom tokens available (currently only AE network).
+ * As this list is quite big (hundreds of items) it requires processing optimizations.
+ */
+const availableTokens = useStorageRef<ITokenList>(
+  {},
+  STORAGE_KEYS.fungibleTokenList,
+);
+
+/**
+ * List of tokens (assets) owned by active account with the balance value
+ */
+const tokenBalances = useStorageRef<Record<string, IToken[]>>(
+  {},
+  STORAGE_KEYS.fungibleTokenBalances,
+);
+
+const { onNetworkChange } = createNetworkWatcher();
+const availableTokensPooling = createPollingBasedOnMountedComponents(60000);
+const tokenBalancesPooling = createPollingBasedOnMountedComponents(10000);
+
+export function useFungibleTokens({ store }: IDefaultComposableOptions) {
+  const { getAeSdk } = useAeSdk({ store });
+  const { fetchFromMiddleware } = useMiddleware();
+  const { tippingContractAddresses } = useTippingContracts({ store });
+  const {
+    isLoggedIn,
+    aeAccounts,
+    getLastActiveProtocolAccount,
+  } = useAccounts();
+
+  function getAccountTokenBalances(address?: string): IToken[] {
+    const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
+    return tokenBalances.value[address || account?.address!] || [];
+  }
+
+  async function loadAvailableTokens() {
+    const response: IToken[] = camelCaseKeysDeep(await fetchAllPages(
+      () => fetchFromMiddleware('/v2/aex9?by=name&limit=100&direction=forward'),
+      fetchFromMiddleware,
+    ));
+
+    if (!response.length) {
+      availableTokens.value = {};
+    }
+
+    availableTokens.value = response.reduce((accumulator, token) => {
+      // eslint-disable-next-line no-param-reassign
+      accumulator[token.contractId] = token;
+      return accumulator;
+    }, {} as ITokenList);
+  }
+
+  async function loadTokenBalances() {
+    if (!isLoggedIn.value) {
+      return;
+    }
+    const addresses = aeAccounts.value.map((account) => account.address);
+
+    await Promise.all(addresses.map(async (address) => {
+      try {
+        const tokens: ITokenBalanceResponse[] = camelCaseKeysDeep(await fetchAllPages(
+          () => fetchFromMiddleware(`/v2/aex9/account-balances/${address}?limit=100`),
+          fetchFromMiddleware,
+        ));
+        if (!tokens.length) {
+          return;
+        }
+
+        tokenBalances.value[address] = tokens
+          .filter(({ contractId }) => availableTokens.value[contractId])
+          .map(({ amount, contractId }): IToken => {
+            const availableToken = availableTokens.value[contractId];
+            const balance = toShiftedBigNumber(amount!, -availableToken.decimals);
+            const convertedBalance = Number(balance.toFixed(2));
+
+            return {
+              ...availableToken, // TODO store the balance and amount separately from asset data
+              amount,
+              convertedBalance,
+            };
+          });
+      } catch (error) {
+        handleUnknownError(error);
+      }
+    }));
+  }
+
+  async function createOrChangeAllowance(contractId: string, amount: number | string) {
+    const aeSdk = await getAeSdk();
+    const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
+    const selectedToken = tokenBalances.value?.[account?.address!]
+      ?.find((token) => token?.contractId === contractId);
+
+    const tokenContract = await aeSdk.initializeContract({
+      aci: FungibleTokenFullInterfaceACI,
+      address: selectedToken?.contractId as any,
+    });
+
+    const { decodedResult } = await tokenContract.allowance({
+      from_account: account?.address,
+      for_account: tippingContractAddresses?.value?.tippingV2?.replace('ct_', 'ak_'),
+    });
+
+    const allowanceAmount = (decodedResult !== undefined)
+      ? new BigNumber(decodedResult)
+        .multipliedBy(-1)
+        .plus(toShiftedBigNumber(amount, selectedToken?.decimals!))
+        .toNumber()
+      : toShiftedBigNumber(amount, selectedToken?.decimals!)
+        .toNumber();
+
+    const getContractFunction = (tokenContract.methods as any)[
+      decodedResult !== undefined ? 'change_allowance' : 'create_allowance'
+    ];
+
+    return getContractFunction(
+      tippingContractAddresses.value?.tippingV2?.replace(
+        `${Encoding.ContractAddress}_`,
+        `${Encoding.AccountAddress}_`,
+      ),
+      allowanceAmount,
+    );
+  }
+
+  async function getContractTokenPairs(
+    address: Encoded.ContractAddress,
+  ): Promise<Partial<TokenPair> & Record<string, any>> {
+    try {
+      const aeSdk = await getAeSdk();
+      const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
+      const tokenContract = await aeSdk.initializeContract({
+        aci: AedexV2PairACI,
+        address,
+      });
+
+      const [
+        { decodedResult: balances },
+        { decodedResult: balance },
+        { decodedResult: token0 },
+        { decodedResult: token1 },
+        { decodedResult: reserves },
+        { decodedResult: totalSupply },
+      ] = await Promise.all([
+        tokenContract.balances(),
+        tokenContract.balance(account?.address),
+        tokenContract.token0(),
+        tokenContract.token1(),
+        tokenContract.get_reserves(),
+        tokenContract.total_supply(),
+      ]);
+
+      return {
+        token0: {
+          ...availableTokens.value?.[token0],
+          amount: calculateSupplyAmount(
+            balance,
+            totalSupply,
+            reserves.reserve0,
+          ),
+        },
+        token1: {
+          ...availableTokens.value?.[token1],
+          amount: calculateSupplyAmount(
+            balance,
+            totalSupply,
+            reserves.reserve1,
+          ),
+        },
+        totalSupply,
+        balance,
+        balances,
+      };
+    } catch (error) {
+      return {};
+    }
+  }
+
+  async function transferToken(
+    tokenContractId: Encoded.ContractAddress,
+    toAccount: Encoded.AccountAddress,
+    amount: number,
+    option: {
+      waitMined: boolean,
+      modal: boolean,
+    },
+  ) {
+    const aeSdk = await getAeSdk();
+    const tokenContract = await aeSdk.initializeContract({
+      aci: FungibleTokenFullInterfaceACI,
+      address: tokenContractId,
+    });
+    return tokenContract.transfer(toAccount, amount.toFixed(), option);
+  }
+
+  async function burnTriggerPoS(
+    address: Encoded.ContractAddress,
+    posAddress: string,
+    invoiceId: string,
+    amount: number,
+    option: {
+      waitMined: boolean,
+      modal: boolean,
+    },
+  ) {
+    const aeSdk = await getAeSdk();
+    const tokenContract = await aeSdk.initializeContract({
+      aci: ZeitTokenACI,
+      address,
+    });
+    return tokenContract.burn_trigger_pos(
+      amount.toFixed(),
+      posAddress,
+      invoiceId,
+      option,
+    );
+  }
+
+  function getTxSymbol(transaction?: ITransaction) {
+    if (transaction?.pendingTokenTx) {
+      return availableTokens.value[transaction.tx.contractId]?.symbol;
+    }
+    const contractCallData = transaction?.tx && categorizeContractCallTxObject(transaction);
+    return availableTokens.value[contractCallData?.token!]?.symbol || AE_SYMBOL;
+  }
+
+  function getTxAmountTotal(
+    transaction: ITransaction,
+    direction: string = TX_DIRECTION.sent,
+  ) {
+    const contractCallData = transaction.tx && categorizeContractCallTxObject(transaction);
+    if (contractCallData && availableTokens.value[contractCallData.token!]) {
+      return +toShiftedBigNumber(
+        contractCallData.amount || 0,
+        -availableTokens.value[contractCallData.token!].decimals,
+      );
+    }
+    const isReceived = direction === TX_DIRECTION.received;
+
+    const rawAmount = (
+      transaction.tx?.amount
+      || (transaction.tx?.tx?.tx as any)?.amount
+      || transaction.tx?.nameFee
+      || 0
+    );
+
+    const amount: BigNumberPublic = (typeof rawAmount === 'object')
+      ? rawAmount
+      : new BigNumber(Number(rawAmount));
+
+    return +aettosToAe(amount
+      .plus(isReceived ? 0 : transaction.tx?.fee || 0)
+      .plus(isReceived ? 0 : transaction.tx?.tx?.tx?.fee || 0));
+  }
+
+  onNetworkChange(async (network, oldNetwork) => {
+    const newMiddlewareUrl = network.protocols[PROTOCOL_AETERNITY].middlewareUrl;
+    const oldMiddlewareUrl = oldNetwork?.protocols?.[PROTOCOL_AETERNITY]?.middlewareUrl;
+    if (newMiddlewareUrl !== oldMiddlewareUrl) {
+      await loadAvailableTokens();
+      await loadTokenBalances();
+    }
+  });
+
+  watch(aeAccounts, (val, oldVal) => {
+    if (val !== oldVal) {
+      loadTokenBalances();
+    }
+  });
+
+  availableTokensPooling(() => loadAvailableTokens());
+  tokenBalancesPooling(() => loadTokenBalances());
+
+  return {
+    availableTokens,
+    tokenBalances,
+    burnTriggerPoS,
+    createOrChangeAllowance,
+    getAccountTokenBalances,
+    getContractTokenPairs,
+    getTxSymbol,
+    getTxAmountTotal,
+    transferToken,
+    loadTokenBalances,
+    loadAvailableTokens,
+  };
+}
diff --git a/src/composables/index.ts b/src/composables/index.ts
index 43d3cd62a..c36f09e8b 100644
--- a/src/composables/index.ts
+++ b/src/composables/index.ts
@@ -27,6 +27,7 @@ export * from './transactionTokens';
 export * from './transactionList';
 export * from './ui';
 export * from './viewport';
+export * from './fungibleTokens';
 export * from './coinTokensProps';
 export * from './scrollTransactions';
 export * from './languages';
diff --git a/src/composables/latestTransactionList.ts b/src/composables/latestTransactionList.ts
index 6a3cdf8fc..fbb8710aa 100644
--- a/src/composables/latestTransactionList.ts
+++ b/src/composables/latestTransactionList.ts
@@ -15,6 +15,7 @@ import {
 } from '@/utils';
 import { ProtocolAdapterFactory } from '@/lib/ProtocolAdapterFactory';
 import { AE_MDW_TO_NODE_APPROX_DELAY_TIME } from '@/protocols/aeternity/config';
+import { useFungibleTokens } from './fungibleTokens';
 import { useAccounts } from './accounts';
 import { useBalances } from './balances';
 import { useTransactionTx } from './transactionTx';
@@ -40,10 +41,9 @@ export function useLatestTransactionList({ store }: IDefaultComposableOptions) {
     fetchTransactions,
   } = useTransactionList({ store });
 
+  const { tokenBalances } = useFungibleTokens({ store });
   const btcTransactions = ref<ITransaction[]>([]);
 
-  const tokens = computed(() => store.state.fungibleTokens.tokens);
-
   const latestTransactions = computed(() => {
     const aeTransactions = Object.entries(transactions.value)
       .map(([
@@ -131,7 +131,7 @@ export function useLatestTransactionList({ store }: IDefaultComposableOptions) {
   );
 
   watch(
-    tokens,
+    tokenBalances,
     (oldTokens, newTokens) => {
       if (!isEqual(oldTokens, newTokens)) {
         updateTransactionListData();
diff --git a/src/composables/tokensList.ts b/src/composables/tokensList.ts
index 8459d2eeb..e94eac649 100644
--- a/src/composables/tokensList.ts
+++ b/src/composables/tokensList.ts
@@ -13,7 +13,9 @@ import type {
 import { AE_CONTRACT_ID } from '@/protocols/aeternity/config';
 import { ProtocolAdapterFactory } from '@/lib/ProtocolAdapterFactory';
 import { PROTOCOL_AETERNITY } from '@/constants';
-import { useCurrencies } from '@/composables/currencies';
+import { useCurrencies } from './currencies';
+import { useFungibleTokens } from './fungibleTokens';
+import { useAccounts } from './accounts';
 import { useMultisigAccounts } from './multisigAccounts';
 import { useBalances } from './balances';
 
@@ -46,14 +48,18 @@ export function useTokensList({
 }: UseTokensListOptions) {
   const { marketData } = useCurrencies();
   const { balance } = useBalances();
+  const { activeAccount } = useAccounts();
   const { activeMultisigAccount } = useMultisigAccounts({ store });
+  const {
+    availableTokens: allAvailableTokens,
+    getAccountTokenBalances,
+  } = useFungibleTokens({ store });
 
   const availableTokens = computed<ITokenList>(() => (
     isMultisig
-      ? []
-      : (store.state as any).fungibleTokens.availableTokens
+      ? {}
+      : allAvailableTokens.value
   ));
-  const tokenBalances = computed<IToken[]>(() => store.getters['fungibleTokens/tokenBalances']);
 
   const aeTokenBalance = computed((): Balance => (
     isMultisig
@@ -61,6 +67,8 @@ export function useTokensList({
       : balance.value || new BigNumber(0)
   ));
 
+  const tokenBalances = computed(() => getAccountTokenBalances(activeAccount.value.address));
+
   /**
    * Returns the default aeternity meta information
    */
diff --git a/src/composables/transactionList.ts b/src/composables/transactionList.ts
index fbeadbf6c..d4a5eb796 100644
--- a/src/composables/transactionList.ts
+++ b/src/composables/transactionList.ts
@@ -77,7 +77,7 @@ export function useTransactionList({ store }: IDefaultComposableOptions) {
     }
     const { pending, loaded } = getAccountTransactionsState(address);
 
-    return [...loaded, ...(pending[nodeNetworkId.value!] || [])];
+    return [...loaded, ...((pending || {})[nodeNetworkId.value!] || [])];
   }
 
   function getTransactionByHash(address: Encoded.AccountAddress, hash: string) {
@@ -277,7 +277,7 @@ export function useTransactionList({ store }: IDefaultComposableOptions) {
     preparedTransactions = orderBy(preparedTransactions, ['microTime'], ['desc']);
 
     const oldPendingTransactionForAccount: ITransaction[] = (
-      transactions.value[address]?.pending[nodeNetworkId.value!] || []
+      transactions.value[address]?.pending?.[nodeNetworkId.value!] || []
     );
 
     oldPendingTransactionForAccount.forEach(({ hash }) => {
@@ -321,7 +321,7 @@ export function useTransactionList({ store }: IDefaultComposableOptions) {
       transactions.value = getLocalStorageItem([TRANSACTIONS_LOCAL_STORAGE_KEY, value!]) || {};
 
       Object.entries(transactions.value).forEach(([address, transactionState]) => {
-        (transactionState.pending[nodeNetworkId.value!])?.filter(({ sent = false }) => !sent)
+        (transactionState.pending?.[nodeNetworkId.value!])?.filter(({ sent = false }) => !sent)
           .forEach((transaction) => {
             if (Date.now() - (transaction.microTime || 0) > 600000) {
               removePendingTransactionByAccount(
diff --git a/src/composables/transactionTokens.ts b/src/composables/transactionTokens.ts
index 40c1174c3..1af7a05f9 100644
--- a/src/composables/transactionTokens.ts
+++ b/src/composables/transactionTokens.ts
@@ -2,7 +2,6 @@ import { computed } from 'vue';
 import { camelCase } from 'lodash-es';
 import type {
   IDefaultComposableOptions,
-  ITokenList,
   ITokenResolved,
   ITransaction,
   TxFunctionParsed,
@@ -20,6 +19,7 @@ import {
 } from '@/protocols/aeternity/helpers';
 import { BTC_SYMBOL } from '@/protocols/bitcoin/config';
 import { getTxAmountTotal as getBitcoinTxAmountTotal } from '@/protocols/bitcoin/helpers';
+import { useFungibleTokens } from './fungibleTokens';
 
 interface UseTransactionTokensOptions extends IDefaultComposableOptions {
   transaction: ITransaction
@@ -35,13 +35,8 @@ export function useTransactionTokens({
   transaction,
   showDetailedAllowanceInfo = false,
 }: UseTransactionTokensOptions) {
-  const getTxSymbol = computed(() => store.getters.getTxSymbol);
-  const getTxAmountTotal = computed(() => store.getters.getTxAmountTotal);
   const innerTx = computed(() => getInnerTransaction(transaction.tx));
-
-  const availableTokens = computed<ITokenList>(
-    () => (store.state as any).fungibleTokens.availableTokens,
-  );
+  const { availableTokens, getTxAmountTotal, getTxSymbol } = useFungibleTokens({ store });
 
   const transactionFunction = computed(() => {
     if (innerTx.value?.function) {
@@ -83,13 +78,13 @@ export function useTransactionTokens({
       ...innerTx.value || {},
       amount: isAllowance
         ? toShiftedBigNumber(innerTx.value?.fee || 0, -AE_COIN_PRECISION)
-        : getTxAmountTotal.value(transaction, direction),
-      symbol: isAllowance ? AE_SYMBOL : getTxSymbol.value(transaction),
+        : getTxAmountTotal(transaction, direction),
+      symbol: isAllowance ? AE_SYMBOL : getTxSymbol(transaction),
       isReceived: direction === TX_DIRECTION.received,
       isAe:
         isAllowance
         || (
-          getTxSymbol.value(transaction) === AE_SYMBOL
+          getTxSymbol(transaction) === AE_SYMBOL
           && !isTransactionAex9(transaction)
         ),
     }];
diff --git a/src/composables/transactionTx.ts b/src/composables/transactionTx.ts
index 8c03879e3..ced0a51b7 100644
--- a/src/composables/transactionTx.ts
+++ b/src/composables/transactionTx.ts
@@ -3,7 +3,6 @@ import { Encoded, Tag } from '@aeternity/aepp-sdk';
 import type {
   IAccountOverview,
   IDefaultComposableOptions,
-  ITokenList,
   ITx,
   ObjectValues,
   TxFunctionRaw,
@@ -35,6 +34,7 @@ import {
   isTxFunctionDexRemoveLiquidity,
   isTxFunctionDexPool,
 } from '@/protocols/aeternity/helpers';
+import { useFungibleTokens } from '@/composables/fungibleTokens';
 import { useAccounts } from './accounts';
 import { useAeSdk } from './aeSdk';
 
@@ -53,15 +53,12 @@ export function useTransactionTx({
   const { dexContracts } = useAeSdk({ store });
   const { accounts, activeAccount } = useAccounts();
   const { tippingContractAddresses } = useTippingContracts({ store });
+  const { availableTokens } = useFungibleTokens({ store });
 
   const outerTx = ref<ITx | undefined>(tx);
   const innerTx = ref<ITx | undefined>(tx ? getInnerTransaction(tx) : undefined);
   const ownerAddress = ref<Encoded.AccountAddress | undefined>(externalAddress);
 
-  const availableTokens = computed<ITokenList>(
-    () => (store.state as any).fungibleTokens.availableTokens,
-  );
-
   const hasNestedTx = computed(() => outerTx.value && isContainingNestedTx(outerTx.value));
   const innerTxTag = computed((): Tag | null => innerTx.value ? getTxTag(innerTx.value) : null);
   const outerTxTag = computed((): Tag | null => tx ? getTxTag(tx) : null);
diff --git a/src/constants/common.ts b/src/constants/common.ts
index 0ded417b0..2e4ef1806 100644
--- a/src/constants/common.ts
+++ b/src/constants/common.ts
@@ -154,6 +154,8 @@ export const STORAGE_KEYS = {
   namesOwned: 'names-owned',
   namesDefault: 'names-default',
   lastRoute: 'last-route',
+  fungibleTokenList: 'fungible-token-list',
+  fungibleTokenBalances: 'fungible-token-balances',
   permissions: 'permissions',
 } as const;
 
diff --git a/src/popup/components/AccountCardTotalTokens.vue b/src/popup/components/AccountCardTotalTokens.vue
index f4816590f..962e248d6 100644
--- a/src/popup/components/AccountCardTotalTokens.vue
+++ b/src/popup/components/AccountCardTotalTokens.vue
@@ -16,9 +16,9 @@
 
 <script lang="ts">
 import { computed, defineComponent, PropType } from 'vue';
+import { useStore } from 'vuex';
 import { IAccount } from '@/types';
-import { useConnection } from '@/composables';
-import { useGetter } from '@/composables/vuex';
+import { useConnection, useFungibleTokens } from '@/composables';
 
 export default defineComponent({
   props: {
@@ -26,9 +26,12 @@ export default defineComponent({
   },
   setup(props) {
     const { isOnline } = useConnection();
-    const getTokenBalance = useGetter('fungibleTokens/getTokenBalance');
+    const store = useStore();
+    const { getAccountTokenBalances } = useFungibleTokens({ store });
 
-    const totalTokens = computed(() => getTokenBalance.value(props.currentAccount.address).length);
+    const totalTokens = computed(
+      () => getAccountTokenBalances(props.currentAccount.address).length,
+    );
 
     return {
       isOnline,
diff --git a/src/popup/components/Modals/ConfirmTransactionSign.vue b/src/popup/components/Modals/ConfirmTransactionSign.vue
index 78aa51cbe..f2d555d88 100644
--- a/src/popup/components/Modals/ConfirmTransactionSign.vue
+++ b/src/popup/components/Modals/ConfirmTransactionSign.vue
@@ -156,10 +156,10 @@ import {
 import {
   useAccounts,
   useAeSdk,
+  useFungibleTokens,
   usePopupProps,
   useTransactionTx,
 } from '@/composables';
-import { useGetter, useState } from '@/composables/vuex';
 import {
   AE_SYMBOL,
   DEX_TRANSACTION_TAGS,
@@ -242,12 +242,10 @@ export default defineComponent({
     const error = ref('');
     const verifying = ref(false);
 
-    const availableTokens = useState('fungibleTokens', 'availableTokens');
-    const getTxSymbol = useGetter('getTxSymbol');
-    const getTxAmountTotal = useGetter('getTxAmountTotal');
+    const { availableTokens, getTxSymbol, getTxAmountTotal } = useFungibleTokens({ store });
 
     const transactionWrapped = computed(
-      (): Partial<ITransaction> => ({ tx: popupProps.value?.tx as ITx }),
+      (): Partial<ITransaction> => ({ tx: popupProps.value?.tx as any }),
     );
 
     const isSwap = computed(() => isTxFunctionDexSwap(txFunction.value));
@@ -276,13 +274,13 @@ export default defineComponent({
     });
 
     const totalAmount = computed(
-      () => getTxAmountTotal.value(transactionWrapped.value, direction.value),
+      () => getTxAmountTotal(transactionWrapped.value as ITransaction, direction.value),
     );
 
     const singleToken = computed((): ITokenResolved => ({
       isReceived: direction.value === TX_DIRECTION.received,
       amount: totalAmount.value,
-      symbol: getTxSymbol.value(popupProps.value?.tx),
+      symbol: getTxSymbol(popupProps.value?.tx as any),
     }));
 
     const filteredTxFields = computed(
diff --git a/src/popup/components/SwapRates.vue b/src/popup/components/SwapRates.vue
index c2a0551d1..c1de74216 100644
--- a/src/popup/components/SwapRates.vue
+++ b/src/popup/components/SwapRates.vue
@@ -46,17 +46,18 @@ import {
 } from 'vue';
 import { PROTOCOL_AETERNITY } from '@/constants';
 import { camelCase } from 'lodash-es';
-import { useState } from '@/composables/vuex';
+import { useStore } from 'vuex';
+
 import {
   getTransactionTokenInfoResolver,
   isTxFunctionDexSwap,
   isTxFunctionDexPool,
 } from '@/protocols/aeternity/helpers';
-
 import {
   ITransaction,
   TxFunctionParsed,
 } from '@/types';
+import { useFungibleTokens } from '@/composables';
 import Tokens from './Tokens.vue';
 import TokenAmount from './TokenAmount.vue';
 
@@ -69,7 +70,8 @@ export default defineComponent({
     transaction: { type: Object as PropType<ITransaction>, required: true },
   },
   setup(props) {
-    const availableTokens = useState('fungibleTokens', 'availableTokens');
+    const store = useStore();
+    const { availableTokens } = useFungibleTokens({ store });
 
     const isSwapTx = computed(() => isTxFunctionDexSwap(props.transaction.tx.function)
         || isTxFunctionDexPool(props.transaction.tx.function));
@@ -93,15 +95,20 @@ export default defineComponent({
 
       const hasAmount = tokens.every((token) => !!token.amount);
 
+      const tokenAmount = [
+        Number(tokens[0].amount),
+        Number(tokens[1].amount),
+      ];
+
       return [
         {
           from: tokens[0],
           to: tokens[1],
-          price: hasAmount ? tokens[1].amount! / tokens[0].amount! : 0,
+          price: hasAmount ? tokenAmount[1] / tokenAmount[0] : 0,
         }, {
           from: tokens[1],
           to: tokens[0],
-          price: hasAmount ? tokens[0].amount! / tokens[1].amount! : 0,
+          price: hasAmount ? tokenAmount[0] / tokenAmount[1] : 0,
         },
       ];
     });
diff --git a/src/popup/components/SwapRoute.vue b/src/popup/components/SwapRoute.vue
index d83346003..1fc57c73a 100644
--- a/src/popup/components/SwapRoute.vue
+++ b/src/popup/components/SwapRoute.vue
@@ -1,6 +1,6 @@
 <template>
   <div
-    v-if="tokens.length > 1"
+    v-if="tokenList.length > 1"
     class="swap-route"
   >
     <div class="title">
@@ -8,7 +8,7 @@
     </div>
     <div class="swap-wrapper">
       <span
-        v-for="(token, idx) of tokens"
+        v-for="(token, idx) of tokenList"
         :key="idx"
         class="swap"
       >
@@ -30,78 +30,112 @@
   </div>
 </template>
 
-<script>
-import { mapState } from 'vuex';
+<script lang="ts">
+import { computed, defineComponent, PropType } from 'vue';
+import { useStore } from 'vuex';
 import { camelCase } from 'lodash-es';
-import { useAeSdk } from '@/composables';
+import { useAeSdk, useFungibleTokens } from '@/composables';
 import { DEX_CONTRACTS } from '@/protocols/aeternity/config';
-import { getTransactionTokenInfoResolver, isTxFunctionDexSwap } from '@/protocols/aeternity/helpers';
 
+import { getTransactionTokenInfoResolver, isTxFunctionDexSwap } from '@/protocols/aeternity/helpers';
+import {
+  ITransaction,
+  TxFunction,
+  TxFunctionParsed,
+  TxFunctionRaw,
+} from '@/types';
+import { Encoded } from '@aeternity/aepp-sdk';
 import Tokens from './Tokens.vue';
 import ArrowHead from '../../icons/arrow-head.svg?vue-component';
 
-export default {
+export default defineComponent({
   components: {
     Tokens,
     ArrowHead,
   },
   props: {
-    transaction: { type: Object, required: true },
+    transaction: { type: Object as PropType<ITransaction>, required: true },
   },
-  computed: {
-    ...mapState('fungibleTokens', ['availableTokens']),
-    tokens() {
-      if (!isTxFunctionDexSwap(this.transaction.tx.function)) {
+  setup(props) {
+    const store = useStore();
+    const { nodeNetworkId } = useAeSdk({ store });
+    const { availableTokens } = useFungibleTokens({ store });
+
+    function getTxFunction(
+      functionName: TxFunctionRaw | TxFunctionParsed | TxFunction,
+    ): TxFunctionParsed {
+      return camelCase(functionName) as TxFunctionParsed;
+    }
+
+    const tokenList = computed(() => {
+      const txFunction = getTxFunction(props.transaction.tx.function!);
+
+      if (!isTxFunctionDexSwap(txFunction)) {
+        return [];
+      }
+      const resolver = getTransactionTokenInfoResolver(txFunction);
+      if (!resolver) {
         return [];
       }
-      const resolver = getTransactionTokenInfoResolver(camelCase(this.transaction.tx.function));
-      if (!resolver) return [];
-      let { tokens } = resolver(this.transaction, this.availableTokens);
-      const index = this.transaction.tx.arguments.findIndex(({ type }) => type === 'list');
-      if (index >= 0 && this.transaction.tx.arguments[index].value.length > tokens.length) {
+      let { tokens } = resolver(props.transaction, availableTokens.value);
+      const index = props.transaction.tx.arguments.findIndex(({ type }) => type === 'list');
+
+      if (index >= 0 && props.transaction.tx.arguments[index].value.length > tokens.length) {
         tokens = [
           tokens[0],
-          ...this.transaction.tx.arguments[index].value
-            .slice(1, this.transaction.tx.arguments[index].value.length - 1)
-            .map(({ value }) => this.availableTokens[value]),
+          ...props.transaction.tx.arguments[index].value
+            .slice(1, props.transaction.tx.arguments[index].value.length - 1)
+            .map((element: any) => availableTokens.value[element.value]),
           tokens[1],
         ];
       }
-      const { nodeNetworkId } = useAeSdk({ store: this.$store });
-      const waeContract = DEX_CONTRACTS[nodeNetworkId.value]?.wae;
-      if (tokens[0].isAe && waeContract && !waeContract?.includes(tokens[1].contractId)) {
+
+      const waeContract = DEX_CONTRACTS[nodeNetworkId.value!]?.wae;
+
+      const tokenLastIndex = tokens.length - 1;
+
+      if (
+        tokens[0].isAe
+        && waeContract
+        && !waeContract?.includes(tokens[1].contractId as Encoded.ContractAddress)
+      ) {
         tokens.unshift({
           ...tokens[0],
           isAe: true,
         });
         tokens[1].isAe = false;
       }
-      if (tokens[tokens.length - 1].isAe && waeContract
-        && !waeContract?.includes(tokens[tokens.length - 2].contractId)) {
-        tokens[tokens.length - 1].isAe = false;
-        tokens.push({ ...tokens[tokens.length - 1], isAe: true });
+      if (tokens[tokenLastIndex].isAe && waeContract
+        && !waeContract?.includes(
+            tokens[tokenLastIndex - 1].contractId as Encoded.ContractAddress,
+        )
+      ) {
+        tokens[tokenLastIndex].isAe = false;
+        tokens.push({ ...tokens[tokenLastIndex], isAe: true });
       }
       return tokens;
-    },
-  },
-  methods: {
-    checkWaeAeTx(idx) {
-      if (idx === this.tokens.length - 1) {
+    });
+
+    function checkWaeAeTx(idx: number) {
+      if (idx === tokenList.value.length - 1) {
         return false;
       }
-      const { nodeNetworkId } = useAeSdk({ store: this.$store });
-      const contracts = DEX_CONTRACTS[nodeNetworkId.value];
-      return (
-        contracts?.wae?.includes(this.tokens[idx].contractId)
-        && this.tokens[idx + 1].isAe
-      )
-      || (
-        contracts?.wae?.includes(this.tokens[idx + 1].contractId)
-        && this.tokens[idx].isAe
+      const contracts = DEX_CONTRACTS[nodeNetworkId.value!];
+
+      return (contracts?.wae?.includes(tokenList.value[idx].contractId as Encoded.ContractAddress)
+          && tokenList.value[idx + 1].isAe
+      ) || (
+        contracts?.wae?.includes(tokenList.value[idx + 1].contractId as Encoded.ContractAddress)
+          && tokenList.value[idx].isAe
       );
-    },
+    }
+
+    return {
+      tokenList,
+      checkWaeAeTx,
+    };
   },
-};
+});
 </script>
 
 <style lang="scss" scoped>
diff --git a/src/popup/components/TransactionLabel.vue b/src/popup/components/TransactionLabel.vue
index d9134ecb8..e731d0b72 100644
--- a/src/popup/components/TransactionLabel.vue
+++ b/src/popup/components/TransactionLabel.vue
@@ -78,15 +78,11 @@ import { Tag } from '@aeternity/aepp-sdk';
 import { useI18n } from 'vue-i18n';
 import { useStore } from 'vuex';
 
-import { useAccounts, useTransactionTx } from '@/composables';
-import { useState } from '@/composables/vuex';
-import { useAeNames } from '@/protocols/aeternity/composables/aeNames';
-import {
-  ITokenList,
-  ITransaction,
-} from '@/types';
+import type { ITransaction } from '@/types';
 import { TX_DIRECTION } from '@/constants';
 import { getDefaultAccountLabel } from '@/utils';
+import { useAccounts, useFungibleTokens, useTransactionTx } from '@/composables';
+import { useAeNames } from '@/protocols/aeternity/composables/aeNames';
 import {
   TX_FUNCTIONS,
   TX_RETURN_TYPE_ABORT,
@@ -135,7 +131,7 @@ export default defineComponent({
       externalAddress: props.transaction.transactionOwner,
     });
 
-    const availableTokens = useState<ITokenList>('fungibleTokens', 'availableTokens');
+    const { availableTokens } = useFungibleTokens({ store });
 
     const label = computed((): {
       text: string;
diff --git a/src/popup/components/TransactionList.vue b/src/popup/components/TransactionList.vue
index 62a1a0533..ca35781a1 100644
--- a/src/popup/components/TransactionList.vue
+++ b/src/popup/components/TransactionList.vue
@@ -50,10 +50,10 @@ import {
   pipe,
   sortTransactionsByDate,
 } from '@/utils';
-import { useGetter } from '@/composables/vuex';
 import {
   useAccounts,
   useAeSdk,
+  useFungibleTokens,
   useTransactionAndTokenFilter,
   useViewport,
 } from '@/composables';
@@ -98,7 +98,7 @@ export default defineComponent({
       FILTER_MODE,
     } = useTransactionAndTokenFilter();
 
-    const getTxSymbol = useGetter('getTxSymbol');
+    const { getTxSymbol } = useFungibleTokens({ store });
 
     function filterTransactionsByDisplayMode(transactionList: ICommonTransaction[]) {
       return transactionList.filter((transaction) => {
@@ -140,7 +140,7 @@ export default defineComponent({
         (transaction) => (
           !searchPhrase.value
           || includesCaseInsensitive(
-            getTxSymbol.value(transaction),
+            getTxSymbol(getTransaction(transaction)),
             searchPhrase.value.toLocaleLowerCase(),
           )
         ),
diff --git a/src/popup/components/TransactionTagList.vue b/src/popup/components/TransactionTagList.vue
index 500c08d86..8d5a14aa3 100644
--- a/src/popup/components/TransactionTagList.vue
+++ b/src/popup/components/TransactionTagList.vue
@@ -18,11 +18,8 @@ import { computed, defineComponent, PropType } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { Tag } from '@aeternity/aepp-sdk';
 import { useStore } from 'vuex';
-import { useTippingContracts, useTransactionTx } from '@/composables';
-import type {
-  ITokenList,
-  ITransaction,
-} from '@/types';
+import { useFungibleTokens, useTippingContracts, useTransactionTx } from '@/composables';
+import type { ITransaction } from '@/types';
 import { excludeFalsy, includes } from '@/utils';
 import {
   AENS,
@@ -64,9 +61,7 @@ export default defineComponent({
 
     const { tippingContractAddresses } = useTippingContracts({ store });
 
-    const availableTokens = computed<ITokenList>(
-      () => store.state.fungibleTokens.availableTokens,
-    );
+    const { availableTokens } = useFungibleTokens({ store });
 
     const labels = computed((): string[] => {
       if (props.customTitle) {
diff --git a/src/popup/pages/FungibleTokens/TokenContainer.vue b/src/popup/pages/FungibleTokens/TokenContainer.vue
index 3fced91d9..9501dc696 100644
--- a/src/popup/pages/FungibleTokens/TokenContainer.vue
+++ b/src/popup/pages/FungibleTokens/TokenContainer.vue
@@ -102,7 +102,7 @@ import { useRoute } from 'vue-router';
 import { useI18n } from 'vue-i18n';
 import { Encoded } from '@aeternity/aepp-sdk';
 
-import type { IToken, ITokenList, TokenPair } from '@/types';
+import type { IToken, TokenPair } from '@/types';
 import {
   IS_IOS,
   PROTOCOL_AETERNITY,
@@ -121,11 +121,11 @@ import {
   useAccounts,
   useAeSdk,
   useCurrencies,
+  useFungibleTokens,
   useTokensList,
   useTokenProps,
   useUi,
 } from '@/composables';
-import { useState, useGetter } from '@/composables/vuex';
 import { AE_CONTRACT_ID, AE_DEX_URL } from '@/protocols/aeternity/config';
 import { buildAeFaucetUrl, buildSimplexLink, isContract } from '@/protocols/aeternity/helpers';
 import { ProtocolAdapterFactory } from '@/lib/ProtocolAdapterFactory';
@@ -175,6 +175,11 @@ export default defineComponent({
       isMultisig: isMultisig.value,
     });
     const { marketData } = useCurrencies();
+    const {
+      getContractTokenPairs,
+      availableTokens,
+      getAccountTokenBalances,
+    } = useFungibleTokens({ store });
 
     const isCoin: boolean = !!route.matched.find(
       ({ name }) => name && [ROUTE_COIN, ROUTE_COIN_DETAILS].includes(name.toString()),
@@ -203,10 +208,9 @@ export default defineComponent({
       },
     ];
     const routerHeight = ref<string>();
-    const tokenPairs = ref<TokenPair>({ token0: null, token1: null });
+    const tokenPairs = ref<Partial<TokenPair>>({ token0: null, token1: null });
     const stickyTabsWrapperEl = ref<HTMLDivElement>();
-    const tokenBalances = useGetter<IToken[]>('fungibleTokens/tokenBalances');
-    const availableTokens = useState<ITokenList>('fungibleTokens', 'availableTokens');
+
     const fungibleToken = computed(() => availableTokens.value[contractId]);
     const routeName = computed(() => route.name);
     const showFilterBar = computed(() => !!route?.meta?.showFilterBar);
@@ -223,7 +227,7 @@ export default defineComponent({
           .getAdapter(PROTOCOL_AETERNITY)
           .getDefaultCoin(marketData.value!, aeTokenBalance.value.toNumber());
       }
-      return tokenBalances.value.find(
+      return getAccountTokenBalances().find(
         (token) => token.contractId === contractId,
       ) || { ...fungibleToken.value, contractId };
     });
@@ -258,7 +262,7 @@ export default defineComponent({
       if (isContract(contractId) && !isAe) {
         setLoaderVisible(true);
         await getAeSdk();
-        tokenPairs.value = await store.dispatch('fungibleTokens/getContractTokenPairs', contractId);
+        tokenPairs.value = await getContractTokenPairs(contractId);
         setLoaderVisible(false);
       }
       setTimeout(() => {
diff --git a/src/popup/pages/FungibleTokens/TokenTransactions.vue b/src/popup/pages/FungibleTokens/TokenTransactions.vue
index e0edefc5b..1b28c7d22 100644
--- a/src/popup/pages/FungibleTokens/TokenTransactions.vue
+++ b/src/popup/pages/FungibleTokens/TokenTransactions.vue
@@ -23,15 +23,15 @@ import {
   IonPage,
 } from '@ionic/vue';
 import { useStore } from 'vuex';
-import type { ICommonTransaction, ITokenList, ITx } from '@/types';
+import type { ICommonTransaction, ITx } from '@/types';
 import { TXS_PER_PAGE } from '@/constants';
 import {
   useAccounts,
+  useFungibleTokens,
   useMultisigAccounts,
   useTransactionList,
   useTokenProps,
 } from '@/composables';
-import { useState } from '@/composables/vuex';
 import { AE_CONTRACT_ID } from '@/protocols/aeternity/config';
 import { getInnerTransaction } from '@/protocols/aeternity/helpers';
 import TransactionList from '@/popup/components/TransactionList.vue';
@@ -55,9 +55,10 @@ export default defineComponent({
       getAccountTransactionsState,
     } = useTransactionList({ store });
 
+    const { availableTokens } = useFungibleTokens({ store });
+
     const loading = ref(false);
 
-    const availableTokens = useState<ITokenList>('fungibleTokens', 'availableTokens');
     const tokensContractIds = computed((): string[] => Object.keys(availableTokens.value));
     const currentAddress = computed(
       () => (tokenProps.value?.isMultisig)
diff --git a/src/popup/pages/MultisigProposalDetails.vue b/src/popup/pages/MultisigProposalDetails.vue
index 34cb0bd49..07fe3dc99 100644
--- a/src/popup/pages/MultisigProposalDetails.vue
+++ b/src/popup/pages/MultisigProposalDetails.vue
@@ -303,13 +303,13 @@ import {
 } from '@/utils';
 import {
   useAccounts,
+  useFungibleTokens,
   useMultisigAccounts,
   usePendingMultisigTransaction,
   useMultisigTransactions,
   useModals,
   useUi,
 } from '@/composables';
-import { useGetter } from '@/composables/vuex';
 import { ROUTE_ACCOUNT } from '@/popup/router/routeNames';
 import { AE_SYMBOL, TX_FUNCTIONS_MULTISIG } from '@/protocols/aeternity/config';
 import {
@@ -390,8 +390,7 @@ export default defineComponent({
     } = useAccounts();
 
     const { isLoaderVisible, setLoaderVisible } = useUi();
-
-    const getTxSymbol = useGetter('getTxSymbol');
+    const { getTxSymbol } = useFungibleTokens({ store });
 
     const multisigTx = ref<ITx | null>(null);
     const transaction = ref<ITransaction | null>(null);
diff --git a/src/popup/pages/Retip.vue b/src/popup/pages/Retip.vue
index fdd3a8903..a34483a1a 100644
--- a/src/popup/pages/Retip.vue
+++ b/src/popup/pages/Retip.vue
@@ -91,14 +91,15 @@ import type {
 } from '@/types';
 import { toShiftedBigNumber } from '@/utils';
 import {
+  useAccounts,
+  useAeSdk,
+  useBalances,
   useCurrencies,
   useDeepLinkApi,
+  useFungibleTokens,
   useMaxAmount,
-  useBalances,
   useModals,
-  useAccounts,
   useTippingContracts,
-  useAeSdk,
   useTransactionList,
   useUi,
 } from '@/composables';
@@ -146,6 +147,7 @@ export default defineComponent({
     const { getTippingContracts } = useTippingContracts({ store });
     const { upsertCustomPendingTransactionForAccount } = useTransactionList({ store });
     const { getTippingUrlStatus } = useAeTippingUrls();
+    const { createOrChangeAllowance } = useFungibleTokens({ store });
 
     const tipId = route.query.id;
     const tip = ref<{ url: string, id: string }>({
@@ -178,11 +180,9 @@ export default defineComponent({
           && formModel.value.selectedAsset?.contractId
           && formModel.value.selectedAsset.contractId !== AE_CONTRACT_ID
         ) {
-          await store.dispatch(
-            'fungibleTokens/createOrChangeAllowance',
-            [
-              formModel.value.selectedAsset.contractId,
-              formModel.value.amount],
+          await createOrChangeAllowance(
+            formModel.value.selectedAsset.contractId,
+            formModel.value.amount || 0,
           );
 
           retipResponse = await tippingV2.retip_token(
diff --git a/src/protocols/aeternity/components/TransferReview.vue b/src/protocols/aeternity/components/TransferReview.vue
index b9d1d59b8..d00f268b7 100644
--- a/src/protocols/aeternity/components/TransferReview.vue
+++ b/src/protocols/aeternity/components/TransferReview.vue
@@ -85,7 +85,7 @@ import {
 import { useRouter } from 'vue-router';
 import { useI18n } from 'vue-i18n';
 import { useStore } from 'vuex';
-import { Tag } from '@aeternity/aepp-sdk';
+import { Encoded, Tag } from '@aeternity/aepp-sdk';
 import type { TransferFormModel, ITransaction } from '@/types';
 import {
   escapeSpecialChars,
@@ -95,6 +95,7 @@ import {
 import {
   useAccounts,
   useDeepLinkApi,
+  useFungibleTokens,
   useModals,
   useMultisigAccounts,
   useMultisigTransactions,
@@ -148,6 +149,11 @@ export default defineComponent({
       updateMultisigAccounts,
     } = useMultisigAccounts({ store });
     const { getTippingContracts } = useTippingContracts({ store });
+    const {
+      createOrChangeAllowance,
+      burnTriggerPoS,
+      transferToken,
+    } = useFungibleTokens({ store });
 
     const loading = ref<boolean>(false);
 
@@ -173,20 +179,20 @@ export default defineComponent({
         let actionResult;
 
         if (props.transferData.invoiceId !== null) {
-          actionResult = await store.dispatch('fungibleTokens/burnTriggerPoS', [
+          actionResult = await burnTriggerPoS(
             selectedAsset.contractId,
             amount,
             props.transferData.invoiceContract,
             props.transferData.invoiceId,
             { waitMined: false, modal: false },
-          ]);
+          );
         } else if (!isSelectedAssetAeCoin) {
-          actionResult = await store.dispatch('fungibleTokens/transfer', [
+          actionResult = await transferToken(
             selectedAsset.contractId,
             recipient,
             amount,
             { waitMined: false, modal: false },
-          ]);
+          );
         } else {
           const aeternityAdapter = ProtocolAdapterFactory.getAdapter(PROTOCOL_AETERNITY);
           actionResult = await aeternityAdapter.spend(amount, recipient, {
@@ -196,7 +202,7 @@ export default defineComponent({
 
         if (actionResult && !isSelectedAssetAeCoin) {
           const transaction: ITransaction = {
-            hash: actionResult.hash,
+            hash: actionResult.hash as Encoded.TxHash,
             pendingTokenTx: true,
             pending: true,
             transactionOwner: activeAccount.value.address,
@@ -214,7 +220,7 @@ export default defineComponent({
           upsertCustomPendingTransactionForAccount(activeAccount.value.address, transaction);
         } else if (actionResult) {
           const transaction: ITransaction = {
-            hash: actionResult.hash,
+            hash: actionResult.hash as Encoded.TxHash,
             pending: true,
             transactionOwner: activeAccount.value.address,
             tx: {
@@ -254,10 +260,10 @@ export default defineComponent({
         const { tippingV1, tippingV2 } = await getTippingContracts();
         const tippingContract = tippingV2 || tippingV1;
         if (selectedAsset.contractId !== AE_CONTRACT_ID && tippingV2) {
-          await store.dispatch('fungibleTokens/createOrChangeAllowance', [
+          await createOrChangeAllowance(
             selectedAsset.contractId,
             props.amount,
-          ]);
+          );
           txResult = await tippingV2.tip_token(
             recipient,
             escapeSpecialChars(note),
diff --git a/src/protocols/aeternity/components/TransferSendForm.vue b/src/protocols/aeternity/components/TransferSendForm.vue
index f5993804d..52e69738f 100644
--- a/src/protocols/aeternity/components/TransferSendForm.vue
+++ b/src/protocols/aeternity/components/TransferSendForm.vue
@@ -168,7 +168,6 @@ import { Encoded } from '@aeternity/aepp-sdk';
 import type {
   IAsset,
   IFormSelectOption,
-  ITokenList,
   TransferFormModel,
 } from '@/types';
 import {
@@ -184,6 +183,7 @@ import {
   useAccounts,
   useBalances,
   useCurrencies,
+  useFungibleTokens,
   useMaxAmount,
   useModals,
   useMultisigAccounts,
@@ -192,7 +192,6 @@ import {
   AE_CONTRACT_ID,
   AE_SYMBOL,
 } from '@/protocols/aeternity/config';
-import { useState } from '@/composables/vuex';
 import { ProtocolAdapterFactory } from '@/lib/ProtocolAdapterFactory';
 import { useTransferSendForm } from '@/composables/transferSendForm';
 import { isAensNameValid } from '@/protocols/aeternity/helpers';
@@ -263,9 +262,7 @@ export default defineComponent({
       setActiveAccountByAddress,
     } = useAccounts();
 
-    const fungibleTokens = useState('fungibleTokens');
-
-    const availableTokens = computed<ITokenList>(() => fungibleTokens.value.availableTokens);
+    const { availableTokens, getAccountTokenBalances } = useFungibleTokens({ store });
 
     function getSelectedAssetValue(tokenContractId?: string, selectedAsset?: IAsset) {
       const aeCoin = ProtocolAdapterFactory
@@ -309,7 +306,7 @@ export default defineComponent({
       () => formModel.value.selectedAsset?.contractId === AE_CONTRACT_ID,
     );
 
-    const tokenBalances = computed(() => fungibleTokens.value.tokenBalances);
+    const tokenBalances = computed(() => getAccountTokenBalances());
 
     const isTipUrl = computed(() => (
       !!formModel.value.address
diff --git a/src/protocols/aeternity/helpers/index.ts b/src/protocols/aeternity/helpers/index.ts
index 0415318cf..c833b0d92 100644
--- a/src/protocols/aeternity/helpers/index.ts
+++ b/src/protocols/aeternity/helpers/index.ts
@@ -50,14 +50,14 @@ import {
 
 export * from './transactionTokenInfoResolvers';
 
-export function aeToAettos(value: number | string) {
+export function aeToAettos(value: number | string | BigNumber) {
   return formatAmount(value.toString(), {
     denomination: AE_AMOUNT_FORMATS.AE,
     targetDenomination: AE_AMOUNT_FORMATS.AETTOS,
   });
 }
 
-export function aettosToAe(value: number | string) {
+export function aettosToAe(value: number | string | BigNumber) {
   return formatAmount(value.toString(), {
     denomination: AE_AMOUNT_FORMATS.AETTOS,
     targetDenomination: AE_AMOUNT_FORMATS.AE,
@@ -76,7 +76,7 @@ export function buildSimplexLink(address: string): string {
 
 export function calculateSupplyAmount(balance: number, totalSupply: number, reserve: number) {
   if (!balance || !totalSupply || !reserve) {
-    return null;
+    return undefined;
   }
   const share = new BigNumber(balance).times(100).div(totalSupply);
   const amount = new BigNumber(reserve).times(share).div(100);
diff --git a/src/protocols/aeternity/views/TransactionDetails.vue b/src/protocols/aeternity/views/TransactionDetails.vue
index 1f6037f1a..818496ad0 100644
--- a/src/protocols/aeternity/views/TransactionDetails.vue
+++ b/src/protocols/aeternity/views/TransactionDetails.vue
@@ -170,6 +170,7 @@ import { IonContent, IonPage } from '@ionic/vue';
 import type { ITransaction, TxFunctionRaw } from '@/types';
 import {
   useAccounts,
+  useFungibleTokens,
   useMiddleware,
   useMultisigAccounts,
   useTransactionList,
@@ -271,12 +272,10 @@ export default defineComponent({
       getTransactionByHash,
     } = useTransactionList({ store });
 
+    const { getTxAmountTotal, getTxSymbol } = useFungibleTokens({ store });
     const transaction = ref<ITransaction>();
     const multisigContractId = ref<string>();
 
-    const getTxSymbol = computed(() => store.getters.getTxSymbol);
-    const getTxAmountTotal = computed(() => store.getters.getTxAmountTotal);
-
     const tipUrl = computed(() => transaction.value ? getTransactionTipUrl(transaction.value) : '');
     const contractId = computed(() => transaction.value?.tx.contractId);
     const txFunction = computed(() => transaction.value?.tx?.function as TxFunctionRaw | undefined);
diff --git a/src/protocols/aeternity/views/TransferReceiveModal.vue b/src/protocols/aeternity/views/TransferReceiveModal.vue
index 6a05ae716..3bbafe7d2 100644
--- a/src/protocols/aeternity/views/TransferReceiveModal.vue
+++ b/src/protocols/aeternity/views/TransferReceiveModal.vue
@@ -16,12 +16,11 @@
 <script lang="ts">
 import { computed, defineComponent } from 'vue';
 import { useStore } from 'vuex';
-import type { ITokenList } from '@/types';
 import {
   PROTOCOL_AETERNITY,
   PROTOCOL_VIEW_TRANSFER_RECEIVE,
 } from '@/constants';
-import { useAccounts, useMultisigAccounts } from '@/composables';
+import { useAccounts, useFungibleTokens, useMultisigAccounts } from '@/composables';
 
 import TransferReceiveBase from '@/popup/components/Modals/TransferReceiveBase.vue';
 import { useAeNames } from '@/protocols/aeternity/composables/aeNames';
@@ -40,9 +39,7 @@ export default defineComponent({
     const { activeAccount } = useAccounts();
     const { getName } = useAeNames({ store });
 
-    const availableTokens = computed<ITokenList>(
-      () => store.state.fungibleTokens.availableTokens,
-    );
+    const { availableTokens } = useFungibleTokens({ store });
 
     const activeAccountAddress = computed(() => props.isMultisig
       ? activeMultisigAccountId.value
diff --git a/src/protocols/aeternity/views/TransferSendModal.vue b/src/protocols/aeternity/views/TransferSendModal.vue
index cb763f7a3..27a24e5e3 100644
--- a/src/protocols/aeternity/views/TransferSendModal.vue
+++ b/src/protocols/aeternity/views/TransferSendModal.vue
@@ -35,7 +35,6 @@ import {
   ref,
 } from 'vue';
 import type {
-  ITokenList,
   ResolveCallback,
   TransferSendStepExtended,
   TransferFormModel,
@@ -44,7 +43,6 @@ import type {
 import { Encoded } from '@aeternity/aepp-sdk';
 import { useI18n } from 'vue-i18n';
 import { useStore } from 'vuex';
-import { useState } from '@/composables/vuex';
 
 import {
   PROTOCOL_AETERNITY,
@@ -52,7 +50,7 @@ import {
   TRANSFER_SEND_STEPS,
 } from '@/constants';
 import { isUrlValid } from '@/utils';
-import { useAeSdk } from '@/composables';
+import { useAeSdk, useFungibleTokens } from '@/composables';
 import { AE_AENS_DOMAIN } from '@/protocols/aeternity/config';
 
 import TransferSendBase from '@/popup/components/Modals/TransferSendBase.vue';
@@ -77,6 +75,7 @@ export default defineComponent({
     const { t } = useI18n();
     const store = useStore();
     const { isAeNodeReady } = useAeSdk({ store });
+    const { availableTokens } = useFungibleTokens({ store });
 
     const currentRenderedComponent = ref<Component>();
     const currentStep = ref<TransferSendStepExtended>(TRANSFER_SEND_STEPS.form);
@@ -87,8 +86,6 @@ export default defineComponent({
       payload: props.payload,
     });
 
-    const availableTokens = useState<ITokenList>('fungibleTokens', 'availableTokens');
-
     const isAddressChain = computed(() => !!transferData.value.address?.endsWith(AE_AENS_DOMAIN));
 
     const isAddressUrl = computed(() => (
diff --git a/src/store/getters.js b/src/store/getters.js
deleted file mode 100644
index 9ea99fdb0..000000000
--- a/src/store/getters.js
+++ /dev/null
@@ -1,38 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { toShiftedBigNumber } from '@/utils';
-import { TX_DIRECTION } from '@/constants';
-import { AE_SYMBOL } from '@/protocols/aeternity/config';
-import {
-  aettosToAe,
-  categorizeContractCallTxObject,
-} from '@/protocols/aeternity/helpers';
-
-export default {
-  getTxSymbol: ({ fungibleTokens: { availableTokens } }) => (transaction) => {
-    if (transaction.pendingTokenTx) return availableTokens[transaction.tx.contractId]?.symbol;
-    const contractCallData = transaction.tx && categorizeContractCallTxObject(transaction);
-    return availableTokens[contractCallData?.token]?.symbol || AE_SYMBOL;
-  },
-  getTxAmountTotal: (
-    { fungibleTokens: { availableTokens } },
-  ) => (transaction, direction = TX_DIRECTION.sent) => {
-    const contractCallData = transaction.tx && categorizeContractCallTxObject(transaction);
-    if (contractCallData && availableTokens[contractCallData.token]) {
-      return +toShiftedBigNumber(
-        contractCallData.amount,
-        -availableTokens[contractCallData.token].decimals,
-      );
-    }
-    const isReceived = direction === TX_DIRECTION.received;
-
-    return +aettosToAe(
-      new BigNumber(
-        transaction.tx?.amount
-        || transaction.tx?.tx?.tx?.amount
-        || transaction.tx?.nameFee || 0,
-      )
-        .plus(isReceived ? 0 : transaction.tx?.fee || 0)
-        .plus(isReceived ? 0 : transaction.tx?.tx?.tx?.fee || 0),
-    );
-  },
-};
diff --git a/src/store/index.js b/src/store/index.js
index a36444edf..96055b19a 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -1,11 +1,8 @@
 import Vuex from 'vuex';
-import getters from './getters';
 import mutations from './mutations';
 import persistState from './plugins/persistState';
-import pollAccountInfo from './plugins/pollAccountInfo';
 import runMigrations from './migrations';
 import accountsModule from './modules/accounts';
-import fungibleTokensPlugin from './plugins/fungibleTokens';
 import stateReducer from './utils';
 import veeValidate from './plugins/veeValidate';
 
@@ -16,16 +13,13 @@ export default new Vuex.Store({
     chainNames: null,
     migrations: {},
   },
-  getters,
   mutations,
   plugins: [
     persistState(
       runMigrations,
       stateReducer,
     ),
-    fungibleTokensPlugin,
     veeValidate,
-    pollAccountInfo,
   ],
   modules: {
     accounts: accountsModule,
diff --git a/src/store/plugins/fungibleTokens.js b/src/store/plugins/fungibleTokens.js
deleted file mode 100644
index 2723c69cc..000000000
--- a/src/store/plugins/fungibleTokens.js
+++ /dev/null
@@ -1,231 +0,0 @@
-import { watch } from 'vue';
-import BigNumber from 'bignumber.js';
-import { isEmpty } from 'lodash-es';
-
-import { PROTOCOL_AETERNITY } from '@/constants';
-import FungibleTokenFullInterfaceACI from '@/lib/contracts/FungibleTokenFullInterfaceACI.json';
-import AedexV2PairACI from '@/lib/contracts/AedexV2PairACI.json';
-import ZeitTokenACI from '@/lib/contracts/FungibleTokenFullACI.json';
-import {
-  fetchAllPages,
-  handleUnknownError,
-  toShiftedBigNumber,
-} from '@/utils';
-import {
-  useAccounts,
-  useMiddleware,
-  useAeSdk,
-  useNetworks,
-  useTippingContracts,
-} from '@/composables';
-import { calculateSupplyAmount } from '@/protocols/aeternity/helpers';
-
-export default (store) => {
-  const { activeNetwork } = useNetworks();
-  const { getAeSdk } = useAeSdk({ store });
-  const { fetchFromMiddleware } = useMiddleware();
-  const {
-    aeAccounts,
-    getLastActiveProtocolAccount,
-  } = useAccounts();
-  const { tippingContractAddresses } = useTippingContracts({ store });
-
-  store.registerModule('fungibleTokens', {
-    namespaced: true,
-    state: {
-      availableTokens: {},
-      tokens: {},
-    },
-    getters: {
-      getTokenBalance: ({ tokens }) => (address) => tokens?.[address]?.tokenBalances || [],
-      tokenBalances: (state, { getTokenBalance }) => {
-        const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
-        return getTokenBalance(account.address);
-      },
-    },
-    mutations: {
-      setAvailableTokens(state, payload) {
-        state.availableTokens = payload;
-      },
-      resetTokensAndTransactions(state) {
-        state.tokens = {};
-        state.transactions = {};
-      },
-      addTokenBalance(state, tokens) {
-        state.tokens = { ...state.tokens, ...tokens };
-      },
-    },
-    actions: {
-      async loadAvailableTokens({ commit }) {
-        const response = await fetchAllPages(
-          () => fetchFromMiddleware('/v2/aex9?by=name&limit=100&direction=forward'),
-          fetchFromMiddleware,
-        );
-
-        if (isEmpty(response) || typeof response !== 'object') return commit('setAvailableTokens', {});
-
-        const availableTokens = response.reduce((obj, { contract_id: contractId, ...other }) => ({
-          ...obj, [contractId]: { contractId, ...other },
-        }), {});
-        return commit('setAvailableTokens', availableTokens);
-      },
-      async loadTokenBalances({
-        state: { availableTokens },
-        commit,
-      }) {
-        const newBalances = {};
-        await Promise.all(aeAccounts.value.map(async ({ address }) => {
-          try {
-            if (isEmpty(availableTokens)) return;
-            const tokens = await fetchAllPages(
-              () => fetchFromMiddleware(`/v2/aex9/account-balances/${address}?limit=100`),
-              fetchFromMiddleware,
-            );
-            if (isEmpty(tokens) || typeof tokens !== 'object') return;
-            const balances = tokens.map(({ amount, contract_id: contractId }) => {
-              const token = availableTokens[contractId];
-              if (!token) return null;
-              const balance = toShiftedBigNumber(amount, -token.decimals);
-              const convertedBalance = balance.toFixed(2);
-              const objectStructure = {
-                ...token,
-                value: contractId,
-                text: `${convertedBalance} ${token.symbol}`,
-                contractId,
-                balance,
-                convertedBalance,
-              };
-              return objectStructure;
-            });
-            newBalances[address] = { tokenBalances: balances };
-          } catch (e) {
-            handleUnknownError(e);
-          }
-        }));
-        commit('addTokenBalance', newBalances);
-      },
-      async createOrChangeAllowance(
-        _,
-        [contractId, amount],
-      ) {
-        const aeSdk = await getAeSdk();
-        const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
-        const selectedToken = store.state.fungibleTokens.tokens?.[account.address]
-          ?.tokenBalances
-          ?.find((t) => t?.contractId === contractId);
-        const tokenContract = await aeSdk.initializeContract({
-          aci: FungibleTokenFullInterfaceACI,
-          address: selectedToken.contractId,
-        });
-        const { decodedResult } = await tokenContract.allowance({
-          from_account: account.address,
-          for_account: tippingContractAddresses.value.tippingV2.replace('ct_', 'ak_'),
-        });
-        const allowanceAmount = decodedResult !== undefined
-          ? new BigNumber(decodedResult)
-            .multipliedBy(-1)
-            .plus(toShiftedBigNumber(amount, selectedToken.decimals))
-            .toNumber()
-          : toShiftedBigNumber(amount, selectedToken.decimals).toFixed();
-        return tokenContract.methods[
-          decodedResult !== undefined ? 'change_allowance' : 'create_allowance'
-        ](tippingContractAddresses.value.tippingV2.replace('ct_', 'ak_'), allowanceAmount);
-      },
-      async getContractTokenPairs(
-        { state: { availableTokens } },
-        address,
-      ) {
-        try {
-          const aeSdk = await getAeSdk();
-          const account = getLastActiveProtocolAccount(PROTOCOL_AETERNITY);
-          const tokenContract = await aeSdk.initializeContract({
-            aci: AedexV2PairACI,
-            address,
-          });
-
-          const [
-            { decodedResult: balances },
-            { decodedResult: balance },
-            { decodedResult: token0 },
-            { decodedResult: token1 },
-            { decodedResult: reserves },
-            { decodedResult: totalSupply },
-          ] = await Promise.all([
-            tokenContract.balances(),
-            tokenContract.balance(account.address),
-            tokenContract.token0(),
-            tokenContract.token1(),
-            tokenContract.get_reserves(),
-            tokenContract.total_supply(),
-          ]);
-
-          return {
-            token0: {
-              ...availableTokens?.[token0],
-              amount: calculateSupplyAmount(
-                balance, totalSupply, reserves.reserve0,
-              ),
-              reserve: reserves.reserve0,
-            },
-            token1: {
-              ...availableTokens?.[token1],
-              amount: calculateSupplyAmount(
-                balance, totalSupply, reserves.reserve1,
-              ),
-              reserve: reserves.reserve1,
-            },
-            totalSupply,
-            balance,
-            balances,
-          };
-        } catch (error) {
-          return {};
-        }
-      },
-      async transfer(_, [address, toAccount, amount, option]) {
-        const aeSdk = await getAeSdk();
-        const tokenContract = await aeSdk.initializeContract({
-          aci: FungibleTokenFullInterfaceACI,
-          address,
-        });
-        return tokenContract.transfer(toAccount, amount.toFixed(), option);
-      },
-      async burnTriggerPoS(_, [address, amount, posAddress, invoiceId, option]) {
-        const aeSdk = await getAeSdk();
-        const tokenContract = await aeSdk.initializeContract({
-          aci: ZeitTokenACI,
-          address,
-        });
-        return tokenContract.burn_trigger_pos(
-          amount.toFixed(), posAddress, invoiceId, option,
-        );
-      },
-    },
-  });
-
-  watch(
-    activeNetwork,
-    async (network, oldNetwork) => {
-      const newMiddlewareUrl = network.protocols[PROTOCOL_AETERNITY].middlewareUrl;
-      const oldMiddlewareUrl = oldNetwork?.protocols?.[PROTOCOL_AETERNITY]?.middlewareUrl;
-      if (newMiddlewareUrl === oldMiddlewareUrl) {
-        return;
-      }
-      store.commit('fungibleTokens/resetTokensAndTransactions');
-
-      await store.dispatch('fungibleTokens/loadAvailableTokens');
-      await store.dispatch('fungibleTokens/loadTokenBalances');
-    },
-    { immediate: true },
-  );
-
-  // Fetch balances whenever new account is added
-  watch(
-    aeAccounts,
-    async (val, oldVal) => {
-      if (val.length !== oldVal.length) {
-        await store.dispatch('fungibleTokens/loadTokenBalances');
-      }
-    },
-  );
-};
diff --git a/src/store/plugins/pollAccountInfo.js b/src/store/plugins/pollAccountInfo.js
deleted file mode 100644
index ac62edefe..000000000
--- a/src/store/plugins/pollAccountInfo.js
+++ /dev/null
@@ -1,34 +0,0 @@
-export default async (store) => {
-  let pollAvailableTokens;
-  let pollTokenBalances;
-
-  function stopPolling() {
-    clearInterval(pollAvailableTokens);
-    clearInterval(pollTokenBalances);
-  }
-
-  function startPolling() {
-    pollAvailableTokens = setInterval(() => store.dispatch('fungibleTokens/loadAvailableTokens'), 60000);
-    pollTokenBalances = setInterval(() => store.dispatch('fungibleTokens/loadTokenBalances'), 10000);
-  }
-
-  function handleVisibilityChange(event) {
-    const isHidden = event.target.hidden;
-    if (isHidden) {
-      stopPolling();
-    } else {
-      startPolling();
-    }
-  }
-
-  store.watch(
-    (state, { wallet }) => wallet,
-    async () => {
-      stopPolling();
-      startPolling();
-    },
-  );
-
-  // TODO - if possible use ui.ts composable
-  document.addEventListener('visibilitychange', (event) => handleVisibilityChange(event));
-};
diff --git a/src/types/index.ts b/src/types/index.ts
index 2907d9fc6..f81adda8a 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -126,6 +126,19 @@ export interface IInputMessage {
 
 export type IInputMessageRaw = string | IInputMessage;
 
+export interface ITokenBalanceResponse {
+  amount: number;
+  blockHash: Encoded.MicroBlockHash;
+  contractId: Encoded.ContractAddress;
+  decimals: number; // precision
+  height: number;
+  tokenName: string;
+  tokenSymbol: string;
+  txHash: Encoded.TxHash;
+  txIndex: number;
+  txType: string;
+}
+
 /**
  * Fungible tokens that are available in currently used network.
  */
@@ -133,18 +146,17 @@ export interface IToken {
   contractId: Encoded.ContractAddress
     | typeof AE_CONTRACT_ID
     | typeof BTC_CONTRACT_ID
-  contract_txi?: number;
+  contractTxi?: number;
   convertedBalance?: number; // Amount of the token that is owned
   decimals: number;
   event_supply?: number;
   extensions?: string[];
   holders?: number;
   image?: string;
-  initial_supply?: number;
+  initialSupply?: number;
   name: string;
   symbol: string;
-  text?: string; // TODO determine if we can remove this
-  value?: string; // TODO copy of the contractId, maybe we should remove it
+  amount?: number | string;
 }
 
 export type TokenPair = Record<'token0' | 'token1', IToken | null>
@@ -153,7 +165,6 @@ export type TokenPair = Record<'token0' | 'token1', IToken | null>
  * In most cases it's the result of firing one of the `TransactionResolvers`.
  */
 export interface ITokenResolved extends Partial<IToken> {
-  amount?: number;
   isAe?: boolean;
   isPool?: boolean;
   isReceived?: boolean;
diff --git a/src/utils/common.ts b/src/utils/common.ts
index 043b01e8e..6cceec3c1 100644
--- a/src/utils/common.ts
+++ b/src/utils/common.ts
@@ -43,11 +43,11 @@ import { ProtocolAdapterFactory } from '@/lib/ProtocolAdapterFactory';
  * If the number is between high and low precision
  * no argument is passed to the `toFixed` method which means there will be no trailing zeros.
  */
-export function amountRounded(rawAmount: number | BigNumberPublic): string {
+export function amountRounded(rawAmount: number | BigNumberPublic | string): string {
   const ZERO_AND_COMA_LEN = 2;
   const amount: BigNumberPublic = (typeof rawAmount === 'object')
     ? rawAmount
-    : new BigNumber(rawAmount);
+    : new BigNumber(Number(rawAmount));
   if (
     amount.lt(0.01)
     && amount.toString().length - ZERO_AND_COMA_LEN < DECIMAL_PLACES_HIGH_PRECISION
@@ -124,8 +124,8 @@ export function executeAndSetInterval(handler: () => any, timeout: number) {
 }
 
 export async function fetchAllPages<T = any>(
-  getFunction: () => Promise<IPageableResponse<T>>,
-  getNextPage: (url: string) => Promise<IPageableResponse<T>>,
+  getFunction: () => Promise<IPageableResponse<T> | null>,
+  getNextPage: (url: string) => Promise<IPageableResponse<T> | null>,
 ) {
   const result = [];
   let nextPageUrl: string | null = '';
diff --git a/tests/unit/getters/get-tx-amount-total.spec.js b/tests/unit/getters/get-tx-amount-total.spec.js
index b6dba30a0..e80a5f1aa 100644
--- a/tests/unit/getters/get-tx-amount-total.spec.js
+++ b/tests/unit/getters/get-tx-amount-total.spec.js
@@ -1,5 +1,6 @@
 import BigNumber from 'bignumber.js';
-import getters from '../../../src/store/getters';
+import Vuex from 'vuex';
+import { useFungibleTokens } from '@/composables';
 import { TX_DIRECTION } from '../../../src/constants';
 import { STUB_TOKEN_CONTRACT_ADDRESS, STUB_TRANSACTIONS } from '../../../src/constants/stubs';
 import { AE_COIN_PRECISION } from '../../../src/protocols/aeternity/config';
@@ -52,31 +53,28 @@ const tests = [{
 })),
 ];
 
-const store = {
-  fungibleTokens: {
-    availableTokens: {
-      [STUB_TOKEN_CONTRACT_ADDRESS]: {
-        decimals: TEST_TOKEN_DECIMALS,
-      },
-    },
-  },
-};
-
 describe('getTxAmountTotal', () => {
+  const store = new Vuex.Store({});
+  const { availableTokens, getTxAmountTotal } = useFungibleTokens({ store });
+
+  availableTokens.value[STUB_TOKEN_CONTRACT_ADDRESS] = {
+    decimals: TEST_TOKEN_DECIMALS,
+  };
+
   tests.forEach((test) => it(
     `should return correct result for each type of transaction: for \
 ${test.transaction.tx.type}/${test.transaction.tx.function}`,
     () => {
       expect(
-        new BigNumber(getters.getTxAmountTotal(store)(test.transaction, TX_DIRECTION.sent))
+        new BigNumber(getTxAmountTotal(test.transaction, TX_DIRECTION.sent))
           .isEqualTo(test.resultSent),
       ).toBeTruthy();
       expect(
-        new BigNumber(getters.getTxAmountTotal(store)(test.transaction)).isEqualTo(test.resultSent),
+        new BigNumber(getTxAmountTotal(test.transaction)).isEqualTo(test.resultSent),
       ).toBeTruthy();
       if (test.resultReceived !== undefined) {
         expect(
-          new BigNumber(getters.getTxAmountTotal(store)(test.transaction, TX_DIRECTION.received))
+          new BigNumber(getTxAmountTotal(test.transaction, TX_DIRECTION.received))
             .isEqualTo(test.resultReceived),
         ).toBeTruthy();
       }
diff --git a/tests/unit/transaction-tag-list.spec.js b/tests/unit/transaction-tag-list.spec.js
index b8f249eaa..5472d5919 100644
--- a/tests/unit/transaction-tag-list.spec.js
+++ b/tests/unit/transaction-tag-list.spec.js
@@ -1,6 +1,7 @@
 import { mount } from '@vue/test-utils';
 import Vuex from 'vuex';
 import { i18n, tg } from '@/popup/plugins/i18n';
+import { useFungibleTokens } from '@/composables';
 import TransactionTagList from '../../src/popup/components/TransactionTagList.vue';
 
 import {
@@ -12,13 +13,7 @@ import {
 } from '../../src/constants';
 
 const store = new Vuex.Store({
-  state: {
-    fungibleTokens: {
-      availableTokens: {
-        [STUB_TOKEN_CONTRACT_ADDRESS]: {},
-      },
-    },
-  },
+  state: {},
 });
 
 const transactionLabels = {
@@ -118,6 +113,9 @@ describe('TransactionTagList', () => {
         global: { plugins: [i18n, store] },
         props,
       });
+      const { availableTokens } = useFungibleTokens({ store });
+      availableTokens.value[STUB_TOKEN_CONTRACT_ADDRESS] = {};
+
       wrapper.findAll('.transaction-tag').forEach((el, index) => {
         expect(el.text()).toEqual(labels[index] || '');
       });