diff --git a/src/apis/kord-fi/index.ts b/src/apis/kord-fi/index.ts
index f3f0bd65a..50f4fa39a 100644
--- a/src/apis/kord-fi/index.ts
+++ b/src/apis/kord-fi/index.ts
@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { BigNumber } from 'bignumber.js';
+import { isEqual } from 'lodash-es';
 import { Observable, catchError, from, map, of } from 'rxjs';
 
 import { EarnOpportunityTokenStandardEnum } from 'src/enums/earn-opportunity-token-standard.enum';
@@ -61,7 +62,9 @@ const getKordFiStats$ = (): Observable<KordFiLendStats> =>
     )
   );
 
-export const getKordFiUserDeposits$ = (address: string): Observable<{ [key: string]: UserStakeValueInterface }> =>
+export const getKordFiUserDeposits$ = (
+  address: string
+): Observable<{ [key: string]: UserStakeValueInterface | null }> =>
   from(kordFiApi.post<KordFiUserDepositsResponse>('/llb-api/user-deposits/', { address })).pipe(
     map(({ data: { xtz_deposit, tzbtc_deposit } }) => {
       const tezosDepositAmountAtomic = tzToMutez(new BigNumber(xtz_deposit), TEZ_TOKEN_METADATA.decimals).toFixed();
@@ -88,9 +91,17 @@ export const getKordFiUserDeposits$ = (address: string): Observable<{ [key: stri
       };
     }),
     catchError(error => {
+      if (
+        axios.isAxiosError(error) &&
+        error.response?.status === 404 &&
+        isEqual(error.response.data, { detail: 'User not found' })
+      ) {
+        return of({ [KORDFI_TEZOS_CONTRACT_ADDRESS]: null, [TZBTC_CONTRACT_ADDRESS]: null });
+      }
+
       console.error('Error getting Kord.Fi user deposits: ', error);
 
-      return of({});
+      throw error;
     })
   );
 
diff --git a/src/apis/youves/index.ts b/src/apis/youves/index.ts
index 36de2794b..eab3d8a24 100644
--- a/src/apis/youves/index.ts
+++ b/src/apis/youves/index.ts
@@ -5,6 +5,7 @@ import { catchError, firstValueFrom, forkJoin, from, map, Observable, of } from
 import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { AccountInterface } from 'src/interfaces/account.interface';
 import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
+import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { ExchangeRateRecord } from 'src/store/currency/currency-state';
 import { KNOWN_TOKENS_SLUGS } from 'src/token/data/token-slugs';
 import { toTokenSlug } from 'src/token/utils/token.utils';
@@ -15,17 +16,12 @@ import { isString } from 'src/utils/is-string';
 import { tzktUrl } from 'src/utils/linking';
 import { fractionToPercentage } from 'src/utils/percentage.utils';
 import { getReadOnlyContract } from 'src/utils/rpc/contract.utils';
+import { createReadOnlyTezosToolkit } from 'src/utils/rpc/tezos-toolkit.utils';
 import { mutezToTz } from 'src/utils/tezos.util';
 
 import { INITIAL_APR_VALUE } from './constants';
 import { SavingsPoolStorage } from './types';
-import {
-  createEngineMemoized,
-  createUnifiedSavings,
-  createUnifiedStaking,
-  getTezosToolkit,
-  toEarnOpportunityToken
-} from './utils';
+import { createEngineMemoized, createUnifiedSavings, createUnifiedStaking, toEarnOpportunityToken } from './utils';
 
 export const getYOUTokenApr$ = (
   assetToUsdExchangeRate: BigNumber,
@@ -62,7 +58,7 @@ const getYOUTokenSavingItem = async (
   rpcUrl: string
 ): Promise<SavingsItem | undefined> => {
   try {
-    const tezos = getTezosToolkit(rpcUrl);
+    const tezos = createReadOnlyTezosToolkit(rpcUrl);
     const unifiedStaking = createUnifiedStaking(rpcUrl);
     const apr = await firstValueFrom(getYOUTokenApr$(youToUsdExchangeRate, youToUsdExchangeRate, rpcUrl));
     const savingsContract = await getReadOnlyContract(unifiedStaking.stakingContract, tezos);
@@ -108,7 +104,7 @@ const getSavingsItemByAssetDefinition = async (
   rpcUrl: string
 ): Promise<SavingsItem | undefined> => {
   try {
-    const tezos = getTezosToolkit(rpcUrl);
+    const tezos = createReadOnlyTezosToolkit(rpcUrl);
     const { id, token, SAVINGS_V3_POOL_ADDRESS } = assetDefinition;
     const { decimals: tokenDecimals, contractAddress: tokenAddress, tokenId } = token;
     const apr = await firstValueFrom(getYouvesTokenApr$(assetDefinition, rpcUrl));
@@ -163,7 +159,7 @@ export const getUserStake = async (
   stakingOrSavingId: string,
   type: EarnOpportunityTypeEnum,
   rpcUrl: string
-) => {
+): Promise<UserStakeValueInterface | null> => {
   const assetDefinition = contracts.mainnet.find(({ id }) => id === stakingOrSavingId);
   let lastStake: UnifiedStakeExtendedItem | undefined;
 
@@ -196,13 +192,13 @@ export const getUserStake = async (
       throw new Error('Unsupported savings type');
   }
 
-  return (
-    lastStake && {
-      lastStakeId: lastStake.id.toFixed(),
-      depositAmountAtomic: lastStake.token_amount.toFixed(),
-      claimableRewards: lastStake.rewardNow.toFixed(),
-      fullReward: lastStake.rewardTotal.toFixed(),
-      rewardsDueDate: new Date(lastStake.endTimestamp).getTime()
-    }
-  );
+  return lastStake
+    ? {
+        lastStakeId: lastStake.id.toFixed(),
+        depositAmountAtomic: lastStake.token_amount.toFixed(),
+        claimableRewards: lastStake.rewardNow.toFixed(),
+        fullReward: lastStake.rewardTotal.toFixed(),
+        rewardsDueDate: new Date(lastStake.endTimestamp).getTime()
+      }
+    : null;
 };
diff --git a/src/apis/youves/utils.ts b/src/apis/youves/utils.ts
index 79ac12870..db713278c 100644
--- a/src/apis/youves/utils.ts
+++ b/src/apis/youves/utils.ts
@@ -1,4 +1,3 @@
-import { TezosToolkit } from '@taquito/taquito';
 import {
   createEngine,
   contracts,
@@ -17,8 +16,6 @@ import memoize from 'memoizee';
 
 import { EarnOpportunityTokenStandardEnum } from 'src/enums/earn-opportunity-token-standard.enum';
 import { AccountInterface } from 'src/interfaces/account.interface';
-import { isDefined } from 'src/utils/is-defined';
-import { getFastRpcClient } from 'src/utils/rpc/fast-rpc';
 import { createReadOnlyTezosToolkit } from 'src/utils/rpc/tezos-toolkit.utils';
 
 import { INDEXER_CONFIG, YOUVES_TOKENS_ICONS } from './constants';
@@ -57,19 +54,13 @@ class MemoryStorage implements Storage {
   }
 }
 
-export const getTezosToolkit = memoize(
-  (rpcUrl: string, account?: AccountInterface) =>
-    isDefined(account) ? createReadOnlyTezosToolkit(rpcUrl, account) : new TezosToolkit(getFastRpcClient(rpcUrl)),
-  { normalizer: ([rpcUrl, account]) => [rpcUrl, account?.publicKey].join('_') }
-);
-
 const getCreateEngineCacheKey = (rpcUrl: string, token: AssetDefinition, account?: AccountInterface) =>
   [rpcUrl, token.id, account?.publicKey].join('_');
 
 export const createEngineMemoized = memoize(
   (rpcUrl: string, token: AssetDefinition, account?: AccountInterface) =>
     createEngine({
-      tezos: getTezosToolkit(rpcUrl, account),
+      tezos: createReadOnlyTezosToolkit(rpcUrl, account),
       contracts: token,
       storage: new MemoryStorage(),
       indexerConfig: INDEXER_CONFIG,
@@ -109,7 +100,7 @@ const getCreateUnifiedStakingCacheKey = (rpcUrl: string, account?: AccountInterf
 
 export const createUnifiedStaking = memoize(
   (rpcUrl: string, account?: AccountInterface) =>
-    new UnifiedStaking(getTezosToolkit(rpcUrl, account), INDEXER_CONFIG, mainnetNetworkConstants),
+    new UnifiedStaking(createReadOnlyTezosToolkit(rpcUrl, account), INDEXER_CONFIG, mainnetNetworkConstants),
   {
     normalizer: ([rpcUrl, account]) => getCreateUnifiedStakingCacheKey(rpcUrl, account)
   }
diff --git a/src/components/earn-opportunities-main-info/index.tsx b/src/components/earn-opportunities-main-info/index.tsx
index 5d5e26f18..a946173af 100644
--- a/src/components/earn-opportunities-main-info/index.tsx
+++ b/src/components/earn-opportunities-main-info/index.tsx
@@ -1,16 +1,17 @@
 import { BigNumber } from 'bignumber.js';
 import { noop } from 'lodash-es';
-import React, { FC } from 'react';
+import React, { memo } from 'react';
 import { View, Text } from 'react-native';
 
 import { Button } from 'src/components/button/button';
 import { Divider } from 'src/components/divider/divider';
-import { FormattedAmount } from 'src/components/formatted-amount';
 import { PERCENTAGE_DECIMALS } from 'src/config/earn-opportunities';
 import { DEFAULT_AMOUNT, PENNY } from 'src/config/earn-opportunities-main-info';
-import { EmptyFn } from 'src/config/general';
 import { useCurrentFiatCurrencyMetadataSelector } from 'src/store/settings/settings-selectors';
 import { formatSize } from 'src/styles/format-size';
+import { formatOptionalPercentage } from 'src/utils/earn-opportunities/format.utils';
+
+import { OptionalFormattedAmount } from '../optional-formatted-amount';
 
 import { useEarnOpportunitiesMainInfoStyles, useButtonPrimaryStyleConfig } from './styles';
 
@@ -18,54 +19,59 @@ interface Props {
   claimAllRewards?: EmptyFn;
   shouldShowClaimRewardsButton?: boolean;
   totalClaimableRewardsInFiat?: BigNumber;
-  netApr: BigNumber;
-  totalStakedAmountInFiat: BigNumber;
+  netApr?: BigNumber;
+  totalStakedAmountInFiat?: BigNumber;
   areRewardsClaimable?: boolean;
 }
 
-export const EarnOpportunitiesMainInfo: FC<Props> = ({
-  claimAllRewards = noop,
-  shouldShowClaimRewardsButton = false,
-  totalClaimableRewardsInFiat = DEFAULT_AMOUNT,
-  netApr,
-  totalStakedAmountInFiat,
-  areRewardsClaimable = false
-}) => {
-  const styles = useEarnOpportunitiesMainInfoStyles();
-  const buttonPrimaryStylesConfig = useButtonPrimaryStyleConfig();
-  const { symbol: fiatSymbol } = useCurrentFiatCurrencyMetadataSelector();
-  const roundingMode = totalClaimableRewardsInFiat?.isLessThan(PENNY) ? BigNumber.ROUND_UP : undefined;
+export const EarnOpportunitiesMainInfo = memo<Props>(
+  ({
+    claimAllRewards = noop,
+    shouldShowClaimRewardsButton = false,
+    totalClaimableRewardsInFiat = DEFAULT_AMOUNT,
+    netApr,
+    totalStakedAmountInFiat,
+    areRewardsClaimable = false
+  }) => {
+    const styles = useEarnOpportunitiesMainInfoStyles();
+    const buttonPrimaryStylesConfig = useButtonPrimaryStyleConfig();
+    const { symbol: fiatSymbol } = useCurrentFiatCurrencyMetadataSelector();
+    const roundingMode = totalClaimableRewardsInFiat?.isLessThan(PENNY) ? BigNumber.ROUND_UP : undefined;
 
-  return (
-    <View style={styles.root}>
-      <View>
-        <View style={styles.container}>
-          <View style={[styles.card, styles.deposit]}>
-            <Text style={styles.titleText}>CURRENT DEPOSIT AMOUNT</Text>
-            <FormattedAmount isDollarValue amount={totalStakedAmountInFiat} style={styles.valueText} />
-          </View>
-          <Divider size={formatSize(8)} />
-          <View style={[styles.card, styles.netApr]}>
-            <Text style={styles.titleText}>NET APR</Text>
-            <Text style={styles.valueText}>{netApr.toFixed(PERCENTAGE_DECIMALS)}%</Text>
+    return (
+      <View style={styles.root}>
+        <View>
+          <View style={styles.container}>
+            <View style={[styles.card, styles.deposit]}>
+              <Text style={styles.titleText}>CURRENT DEPOSIT AMOUNT</Text>
+              <OptionalFormattedAmount isDollarValue amount={totalStakedAmountInFiat} style={styles.valueText} />
+            </View>
+            <Divider size={formatSize(8)} />
+            <View style={[styles.card, styles.netApr]}>
+              <Text style={styles.titleText}>NET APR</Text>
+              <Text style={styles.valueText}>{formatOptionalPercentage(netApr)}</Text>
+            </View>
           </View>
+          {shouldShowClaimRewardsButton && (
+            <>
+              <Divider size={formatSize(16)} />
+              <Button
+                styleConfig={buttonPrimaryStylesConfig}
+                title={
+                  areRewardsClaimable
+                    ? `CLAIM ALL ≈ ${totalClaimableRewardsInFiat.toFixed(
+                        PERCENTAGE_DECIMALS,
+                        roundingMode
+                      )}${fiatSymbol}`
+                    : 'EARN TO CLAIM REWARDS'
+                }
+                disabled={!areRewardsClaimable}
+                onPress={claimAllRewards}
+              />
+            </>
+          )}
         </View>
-        {shouldShowClaimRewardsButton && (
-          <>
-            <Divider size={formatSize(16)} />
-            <Button
-              styleConfig={buttonPrimaryStylesConfig}
-              title={
-                areRewardsClaimable
-                  ? `CLAIM ALL ≈ ${totalClaimableRewardsInFiat.toFixed(PERCENTAGE_DECIMALS, roundingMode)}${fiatSymbol}`
-                  : 'EARN TO CLAIM REWARDS'
-              }
-              disabled={!areRewardsClaimable}
-              onPress={claimAllRewards}
-            />
-          </>
-        )}
       </View>
-    </View>
-  );
-};
+    );
+  }
+);
diff --git a/src/components/earn-opportunity-item/index.tsx b/src/components/earn-opportunity-item/index.tsx
index 10201922a..3b4303bdd 100644
--- a/src/components/earn-opportunity-item/index.tsx
+++ b/src/components/earn-opportunity-item/index.tsx
@@ -1,5 +1,5 @@
 import { noop } from 'lodash-es';
-import React, { FC, useMemo } from 'react';
+import React, { memo, useMemo } from 'react';
 import { Text, View } from 'react-native';
 
 import { Bage } from 'src/components/bage/bage';
@@ -9,8 +9,6 @@ import { EarnOpportunityTokens } from 'src/components/earn-opportunity-tokens';
 import { HorizontalBorder } from 'src/components/horizontal-border';
 import { Icon } from 'src/components/icon/icon';
 import { IconNameEnum } from 'src/components/icon/icon-name.enum';
-import { PERCENTAGE_DECIMALS } from 'src/config/earn-opportunities';
-import { EmptyFn } from 'src/config/general';
 import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { useEarnOpportunityTokens } from 'src/hooks/use-earn-opportunity-tokens';
 import { ThemesEnum } from 'src/interfaces/theme.enum';
@@ -20,10 +18,10 @@ import { formatSize } from 'src/styles/format-size';
 import { useColors } from 'src/styles/use-colors';
 import { KNOWN_STABLECOINS_SLUGS } from 'src/token/data/token-slugs';
 import { toTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { SECONDS_IN_DAY } from 'src/utils/date.utils';
+import { formatOptionalPercentage } from 'src/utils/earn-opportunities/format.utils';
 import { isFarm } from 'src/utils/earn.utils';
-import { isDefined } from 'src/utils/is-defined';
 
 import { EarnOpportunityItemSelectors } from './selectors';
 import { StatsItem } from './stats-item';
@@ -35,187 +33,182 @@ interface Props {
   lastStakeRecord?: UserStakeValueInterface;
   navigateToOpportunity: EmptyFn;
   harvestRewards?: EmptyFn;
-  stakeIsLoading: boolean;
+  stakeWasLoading: boolean;
 }
 
-export const EarnOpportunityItem: FC<Props> = ({
-  item,
-  lastStakeRecord,
-  navigateToOpportunity,
-  harvestRewards = noop,
-  stakeIsLoading
-}) => {
-  const {
-    apr,
-    stakedToken,
-    depositExchangeRate,
-    earnExchangeRate,
-    type: itemType,
-    vestingPeriodSeconds,
-    id,
-    contractAddress
-  } = item;
-  const colors = useColors();
-  const theme = useThemeSelector();
-  const styles = useEarnOpportunityItemStyles();
-  const buttonPrimaryStylesConfig = useButtonPrimaryStyleConfig();
-  const buttonSecondaryStylesConfig = useButtonSecondaryStyleConfig();
-  const { stakeTokens, rewardToken } = useEarnOpportunityTokens(item);
-  const itemIsFarm = isFarm(item);
-  const isLiquidityBaking = itemType === EarnOpportunityTypeEnum.LIQUIDITY_BAKING;
-  const isKordFi = itemType === EarnOpportunityTypeEnum.KORD_FI_SAVING;
-  const allTokensAreStablecoins = useMemo(
-    () =>
-      item.tokens.every(token =>
-        KNOWN_STABLECOINS_SLUGS.includes(toTokenSlug(token.contractAddress, token.fa2TokenId))
-      ),
-    [item.tokens]
-  );
-  const earnSourceText = useMemo(() => {
-    switch (item.type) {
-      case EarnOpportunityTypeEnum.YOUVES_SAVING:
-      case EarnOpportunityTypeEnum.YOUVES_STAKING:
-        return 'Youves';
-      case EarnOpportunityTypeEnum.KORD_FI_SAVING:
-        return 'Kord.Fi';
-      case EarnOpportunityTypeEnum.LIQUIDITY_BAKING:
-        return 'Liquidity Baking';
-
-      default:
-        return 'QuipuSwap';
-    }
-  }, [item]);
-  const earnSourceIcon = useMemo(() => {
-    switch (item.type) {
-      case EarnOpportunityTypeEnum.YOUVES_SAVING:
-      case EarnOpportunityTypeEnum.YOUVES_STAKING:
-        return theme === ThemesEnum.light ? IconNameEnum.YouvesEarnSource : IconNameEnum.YouvesEarnSourceDark;
-      case EarnOpportunityTypeEnum.KORD_FI_SAVING:
-        return IconNameEnum.KordFiEarnSource;
+export const EarnOpportunityItem = memo<Props>(
+  ({ item, lastStakeRecord, navigateToOpportunity, harvestRewards = noop, stakeWasLoading }) => {
+    const {
+      apr,
+      stakedToken,
+      depositExchangeRate,
+      earnExchangeRate,
+      type: itemType,
+      vestingPeriodSeconds,
+      id,
+      contractAddress
+    } = item;
+    const colors = useColors();
+    const theme = useThemeSelector();
+    const styles = useEarnOpportunityItemStyles();
+    const buttonPrimaryStylesConfig = useButtonPrimaryStyleConfig();
+    const buttonSecondaryStylesConfig = useButtonSecondaryStyleConfig();
+    const { stakeTokens, rewardToken } = useEarnOpportunityTokens(item);
+    const itemIsFarm = isFarm(item);
+    const isLiquidityBaking = itemType === EarnOpportunityTypeEnum.LIQUIDITY_BAKING;
+    const isKordFi = itemType === EarnOpportunityTypeEnum.KORD_FI_SAVING;
+    const allTokensAreStablecoins = useMemo(
+      () =>
+        item.tokens.every(token =>
+          KNOWN_STABLECOINS_SLUGS.includes(toTokenSlug(token.contractAddress, token.fa2TokenId))
+        ),
+      [item.tokens]
+    );
+    const earnSourceText = useMemo(() => {
+      switch (item.type) {
+        case EarnOpportunityTypeEnum.YOUVES_SAVING:
+        case EarnOpportunityTypeEnum.YOUVES_STAKING:
+          return 'Youves';
+        case EarnOpportunityTypeEnum.KORD_FI_SAVING:
+          return 'Kord.Fi';
+        case EarnOpportunityTypeEnum.LIQUIDITY_BAKING:
+          return 'Liquidity Baking';
 
-      default:
-        return IconNameEnum.QsEarnSource;
-    }
-  }, [theme, item]);
+        default:
+          return 'QuipuSwap';
+      }
+    }, [item]);
+    const earnSourceIcon = useMemo(() => {
+      switch (item.type) {
+        case EarnOpportunityTypeEnum.YOUVES_SAVING:
+        case EarnOpportunityTypeEnum.YOUVES_STAKING:
+          return theme === ThemesEnum.light ? IconNameEnum.YouvesEarnSource : IconNameEnum.YouvesEarnSourceDark;
+        case EarnOpportunityTypeEnum.KORD_FI_SAVING:
+          return IconNameEnum.KordFiEarnSource;
 
-  const formattedApr = useMemo(
-    () => (isDefined(apr) && apr !== 'NaN' ? Number(apr).toFixed(PERCENTAGE_DECIMALS) : '---'),
-    [apr]
-  );
+        default:
+          return IconNameEnum.QsEarnSource;
+      }
+    }, [theme, item]);
 
-  const depositAmounts = useAmounts(
-    lastStakeRecord?.depositAmountAtomic,
-    stakedToken.metadata.decimals,
-    depositExchangeRate
-  );
-  const { amount: depositAmount } = depositAmounts;
-  const depositIsZero = depositAmount.isZero();
+    const depositAmounts = useAmounts(
+      lastStakeRecord?.depositAmountAtomic,
+      stakedToken.metadata.decimals,
+      depositExchangeRate
+    );
+    const { amount: depositAmount } = depositAmounts;
+    const depositIsZero = depositAmount.isZero();
 
-  const claimableRewardsAmounts = useAmounts(lastStakeRecord?.claimableRewards, rewardToken.decimals, earnExchangeRate);
+    const claimableRewardsAmounts = useAmounts(
+      lastStakeRecord?.claimableRewards,
+      rewardToken.decimals,
+      earnExchangeRate
+    );
 
-  const actionButtonsTestIDProperties = useMemo(
-    () => ({
-      id,
-      contractAddress
-    }),
-    [id, contractAddress]
-  );
+    const actionButtonsTestIDProperties = useMemo(
+      () => ({
+        id,
+        contractAddress
+      }),
+      [id, contractAddress]
+    );
 
-  return (
-    <View style={[styles.root, styles.mb16]}>
-      <View style={styles.bageContainer}>
-        {(itemType === EarnOpportunityTypeEnum.STABLESWAP || (allTokensAreStablecoins && !itemIsFarm)) && (
-          <Bage text="Stable Pool" color={colors.kolibriGreen} style={styles.bage} textStyle={styles.bageText} />
-        )}
-        {Number(vestingPeriodSeconds) > SECONDS_IN_DAY && (
-          <Bage
-            text={itemIsFarm ? 'Long-Term Farm' : 'Long-Term Savings Pool'}
-            style={[styles.bage, styles.lastBage]}
-            textStyle={styles.bageText}
-          />
-        )}
-      </View>
-      <View style={styles.mainContent}>
-        <View style={[styles.tokensContainer, styles.row]}>
-          <EarnOpportunityTokens stakeTokens={stakeTokens} rewardToken={rewardToken} />
-          <View>
-            <Text style={styles.aprText}>APR: {formattedApr}%</Text>
-            <View style={styles.earnSource}>
-              {isLiquidityBaking ? (
-                <View style={[styles.earnSourceIcon, styles.liquidityBakingIconWrapper]}>
-                  <Icon size={formatSize(6)} name={IconNameEnum.LiquidityBakingLogo} />
-                </View>
-              ) : (
-                <Icon style={styles.earnSourceIcon} size={formatSize(12)} name={earnSourceIcon} />
-              )}
-              <Text style={styles.attributeTitle}>{earnSourceText}</Text>
+    return (
+      <View style={[styles.root, styles.mb16]}>
+        <View style={styles.bageContainer}>
+          {(itemType === EarnOpportunityTypeEnum.STABLESWAP || (allTokensAreStablecoins && !itemIsFarm)) && (
+            <Bage text="Stable Pool" color={colors.kolibriGreen} style={styles.bage} textStyle={styles.bageText} />
+          )}
+          {Number(vestingPeriodSeconds) > SECONDS_IN_DAY && (
+            <Bage
+              text={itemIsFarm ? 'Long-Term Farm' : 'Long-Term Savings Pool'}
+              style={[styles.bage, styles.lastBage]}
+              textStyle={styles.bageText}
+            />
+          )}
+        </View>
+        <View style={styles.mainContent}>
+          <View style={[styles.tokensContainer, styles.row]}>
+            <EarnOpportunityTokens stakeTokens={stakeTokens} rewardToken={rewardToken} />
+            <View>
+              <Text style={styles.aprText}>APR: {formatOptionalPercentage(apr ?? undefined)}</Text>
+              <View style={styles.earnSource}>
+                {isLiquidityBaking ? (
+                  <View style={[styles.earnSourceIcon, styles.liquidityBakingIconWrapper]}>
+                    <Icon size={formatSize(6)} name={IconNameEnum.LiquidityBakingLogo} />
+                  </View>
+                ) : (
+                  <Icon style={styles.earnSourceIcon} size={formatSize(12)} name={earnSourceIcon} />
+                )}
+                <Text style={styles.attributeTitle}>{earnSourceText}</Text>
+              </View>
             </View>
           </View>
-        </View>
 
-        <HorizontalBorder />
+          <HorizontalBorder />
 
-        <Divider size={formatSize(8)} />
+          <Divider size={formatSize(8)} />
 
-        <View style={[styles.row, styles.mb16]}>
-          <StatsItem
-            title={isKordFi ? 'Your deposit & Rewards:' : 'Your deposit:'}
-            amounts={depositAmounts}
-            isLoading={stakeIsLoading}
-            fiatEquivalentIsMain={itemIsFarm}
-            tokenSymbol={stakedToken.metadata.symbol}
-          />
-          {!depositIsZero && !isLiquidityBaking && !isKordFi && (
+          <View style={[styles.row, styles.mb16]}>
             <StatsItem
-              title="Claimable rewards:"
-              amounts={claimableRewardsAmounts}
-              isLoading={stakeIsLoading}
+              title={isKordFi ? 'Your deposit & Rewards:' : 'Your deposit:'}
+              amounts={depositAmounts}
+              wasLoading={stakeWasLoading}
               fiatEquivalentIsMain={itemIsFarm}
-              tokenSymbol={rewardToken.symbol}
+              tokenSymbol={stakedToken.metadata.symbol}
             />
-          )}
-        </View>
-
-        <View style={styles.row}>
-          {!depositIsZero && (
-            <View style={styles.flex}>
-              <Button
-                title="MANAGE"
-                isFullWidth
-                onPress={navigateToOpportunity}
-                styleConfig={buttonSecondaryStylesConfig}
-                testID={EarnOpportunityItemSelectors.ManageButton}
-                testIDProperties={actionButtonsTestIDProperties}
+            {!depositIsZero && !isLiquidityBaking && !isKordFi && (
+              <StatsItem
+                title="Claimable rewards:"
+                amounts={claimableRewardsAmounts}
+                wasLoading={stakeWasLoading}
+                fiatEquivalentIsMain={itemIsFarm}
+                tokenSymbol={rewardToken.symbol}
               />
-            </View>
-          )}
-          {!depositIsZero && itemIsFarm && !isLiquidityBaking && (
-            <>
-              <Divider size={formatSize(8)} />
+            )}
+          </View>
+
+          <View style={styles.row}>
+            {!depositIsZero && (
               <View style={styles.flex}>
                 <Button
+                  title="MANAGE"
                   isFullWidth
-                  title="CLAIM REWARDS"
-                  onPress={harvestRewards}
-                  styleConfig={buttonPrimaryStylesConfig}
-                  testID={EarnOpportunityItemSelectors.ClaimRewardsButton}
+                  onPress={navigateToOpportunity}
+                  styleConfig={buttonSecondaryStylesConfig}
+                  testID={EarnOpportunityItemSelectors.ManageButton}
                   testIDProperties={actionButtonsTestIDProperties}
                 />
               </View>
-            </>
-          )}
-          {depositIsZero && (
-            <Button
-              isFullWidth
-              title={itemIsFarm ? 'START FARMING' : 'START EARNING'}
-              onPress={navigateToOpportunity}
-              styleConfig={buttonPrimaryStylesConfig}
-              testID={EarnOpportunityItemSelectors.StartFarmingButton}
-              testIDProperties={actionButtonsTestIDProperties}
-            />
-          )}
+            )}
+            {!depositIsZero && itemIsFarm && !isLiquidityBaking && (
+              <>
+                <Divider size={formatSize(8)} />
+                <View style={styles.flex}>
+                  <Button
+                    isFullWidth
+                    title="CLAIM REWARDS"
+                    onPress={harvestRewards}
+                    styleConfig={buttonPrimaryStylesConfig}
+                    testID={EarnOpportunityItemSelectors.ClaimRewardsButton}
+                    testIDProperties={actionButtonsTestIDProperties}
+                  />
+                </View>
+              </>
+            )}
+            {depositIsZero && (
+              <Button
+                isFullWidth
+                title={itemIsFarm ? 'START FARMING' : 'START EARNING'}
+                onPress={navigateToOpportunity}
+                styleConfig={buttonPrimaryStylesConfig}
+                testID={EarnOpportunityItemSelectors.StartFarmingButton}
+                testIDProperties={actionButtonsTestIDProperties}
+              />
+            )}
+          </View>
         </View>
       </View>
-    </View>
-  );
-};
+    );
+  }
+);
diff --git a/src/components/earn-opportunity-item/stats-item/index.tsx b/src/components/earn-opportunity-item/stats-item/index.tsx
index e9907bdc1..ad345fc06 100644
--- a/src/components/earn-opportunity-item/stats-item/index.tsx
+++ b/src/components/earn-opportunity-item/stats-item/index.tsx
@@ -1,8 +1,7 @@
-import React, { FC, useCallback } from 'react';
+import React, { memo } from 'react';
 import { Text, View } from 'react-native';
 
-import { FormattedAmount } from 'src/components/formatted-amount';
-import { FormattedAmountWithLoader } from 'src/components/formatted-amount-with-loader';
+import { OptionalFormattedAmount } from 'src/components/optional-formatted-amount';
 import { useCurrentFiatCurrencyMetadataSelector } from 'src/store/settings/settings-selectors';
 
 import { AssetAmounts } from '../use-amounts';
@@ -12,30 +11,26 @@ import { useStatsItemStyles } from './styles';
 interface Props {
   title: string;
   amounts: AssetAmounts;
-  isLoading: boolean;
+  wasLoading: boolean;
   fiatEquivalentIsMain: boolean;
   tokenSymbol: string;
 }
 
-export const StatsItem: FC<Props> = ({ title, amounts, isLoading, fiatEquivalentIsMain, tokenSymbol }) => {
+export const StatsItem = memo<Props>(({ title, amounts, wasLoading, fiatEquivalentIsMain, tokenSymbol }) => {
   const { symbol: fiatSymbol } = useCurrentFiatCurrencyMetadataSelector();
   const styles = useStatsItemStyles();
 
-  const renderStatsLoader = useCallback(() => <Text style={styles.value}>---</Text>, [styles]);
-
   return (
     <View style={styles.root}>
       <Text style={styles.title}>{title}</Text>
-      <FormattedAmountWithLoader
-        isLoading={isLoading}
+      <OptionalFormattedAmount
         isDollarValue={fiatEquivalentIsMain}
         symbol={fiatEquivalentIsMain ? undefined : tokenSymbol}
-        amount={fiatEquivalentIsMain ? amounts.fiatEquivalent : amounts.amount}
+        amount={wasLoading ? (fiatEquivalentIsMain ? amounts.fiatEquivalent : amounts.amount) : undefined}
         style={styles.value}
-        renderLoader={renderStatsLoader}
       />
       {!fiatEquivalentIsMain && (
-        <FormattedAmount
+        <OptionalFormattedAmount
           style={styles.fiatEquity}
           isDollarValue
           showAllDecimalPlaces
@@ -45,4 +40,4 @@ export const StatsItem: FC<Props> = ({ title, amounts, isLoading, fiatEquivalent
       )}
     </View>
   );
-};
+});
diff --git a/src/components/formatted-amount-with-loader.tsx b/src/components/formatted-amount-with-loader.tsx
deleted file mode 100644
index f5a3fef50..000000000
--- a/src/components/formatted-amount-with-loader.tsx
+++ /dev/null
@@ -1,11 +0,0 @@
-import React, { FC, ReactElement } from 'react';
-
-import { FormattedAmount, FormattedAmountProps } from './formatted-amount';
-
-interface Props extends FormattedAmountProps {
-  isLoading?: boolean;
-  renderLoader: () => ReactElement;
-}
-
-export const FormattedAmountWithLoader: FC<Props> = ({ isLoading = false, renderLoader, ...restProps }) =>
-  isLoading ? renderLoader() : <FormattedAmount {...restProps} />;
diff --git a/src/components/optional-formatted-amount.tsx b/src/components/optional-formatted-amount.tsx
new file mode 100644
index 000000000..6572bc6c2
--- /dev/null
+++ b/src/components/optional-formatted-amount.tsx
@@ -0,0 +1,18 @@
+import { BigNumber } from 'bignumber.js';
+import React, { memo, useMemo } from 'react';
+import { Text } from 'react-native';
+
+import { FormattedAmount, FormattedAmountProps } from './formatted-amount';
+
+interface OptionalFormattedAmountProps extends Omit<FormattedAmountProps, 'amount'> {
+  amount?: BigNumber;
+  renderLoader?: () => JSX.Element;
+}
+
+export const OptionalFormattedAmount = memo<OptionalFormattedAmountProps>(
+  ({ amount, renderLoader, style, ...restProps }) => {
+    const Loader = useMemo(() => renderLoader ?? (() => <Text style={style}>---</Text>), [renderLoader, style]);
+
+    return amount && !amount.isNaN() ? <FormattedAmount amount={amount} style={style} {...restProps} /> : <Loader />;
+  }
+);
diff --git a/src/enums/farms-provider.enum.ts b/src/enums/farms-provider.enum.ts
new file mode 100644
index 000000000..a81227f95
--- /dev/null
+++ b/src/enums/farms-provider.enum.ts
@@ -0,0 +1,4 @@
+export enum FarmsProviderEnum {
+  Quipuswap = 'Quipuswap',
+  LiquidityBaking = 'LiquidityBaking'
+}
diff --git a/src/enums/savings-provider.enum.ts b/src/enums/savings-provider.enum.ts
new file mode 100644
index 000000000..1a92bf0d2
--- /dev/null
+++ b/src/enums/savings-provider.enum.ts
@@ -0,0 +1,4 @@
+export enum SavingsProviderEnum {
+  Youves = 'Youves',
+  KordFi = 'KordFi'
+}
diff --git a/src/hooks/main-hooks/index.ts b/src/hooks/main-hooks/index.ts
index df8790172..19783cdf3 100644
--- a/src/hooks/main-hooks/index.ts
+++ b/src/hooks/main-hooks/index.ts
@@ -95,10 +95,14 @@ export const useMainHooks = (isLocked: boolean) => {
     selectedAccountPkh
   ]);
 
-  useAuthorisedInterval(() => {
-    if (isTezosNode) {
-      dispatch(loadAllFarmsAndStakesAction());
-      dispatch(loadAllSavingsAndStakesAction());
-    }
-  }, APR_REFRESH_INTERVAL);
+  useAuthorisedInterval(
+    () => {
+      if (isTezosNode) {
+        dispatch(loadAllFarmsAndStakesAction(selectedAccountPkh));
+        dispatch(loadAllSavingsAndStakesAction(selectedAccountPkh));
+      }
+    },
+    APR_REFRESH_INTERVAL,
+    [isTezosNode, selectedAccountPkh]
+  );
 };
diff --git a/src/hooks/use-earn-opportunities-stats.ts b/src/hooks/use-earn-opportunities-stats.ts
index 746bb389a..20746367a 100644
--- a/src/hooks/use-earn-opportunities-stats.ts
+++ b/src/hooks/use-earn-opportunities-stats.ts
@@ -3,29 +3,64 @@ import { useMemo } from 'react';
 
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { useFiatToUsdRateSelector } from 'src/store/settings/settings-selectors';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { atomicTokenAmountToFiat } from 'src/utils/fiat.utils';
 import { isDefined } from 'src/utils/is-defined';
+import { ZERO } from 'src/utils/number.util';
 
-const DEFAULT_AMOUNT = 0;
+const numberIsValid = (value: string | null): value is `${number}` => isDefined(value) && !isNaN(Number(value));
+
+interface ReadyStakeEarnOpportunitiesStats {
+  netApr: BigNumber | undefined;
+  totalStakedAmountInFiat: BigNumber;
+  totalClaimableRewardsInFiat: BigNumber;
+  maxApr: BigNumber | undefined;
+}
 
 export const useEarnOpportunitiesStats = (
   earnOpportunities: EarnOpportunity[],
-  userStakes: Record<string, UserStakeValueInterface>
+  userStakes: Record<string, UserStakeValueInterface | undefined>,
+  someStakesWereLoading: boolean
 ) => {
   const fiatToUsdRate = useFiatToUsdRateSelector();
 
   return useMemo(() => {
-    const result = {
-      netApr: new BigNumber(DEFAULT_AMOUNT),
-      totalStakedAmountInFiat: new BigNumber(DEFAULT_AMOUNT),
-      totalClaimableRewardsInFiat: new BigNumber(DEFAULT_AMOUNT),
-      maxApr: BigNumber.maximum(DEFAULT_AMOUNT, ...earnOpportunities.map(item => getCorrectApr(item.apr)))
+    if (earnOpportunities.length === 0) {
+      return {
+        netApr: undefined,
+        totalStakedAmountInFiat: undefined,
+        totalClaimableRewardsInFiat: undefined,
+        maxApr: undefined
+      };
+    }
+
+    const validAprValues = earnOpportunities.map(item => item.apr).filter(numberIsValid);
+    const maxApr = validAprValues.length === 0 ? undefined : BigNumber.maximum(ZERO, ...validAprValues);
+
+    if (!someStakesWereLoading) {
+      return {
+        netApr: undefined,
+        totalStakedAmountInFiat: undefined,
+        totalClaimableRewardsInFiat: undefined,
+        maxApr
+      };
+    }
+
+    const result: ReadyStakeEarnOpportunitiesStats = {
+      netApr: undefined,
+      totalStakedAmountInFiat: ZERO,
+      totalClaimableRewardsInFiat: ZERO,
+      maxApr
     };
 
-    let totalWeightedApr = new BigNumber(DEFAULT_AMOUNT);
+    let netAprNumerator = ZERO;
+    let netAprDenominator = ZERO;
 
     Object.entries(userStakes).forEach(([address, stakeRecord]) => {
+      if (!stakeRecord) {
+        return;
+      }
+
       const item = earnOpportunities.find(({ contractAddress }) => contractAddress === address);
 
       if (!isDefined(item)) {
@@ -33,30 +68,39 @@ export const useEarnOpportunitiesStats = (
       }
 
       const depositValueInFiat = atomicTokenAmountToFiat(
-        new BigNumber(stakeRecord.depositAmountAtomic ?? DEFAULT_AMOUNT),
+        new BigNumber(stakeRecord.depositAmountAtomic ?? ZERO),
         item.stakedToken.metadata.decimals,
         item.depositExchangeRate,
         fiatToUsdRate
       );
 
-      totalWeightedApr = totalWeightedApr.plus(new BigNumber(getCorrectApr(item.apr)).multipliedBy(depositValueInFiat));
-      result.totalStakedAmountInFiat = result.totalStakedAmountInFiat.plus(depositValueInFiat);
-      result.totalClaimableRewardsInFiat = result.totalClaimableRewardsInFiat.plus(
-        atomicTokenAmountToFiat(
-          new BigNumber(stakeRecord.claimableRewards ?? DEFAULT_AMOUNT),
-          item.rewardToken.metadata.decimals,
-          item.earnExchangeRate,
-          fiatToUsdRate
-        )
+      const weightedAprSummand = new BigNumber(item.apr ?? '').multipliedBy(depositValueInFiat);
+
+      if (!weightedAprSummand.isNaN()) {
+        netAprNumerator = netAprNumerator.plus(weightedAprSummand);
+        netAprDenominator = netAprDenominator.plus(depositValueInFiat);
+      }
+
+      if (!depositValueInFiat.isNaN()) {
+        result.totalStakedAmountInFiat = result.totalStakedAmountInFiat.plus(depositValueInFiat);
+      }
+
+      const claimableRewardsInFiat = atomicTokenAmountToFiat(
+        new BigNumber(stakeRecord.claimableRewards ?? ZERO),
+        item.rewardToken.metadata.decimals,
+        item.earnExchangeRate,
+        fiatToUsdRate
       );
+
+      if (!claimableRewardsInFiat.isNaN()) {
+        result.totalClaimableRewardsInFiat = result.totalClaimableRewardsInFiat.plus(claimableRewardsInFiat);
+      }
     });
 
-    if (result.totalStakedAmountInFiat.isGreaterThan(DEFAULT_AMOUNT)) {
-      result.netApr = totalWeightedApr.dividedBy(result.totalStakedAmountInFiat);
+    if (netAprDenominator.isGreaterThan(ZERO)) {
+      result.netApr = netAprNumerator.dividedBy(netAprDenominator);
     }
 
     return result;
-  }, [earnOpportunities, userStakes, fiatToUsdRate]);
+  }, [earnOpportunities, someStakesWereLoading, userStakes, fiatToUsdRate]);
 };
-
-const getCorrectApr = (apr: string | null) => (isDefined(apr) && apr !== 'NaN' ? apr : DEFAULT_AMOUNT);
diff --git a/src/hooks/use-earn-opportunity-tokens.ts b/src/hooks/use-earn-opportunity-tokens.ts
index 966f89ac1..9a1b8506b 100644
--- a/src/hooks/use-earn-opportunity-tokens.ts
+++ b/src/hooks/use-earn-opportunity-tokens.ts
@@ -6,7 +6,7 @@ import { EarnOpportunityToken } from 'src/interfaces/earn-opportunity/earn-oppor
 import { TEZ_TOKEN_SLUG } from 'src/token/data/tokens-metadata';
 import { emptyTezosLikeToken } from 'src/token/interfaces/token.interface';
 import { toTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { useCurrentAccountCollectibles, useCurrentAccountTokens } from 'src/utils/assets/hooks';
 import { convertEarnOpportunityToken } from 'src/utils/earn.utils';
 import { isDefined } from 'src/utils/is-defined';
diff --git a/src/hooks/use-filtered-earn-opportunities.hook.ts b/src/hooks/use-filtered-earn-opportunities.hook.ts
index b54eb2d03..c2210cfcf 100644
--- a/src/hooks/use-filtered-earn-opportunities.hook.ts
+++ b/src/hooks/use-filtered-earn-opportunities.hook.ts
@@ -4,7 +4,7 @@ import { useDispatch } from 'react-redux';
 
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { sortByApr, sortByNewest, sortByOldest } from 'src/utils/earn.utils';
 import { isAssetSearched } from 'src/utils/token-metadata.utils';
 
@@ -14,7 +14,7 @@ export const useFilteredEarnOpportunities = <T extends EarnOpportunity, E extend
   selectSortValueAction: ActionCreatorWithPayload<EarnOpportunitiesSortFieldEnum, E>,
   sortField: EarnOpportunitiesSortFieldEnum,
   items: T[],
-  stakes: Record<string, UserStakeValueInterface>
+  stakes: Record<string, UserStakeValueInterface | undefined>
 ) => {
   const dispatch = useDispatch();
 
@@ -25,8 +25,11 @@ export const useFilteredEarnOpportunities = <T extends EarnOpportunity, E extend
     let result = [...items];
 
     if (depositedOnly) {
-      const stakedItemsAddresses = Object.keys(stakes);
-      result = result.filter(item => stakedItemsAddresses.includes(item.contractAddress));
+      result = result.filter(item => {
+        const stake = stakes[item.contractAddress];
+
+        return stake && Number(stake.depositAmountAtomic ?? '0') > 0;
+      });
     }
 
     if (isString(searchValue)) {
@@ -65,7 +68,7 @@ export const useFilteredEarnOpportunities = <T extends EarnOpportunity, E extend
     }
 
     return result;
-  }, [items, searchValue, depositedOnly, sortField]);
+  }, [items, depositedOnly, searchValue, sortField, stakes]);
 
   const handleSetSortField = useCallback(
     (sortField: EarnOpportunitiesSortFieldEnum) => dispatch(selectSortValueAction(sortField)),
diff --git a/src/hooks/use-filtered-farmings.hook.ts b/src/hooks/use-filtered-farmings.hook.ts
index 939f5bbdb..e43633963 100644
--- a/src/hooks/use-filtered-farmings.hook.ts
+++ b/src/hooks/use-filtered-farmings.hook.ts
@@ -1,31 +1,27 @@
-import { useMemo } from 'react';
-
 import { selectFarmsSortValueAction } from 'src/store/farms/actions';
 import {
-  useFarmsLoadingSelector,
-  useAllFarmsSelector,
+  useAllFarmsWereLoadingSelector,
+  useAllFarms,
   useFarmSortFieldSelector,
-  useLastFarmsStakesSelector
+  useLastFarmsStakes
 } from 'src/store/farms/selectors';
 
 import { useFilteredEarnOpportunities } from './use-filtered-earn-opportunities.hook';
 
 export const useFilteredFarmings = () => {
-  const farms = useAllFarmsSelector();
-  const stakes = useLastFarmsStakesSelector();
+  const farms = useAllFarms();
+  const stakes = useLastFarmsStakes();
   const sortField = useFarmSortFieldSelector();
-  const farmsLoading = useFarmsLoadingSelector();
-  const pageIsLoading = farmsLoading && farms.data.length === 0;
-  const farmsItems = useMemo(() => farms.data.map(({ item }) => item), [farms.data]);
+  const allFarmsWereLoading = useAllFarmsWereLoadingSelector();
 
   const { depositedOnly, filteredItemsList, setSearchValue, handleSetSortField, handleToggleDepositOnly } =
-    useFilteredEarnOpportunities(selectFarmsSortValueAction, sortField, farmsItems, stakes);
+    useFilteredEarnOpportunities(selectFarmsSortValueAction, sortField, farms, stakes);
 
   return {
     sortField,
     depositedOnly,
     filteredItemsList,
-    pageIsLoading,
+    shouldShowLoader: !allFarmsWereLoading,
     setSearchValue,
     handleSetSortField,
     handleToggleDepositOnly
diff --git a/src/hooks/use-filtered-savings.hook.ts b/src/hooks/use-filtered-savings.hook.ts
index 2fa5b0daf..b9adb867b 100644
--- a/src/hooks/use-filtered-savings.hook.ts
+++ b/src/hooks/use-filtered-savings.hook.ts
@@ -1,19 +1,18 @@
 import { selectSavingsSortValueAction } from 'src/store/savings/actions';
 import {
-  useSavingsItemsLoadingSelector,
-  useSavingsItemsSelector,
+  useSavingsItems,
   useSavingsSortFieldSelector,
-  useSavingsStakesSelector
+  useSavingsStakes,
+  useAllSavingsItemsWereLoadingSelector
 } from 'src/store/savings/selectors';
 
 import { useFilteredEarnOpportunities } from './use-filtered-earn-opportunities.hook';
 
 export const useFilteredSavings = () => {
-  const savingsItems = useSavingsItemsSelector();
-  const stakes = useSavingsStakesSelector();
+  const savingsItems = useSavingsItems();
+  const stakes = useSavingsStakes();
   const sortField = useSavingsSortFieldSelector();
-  const savingsItemsLoading = useSavingsItemsLoadingSelector();
-  const pageIsLoading = savingsItemsLoading && savingsItems.length === 0;
+  const allSavingsWereLoading = useAllSavingsItemsWereLoadingSelector();
 
   const { depositedOnly, filteredItemsList, setSearchValue, handleSetSortField, handleToggleDepositOnly } =
     useFilteredEarnOpportunities(selectSavingsSortValueAction, sortField, savingsItems, stakes);
@@ -22,7 +21,7 @@ export const useFilteredSavings = () => {
     sortField,
     depositedOnly,
     filteredItemsList,
-    pageIsLoading,
+    shouldShowLoader: !allSavingsWereLoading,
     setSearchValue,
     handleSetSortField,
     handleToggleDepositOnly
diff --git a/src/hooks/use-load-on-each-block.hook.ts b/src/hooks/use-load-on-each-block.hook.ts
index 019232bdc..7af7e26ce 100644
--- a/src/hooks/use-load-on-each-block.hook.ts
+++ b/src/hooks/use-load-on-each-block.hook.ts
@@ -2,20 +2,23 @@ import { PayloadAction } from '@reduxjs/toolkit';
 import { useEffect, useRef } from 'react';
 import { useDispatch } from 'react-redux';
 
+import { useCurrentAccountPkhSelector } from 'src/store/wallet/wallet-selectors';
+
 import { useBlockLevel } from './use-block-level.hook';
 
 export const useLoadOnEachBlock = <P, T extends string>(
   isLoading: boolean,
-  actionFactory: () => PayloadAction<P, T>
+  actionFactory: (currentAccountPkh: string) => PayloadAction<P, T>
 ) => {
   const blockLevel = useBlockLevel();
   const prevBlockLevelRef = useRef<number | undefined>(-1);
+  const currentAccountPkh = useCurrentAccountPkhSelector();
   const dispatch = useDispatch();
 
   useEffect(() => {
     if (!isLoading && prevBlockLevelRef.current !== blockLevel) {
-      dispatch(actionFactory());
+      dispatch(actionFactory(currentAccountPkh));
       prevBlockLevelRef.current = blockLevel;
     }
-  }, [dispatch, blockLevel, isLoading, actionFactory]);
+  }, [dispatch, blockLevel, isLoading, actionFactory, currentAccountPkh]);
 };
diff --git a/src/hooks/use-user-farming-stats.ts b/src/hooks/use-user-farming-stats.ts
index b1f4d1058..aa4b4d685 100644
--- a/src/hooks/use-user-farming-stats.ts
+++ b/src/hooks/use-user-farming-stats.ts
@@ -1,13 +1,11 @@
-import { useMemo } from 'react';
-
-import { useAllFarmsSelector, useLastFarmsStakesSelector } from 'src/store/farms/selectors';
+import { useAllFarms, useSomeFarmsStakesWereLoadingSelector, useLastFarmsStakes } from 'src/store/farms/selectors';
 
 import { useEarnOpportunitiesStats } from './use-earn-opportunities-stats';
 
 export const useUserFarmingStats = () => {
-  const allFarms = useAllFarmsSelector();
-  const lastStakes = useLastFarmsStakesSelector();
-  const farms = useMemo(() => allFarms.data.map(({ item }) => item), [allFarms.data]);
+  const farms = useAllFarms();
+  const lastStakes = useLastFarmsStakes();
+  const someStakesWereLoading = useSomeFarmsStakesWereLoadingSelector();
 
-  return useEarnOpportunitiesStats(farms, lastStakes);
+  return useEarnOpportunitiesStats(farms, lastStakes, someStakesWereLoading);
 };
diff --git a/src/hooks/use-user-savings-stats.ts b/src/hooks/use-user-savings-stats.ts
index 3953fccc2..45e07b97f 100644
--- a/src/hooks/use-user-savings-stats.ts
+++ b/src/hooks/use-user-savings-stats.ts
@@ -1,10 +1,15 @@
-import { useSavingsItemsSelector, useSavingsStakesSelector } from 'src/store/savings/selectors';
+import {
+  useSavingsItems,
+  useSavingsStakes,
+  useSomeSavingsStakesWereLoadingSelector
+} from 'src/store/savings/selectors';
 
 import { useEarnOpportunitiesStats } from './use-earn-opportunities-stats';
 
 export const useUserSavingsStats = () => {
-  const savings = useSavingsItemsSelector();
-  const stakes = useSavingsStakesSelector();
+  const savings = useSavingsItems();
+  const stakes = useSavingsStakes();
+  const someStakesWereLoading = useSomeSavingsStakesWereLoadingSelector();
 
-  return useEarnOpportunitiesStats(savings, stakes);
+  return useEarnOpportunitiesStats(savings, stakes, someStakesWereLoading);
 };
diff --git a/src/modals/manage-earn-opportunity-modal/details-card/index.tsx b/src/modals/manage-earn-opportunity-modal/details-card/index.tsx
index 8266c890c..726db7d6e 100644
--- a/src/modals/manage-earn-opportunity-modal/details-card/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/details-card/index.tsx
@@ -1,4 +1,4 @@
-import React, { FC, useCallback, useMemo, useState } from 'react';
+import React, { memo, useCallback, useMemo, useState } from 'react';
 import { Text, View } from 'react-native';
 import { useDispatch } from 'react-redux';
 
@@ -18,10 +18,11 @@ import { ModalsEnum } from 'src/navigator/enums/modals.enum';
 import { navigateAction } from 'src/store/root-state.actions';
 import { formatSize } from 'src/styles/format-size';
 import { showErrorToastByError } from 'src/toast/error-toast.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { AnalyticsEventCategory } from 'src/utils/analytics/analytics-event.enum';
 import { useAnalytics } from 'src/utils/analytics/use-analytics.hook';
 import { SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE, toIntegerSeconds } from 'src/utils/date.utils';
+import { formatOptionalPercentage } from 'src/utils/earn-opportunities/format.utils';
 import { isFarm } from 'src/utils/earn.utils';
 import { doAfterConfirmation } from 'src/utils/farm.utils';
 import { useInterval } from 'src/utils/hooks';
@@ -49,210 +50,222 @@ const COUNTDOWN_TOKENS_BASE = [
 ];
 const ZERO = '0';
 
-export const DetailsCard: FC<DetailsCardProps> = ({
-  earnOpportunityItem,
-  loading,
-  stake = EMPTY_STAKE,
-  shouldShowClaimRewardsButton,
-  isNeedToShowMoreDetails = true
-}) => {
-  const { depositAmountAtomic = ZERO, claimableRewards = ZERO, fullReward = ZERO, rewardsDueDate, lastStakeId } = stake;
-  const { stakedToken, depositExchangeRate, earnExchangeRate, rewardToken, apr, contractAddress } = earnOpportunityItem;
-  const isLiquidityBaking = earnOpportunityItem.type === EarnOpportunityTypeEnum.LIQUIDITY_BAKING;
-  const stakedTokenDecimals = stakedToken.metadata.decimals;
-  const aprFormatted = isDefined(apr) ? `${Number(apr).toFixed(2)}%` : '-';
-  const [claimPending, setClaimPending] = useState(false);
-  const styles = useDetailsCardStyles();
-  const claimRewardsButtonConfig = useClaimRewardsButtonConfig();
-  const dispatch = useDispatch();
-  const tezos = useReadOnlyTezosToolkit();
-  const tokens = useEarnOpportunityTokens(earnOpportunityItem);
-  const { trackEvent } = useAnalytics();
-  const rewardTokenDecimals = rewardToken.metadata.decimals;
-  const rewardTokenSymbol = rewardToken.metadata.symbol;
+export const DetailsCard = memo<DetailsCardProps>(
+  ({
+    earnOpportunityItem,
+    loading,
+    stake = EMPTY_STAKE,
+    shouldShowClaimRewardsButton,
+    isNeedToShowMoreDetails = true
+  }) => {
+    const {
+      depositAmountAtomic = ZERO,
+      claimableRewards = ZERO,
+      fullReward = ZERO,
+      rewardsDueDate,
+      lastStakeId
+    } = stake;
+    const { stakedToken, depositExchangeRate, earnExchangeRate, rewardToken, apr, contractAddress } =
+      earnOpportunityItem;
+    const isLiquidityBaking = earnOpportunityItem.type === EarnOpportunityTypeEnum.LIQUIDITY_BAKING;
+    const stakedTokenDecimals = stakedToken.metadata.decimals;
+    const [claimPending, setClaimPending] = useState(false);
+    const styles = useDetailsCardStyles();
+    const claimRewardsButtonConfig = useClaimRewardsButtonConfig();
+    const dispatch = useDispatch();
+    const tezos = useReadOnlyTezosToolkit();
+    const tokens = useEarnOpportunityTokens(earnOpportunityItem);
+    const { trackEvent } = useAnalytics();
+    const rewardTokenDecimals = rewardToken.metadata.decimals;
+    const rewardTokenSymbol = rewardToken.metadata.symbol;
 
-  const getMsToVestingEnd = useCallback(
-    () => (isDefined(rewardsDueDate) ? Math.max(0, rewardsDueDate - Date.now()) : 0),
-    [rewardsDueDate]
-  );
-  const [msToVestingEnd, setMsToVestingEnd] = useState(getMsToVestingEnd());
-  useInterval(
-    () => {
-      setMsToVestingEnd(getMsToVestingEnd());
-    },
-    1000,
-    [getMsToVestingEnd]
-  );
-  const secondsToVestingEnd = toIntegerSeconds(msToVestingEnd);
-  const countdownTokens = useMemo(
-    () =>
-      COUNTDOWN_TOKENS_BASE.map(({ unit, seconds }, index) => ({
-        unit,
-        value: (
-          Math.floor(secondsToVestingEnd / seconds) %
-          ((COUNTDOWN_TOKENS_BASE[index - 1]?.seconds ?? Infinity) / seconds)
-        )
-          .toString()
-          .padStart(2, '0')
-      })),
-    [secondsToVestingEnd]
-  );
+    const getMsToVestingEnd = useCallback(
+      () => (isDefined(rewardsDueDate) ? Math.max(0, rewardsDueDate - Date.now()) : 0),
+      [rewardsDueDate]
+    );
+    const [msToVestingEnd, setMsToVestingEnd] = useState(getMsToVestingEnd());
+    useInterval(
+      () => {
+        setMsToVestingEnd(getMsToVestingEnd());
+      },
+      1000,
+      [getMsToVestingEnd]
+    );
+    const secondsToVestingEnd = toIntegerSeconds(msToVestingEnd);
+    const countdownTokens = useMemo(
+      () =>
+        COUNTDOWN_TOKENS_BASE.map(({ unit, seconds }, index) => ({
+          unit,
+          value: (
+            Math.floor(secondsToVestingEnd / seconds) %
+            ((COUNTDOWN_TOKENS_BASE[index - 1]?.seconds ?? Infinity) / seconds)
+          )
+            .toString()
+            .padStart(2, '0')
+        })),
+      [secondsToVestingEnd]
+    );
 
-  const claimRewardsIfConfirmed = useCallback(() => {
-    if (!isDefined(lastStakeId)) {
-      return;
-    }
-
-    const claimRewards = async () => {
-      try {
-        setClaimPending(true);
-        dispatch(
-          navigateAction(ModalsEnum.Confirmation, {
-            type: ConfirmationTypeEnum.InternalOperations,
-            opParams: await getHarvestAssetsTransferParams(tezos, contractAddress, lastStakeId),
-            testID: 'CLAIM_REWARDS'
-          })
-        );
-      } catch (e) {
-        showErrorToastByError(e);
-      } finally {
-        setClaimPending(false);
+    const claimRewardsIfConfirmed = useCallback(() => {
+      if (!isDefined(lastStakeId)) {
+        return;
       }
-    };
 
-    if (msToVestingEnd > 0) {
-      const { id, contractAddress } = earnOpportunityItem;
-      const modalAnswerAnalyticsProperties = isFarm(earnOpportunityItem)
-        ? {
-            page: ModalsEnum.ManageFarmingPool,
-            farmId: id,
-            farmContractAddress: contractAddress
-          }
-        : {
-            page: ModalsEnum.ManageSavingsPool,
-            savingsItemId: id,
-            savingsItemAddress: contractAddress
-          };
+      const claimRewards = async () => {
+        try {
+          setClaimPending(true);
+          dispatch(
+            navigateAction(ModalsEnum.Confirmation, {
+              type: ConfirmationTypeEnum.InternalOperations,
+              opParams: await getHarvestAssetsTransferParams(tezos, contractAddress, lastStakeId),
+              testID: 'CLAIM_REWARDS'
+            })
+          );
+        } catch (e) {
+          showErrorToastByError(e);
+        } finally {
+          setClaimPending(false);
+        }
+      };
+
+      if (msToVestingEnd > 0) {
+        const { id, contractAddress } = earnOpportunityItem;
+        const modalAnswerAnalyticsProperties = isFarm(earnOpportunityItem)
+          ? {
+              page: ModalsEnum.ManageFarmingPool,
+              farmId: id,
+              farmContractAddress: contractAddress
+            }
+          : {
+              page: ModalsEnum.ManageSavingsPool,
+              savingsItemId: id,
+              savingsItemAddress: contractAddress
+            };
 
-      doAfterConfirmation(
-        'Your claimable rewards will be claimed and sent to you. But your full rewards will be totally lost and redistributed among other participants.',
-        'Claim rewards',
-        () => {
-          trackEvent('CLAIM_REWARDS_MODAL_CONFIRM', AnalyticsEventCategory.ButtonPress, modalAnswerAnalyticsProperties);
-          void claimRewards();
-        },
-        () =>
-          trackEvent('CLAIM_REWARDS_MODAL_CANCEL', AnalyticsEventCategory.ButtonPress, modalAnswerAnalyticsProperties)
-      );
-    } else {
-      void claimRewards();
-    }
-  }, [lastStakeId, dispatch, contractAddress, tezos, msToVestingEnd, earnOpportunityItem, trackEvent]);
+        doAfterConfirmation(
+          'Your claimable rewards will be claimed and sent to you. But your full rewards will be totally lost and redistributed among other participants.',
+          'Claim rewards',
+          () => {
+            trackEvent(
+              'CLAIM_REWARDS_MODAL_CONFIRM',
+              AnalyticsEventCategory.ButtonPress,
+              modalAnswerAnalyticsProperties
+            );
+            void claimRewards();
+          },
+          () =>
+            trackEvent('CLAIM_REWARDS_MODAL_CANCEL', AnalyticsEventCategory.ButtonPress, modalAnswerAnalyticsProperties)
+        );
+      } else {
+        void claimRewards();
+      }
+    }, [lastStakeId, dispatch, contractAddress, tezos, msToVestingEnd, earnOpportunityItem, trackEvent]);
 
-  const { assetAmount: depositAmount, usdEquivalent: depositUsdEquivalent } = useAssetAmount(
-    depositAmountAtomic,
-    stakedTokenDecimals,
-    depositExchangeRate
-  );
-  const { assetAmount: claimableRewardAmount, usdEquivalent: claimableRewardUsdEquivalent } = useAssetAmount(
-    claimableRewards,
-    rewardTokenDecimals,
-    earnExchangeRate
-  );
-  const { assetAmount: fullRewardAmount, usdEquivalent: fullRewardUsdEquivalent } = useAssetAmount(
-    fullReward,
-    rewardTokenDecimals,
-    earnExchangeRate
-  );
-  const depositTokenSymbol = tokens.stakeTokens.length === 1 ? stakedToken.metadata.symbol : 'Shares';
+    const { assetAmount: depositAmount, usdEquivalent: depositUsdEquivalent } = useAssetAmount(
+      depositAmountAtomic,
+      stakedTokenDecimals,
+      depositExchangeRate
+    );
+    const { assetAmount: claimableRewardAmount, usdEquivalent: claimableRewardUsdEquivalent } = useAssetAmount(
+      claimableRewards,
+      rewardTokenDecimals,
+      earnExchangeRate
+    );
+    const { assetAmount: fullRewardAmount, usdEquivalent: fullRewardUsdEquivalent } = useAssetAmount(
+      fullReward,
+      rewardTokenDecimals,
+      earnExchangeRate
+    );
+    const depositTokenSymbol = tokens.stakeTokens.length === 1 ? stakedToken.metadata.symbol : 'Shares';
 
-  return (
-    <View style={styles.root}>
-      <View style={styles.title}>
-        <EarnOpportunityTokens {...tokens} />
-        <Text style={styles.aprLabel}>APR: {aprFormatted}</Text>
-      </View>
-      <HorizontalBorder style={styles.titleBorder} />
-      {depositAmount.isZero() ? (
-        <View style={styles.statsRow}>
-          <StatsItem
-            loading={loading}
-            title={isLiquidityBaking ? 'Your deposit:' : 'Your deposit & Rewards:'}
-            value={<FormattedAmount amount={depositAmount} style={styles.statsValue} symbol={depositTokenSymbol} />}
-            usdEquivalent={depositUsdEquivalent}
-          />
+    return (
+      <View style={styles.root}>
+        <View style={styles.title}>
+          <EarnOpportunityTokens {...tokens} />
+          <Text style={styles.aprLabel}>APR: {formatOptionalPercentage(apr ?? undefined, '-')}</Text>
         </View>
-      ) : (
-        <>
+        <HorizontalBorder style={styles.titleBorder} />
+        {depositAmount.isZero() ? (
           <View style={styles.statsRow}>
             <StatsItem
               loading={loading}
-              title={isNeedToShowMoreDetails ? 'Your deposit:' : 'Your deposit & Rewards:'}
+              title={isLiquidityBaking ? 'Your deposit:' : 'Your deposit & Rewards:'}
               value={<FormattedAmount amount={depositAmount} style={styles.statsValue} symbol={depositTokenSymbol} />}
               usdEquivalent={depositUsdEquivalent}
             />
-            {!isLiquidityBaking && isNeedToShowMoreDetails && (
+          </View>
+        ) : (
+          <>
+            <View style={styles.statsRow}>
               <StatsItem
                 loading={loading}
-                title="Claimable rewards:"
-                value={
-                  <FormattedAmount
-                    amount={claimableRewardAmount}
-                    style={styles.statsValue}
-                    symbol={rewardTokenSymbol}
-                  />
-                }
-                usdEquivalent={claimableRewardUsdEquivalent}
+                title={isNeedToShowMoreDetails ? 'Your deposit:' : 'Your deposit & Rewards:'}
+                value={<FormattedAmount amount={depositAmount} style={styles.statsValue} symbol={depositTokenSymbol} />}
+                usdEquivalent={depositUsdEquivalent}
               />
-            )}
-          </View>
-
-          {!isLiquidityBaking && isNeedToShowMoreDetails && (
-            <>
-              <Divider size={formatSize(12)} />
-              <View style={styles.statsRow}>
+              {!isLiquidityBaking && isNeedToShowMoreDetails && (
                 <StatsItem
                   loading={loading}
-                  title="Long-term rewards:"
+                  title="Claimable rewards:"
                   value={
-                    <FormattedAmount amount={fullRewardAmount} style={styles.statsValue} symbol={rewardTokenSymbol} />
+                    <FormattedAmount
+                      amount={claimableRewardAmount}
+                      style={styles.statsValue}
+                      symbol={rewardTokenSymbol}
+                    />
                   }
-                  usdEquivalent={fullRewardUsdEquivalent}
+                  usdEquivalent={claimableRewardUsdEquivalent}
                 />
-                <StatsItem
-                  loading={loading}
-                  title="Fully claimable:"
-                  value={
-                    <View style={styles.timespanValue}>
-                      {countdownTokens.map(({ unit, value }) => (
-                        <React.Fragment key={unit}>
-                          <Text style={styles.statsValue}>{value}</Text>
-                          <Divider size={formatSize(2)} />
-                          <Text style={styles.timespanUnit}>{unit}</Text>
-                          <Divider size={formatSize(6)} />
-                        </React.Fragment>
-                      ))}
-                    </View>
-                  }
-                />
-              </View>
-            </>
-          )}
-        </>
-      )}
-      {shouldShowClaimRewardsButton && (
-        <>
-          <Divider size={formatSize(16)} />
-          <Button
-            styleConfig={claimRewardsButtonConfig}
-            isFullWidth
-            disabled={claimableRewardAmount.isZero() || claimPending}
-            title={claimableRewardAmount.isZero() ? 'EARN TO CLAIM REWARDS' : 'CLAIM REWARDS'}
-            testID={ManageEarnOpportunityModalSelectors.claimRewardsButton}
-            onPress={claimRewardsIfConfirmed}
-          />
-        </>
-      )}
-    </View>
-  );
-};
+              )}
+            </View>
+
+            {!isLiquidityBaking && isNeedToShowMoreDetails && (
+              <>
+                <Divider size={formatSize(12)} />
+                <View style={styles.statsRow}>
+                  <StatsItem
+                    loading={loading}
+                    title="Long-term rewards:"
+                    value={
+                      <FormattedAmount amount={fullRewardAmount} style={styles.statsValue} symbol={rewardTokenSymbol} />
+                    }
+                    usdEquivalent={fullRewardUsdEquivalent}
+                  />
+                  <StatsItem
+                    loading={loading}
+                    title="Fully claimable:"
+                    value={
+                      <View style={styles.timespanValue}>
+                        {countdownTokens.map(({ unit, value }) => (
+                          <React.Fragment key={unit}>
+                            <Text style={styles.statsValue}>{value}</Text>
+                            <Divider size={formatSize(2)} />
+                            <Text style={styles.timespanUnit}>{unit}</Text>
+                            <Divider size={formatSize(6)} />
+                          </React.Fragment>
+                        ))}
+                      </View>
+                    }
+                  />
+                </View>
+              </>
+            )}
+          </>
+        )}
+        {shouldShowClaimRewardsButton && (
+          <>
+            <Divider size={formatSize(16)} />
+            <Button
+              styleConfig={claimRewardsButtonConfig}
+              isFullWidth
+              disabled={claimableRewardAmount.isZero() || claimPending}
+              title={claimableRewardAmount.isZero() ? 'EARN TO CLAIM REWARDS' : 'CLAIM REWARDS'}
+              testID={ManageEarnOpportunityModalSelectors.claimRewardsButton}
+              onPress={claimRewardsIfConfirmed}
+            />
+          </>
+        )}
+      </View>
+    );
+  }
+);
diff --git a/src/modals/manage-earn-opportunity-modal/details-section/index.tsx b/src/modals/manage-earn-opportunity-modal/details-section/index.tsx
index eb84e2cf9..d716c943a 100644
--- a/src/modals/manage-earn-opportunity-modal/details-section/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/details-section/index.tsx
@@ -1,4 +1,4 @@
-import React, { FC, useMemo } from 'react';
+import React, { memo, useMemo } from 'react';
 import { Text, View } from 'react-native';
 
 import { Divider } from 'src/components/divider/divider';
@@ -7,7 +7,7 @@ import { IconNameEnum } from 'src/components/icon/icon-name.enum';
 import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { formatSize } from 'src/styles/format-size';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { isFarm } from 'src/utils/earn.utils';
 
 import { DetailsCard } from '../details-card';
@@ -23,7 +23,7 @@ interface Props {
 
 const youvesSavingsTypes = [EarnOpportunityTypeEnum.YOUVES_SAVING, EarnOpportunityTypeEnum.YOUVES_STAKING];
 
-export const DetailsSection: FC<Props> = ({ earnOpportunityItem, stake, shouldShowClaimRewardsButton, loading }) => {
+export const DetailsSection = memo<Props>(({ earnOpportunityItem, stake, shouldShowClaimRewardsButton, loading }) => {
   const styles = useDetailsSectionStyles();
   const isLiquidityBaking = earnOpportunityItem.type === EarnOpportunityTypeEnum.LIQUIDITY_BAKING;
   const isKordFi = earnOpportunityItem.type === EarnOpportunityTypeEnum.KORD_FI_SAVING;
@@ -86,4 +86,4 @@ export const DetailsSection: FC<Props> = ({ earnOpportunityItem, stake, shouldSh
       />
     </>
   );
-};
+});
diff --git a/src/modals/manage-earn-opportunity-modal/index.tsx b/src/modals/manage-earn-opportunity-modal/index.tsx
index 98806a3a9..224171f8d 100644
--- a/src/modals/manage-earn-opportunity-modal/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/index.tsx
@@ -17,16 +17,17 @@ import { useBlockLevel } from 'src/hooks/use-block-level.hook';
 import { useOnRampContinueOverlay } from 'src/hooks/use-on-ramp-continue-overlay.hook';
 import { ModalsEnum, ModalsParamList } from 'src/navigator/enums/modals.enum';
 import { OnRampOverlay } from 'src/screens/wallet/on-ramp-overlay/on-ramp-overlay';
-import { loadAllFarmsActions, loadSingleFarmStakeActions } from 'src/store/farms/actions';
-import { useFarmSelector, useFarmsLoadingSelector, useFarmStakeSelector } from 'src/store/farms/selectors';
-import { loadSingleSavingStakeActions } from 'src/store/savings/actions';
+import { loadAllFarmsAction, loadSingleFarmStakeActions } from 'src/store/farms/actions';
+import { useFarm, useFarmsLoadingSelector, useFarmStakeSelector } from 'src/store/farms/selectors';
+import { loadAllSavingsAction, loadSingleSavingStakeActions } from 'src/store/savings/actions';
 import {
-  useSavingsItemSelector,
+  useSavingsItem,
   useSavingsItemsLoadingSelector,
   useSavingsItemStakeSelector
 } from 'src/store/savings/selectors';
 import { loadSwapTokensAction } from 'src/store/swap/swap-actions';
 import { useSwapTokensMetadataSelector } from 'src/store/swap/swap-selectors';
+import { useCurrentAccountPkhSelector } from 'src/store/wallet/wallet-selectors';
 import { formatSize } from 'src/styles/format-size';
 import { usePageAnalytic } from 'src/utils/analytics/use-analytics.hook';
 import { isFarm } from 'src/utils/earn.utils';
@@ -62,13 +63,14 @@ export const ManageEarnOpportunityModal: FC = () => {
   const route = useRoute<RouteProp<ModalsParamList, ModalsEnum.ManageFarmingPool | ModalsEnum.ManageSavingsPool>>();
   const { id, contractAddress } = route.params;
   const isFarmingPool = route.name === ModalsEnum.ManageFarmingPool;
-  const farm = useFarmSelector(id, contractAddress);
-  const savingsItem = useSavingsItemSelector(id, contractAddress);
+  const farm = useFarm(id, contractAddress);
+  const savingsItem = useSavingsItem(id, contractAddress);
   const earnOpportunityItem = isFarmingPool ? farm?.item : savingsItem;
   const farmIsLoading = useFarmsLoadingSelector();
   const savingsItemIsLoading = useSavingsItemsLoadingSelector();
   const earnOpportunityLoading = isFarmingPool ? farmIsLoading : savingsItemIsLoading;
   const { isLoading: swapTokensMetadataLoading } = useSwapTokensMetadataSelector();
+  const accountPkh = useCurrentAccountPkhSelector();
   const pageIsLoading = (earnOpportunityLoading && !isDefined(earnOpportunityItem)) || swapTokensMetadataLoading;
   const farmStake = useFarmStakeSelector(contractAddress);
   const savingsStake = useSavingsItemStakeSelector(contractAddress);
@@ -106,9 +108,9 @@ export const ManageEarnOpportunityModal: FC = () => {
   useEffect(() => {
     if (!isDefined(earnOpportunityItem) || prevBlockLevelRef.current !== blockLevel) {
       prevBlockLevelRef.current = blockLevel;
-      dispatch(loadAllFarmsActions.submit());
+      dispatch(isFarmingPool ? loadAllFarmsAction() : loadAllSavingsAction());
     }
-  }, [blockLevel, earnOpportunityItem, dispatch]);
+  }, [blockLevel, earnOpportunityItem, dispatch, isFarmingPool]);
 
   useEffect(() => {
     if (!isDefined(earnOpportunityItem)) {
@@ -117,15 +119,15 @@ export const ManageEarnOpportunityModal: FC = () => {
 
     dispatch(
       isFarm(earnOpportunityItem)
-        ? loadSingleFarmStakeActions.submit(earnOpportunityItem)
-        : loadSingleSavingStakeActions.submit(earnOpportunityItem)
+        ? loadSingleFarmStakeActions.submit({ farm: earnOpportunityItem, accountPkh })
+        : loadSingleSavingStakeActions.submit({ item: earnOpportunityItem, accountPkh })
     );
 
     if (!isFarm(earnOpportunityItem) && !startedLoadingTokensRef.current) {
       dispatch(loadSwapTokensAction.submit());
       startedLoadingTokensRef.current = true;
     }
-  }, [earnOpportunityItem, dispatch]);
+  }, [earnOpportunityItem, dispatch, accountPkh]);
 
   const handleDepositClick = useCallback(() => {
     const scrollViewHandle = findNodeHandle(scrollViewRef.current);
diff --git a/src/modals/manage-earn-opportunity-modal/stake-form/create-stake-operation-params.ts b/src/modals/manage-earn-opportunity-modal/stake-form/create-stake-operation-params.ts
index 835ed5cdc..572852567 100644
--- a/src/modals/manage-earn-opportunity-modal/stake-form/create-stake-operation-params.ts
+++ b/src/modals/manage-earn-opportunity-modal/stake-form/create-stake-operation-params.ts
@@ -5,7 +5,7 @@ import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { Route3Token } from 'src/interfaces/route3.interface';
 import { createKordFiStakeTransfersParams } from 'src/modals/manage-earn-opportunity-modal/stake-form/create-kord-fi-deposit-tranfer-params';
 import { TokenInterface } from 'src/token/interfaces/token.interface';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { parseTransferParamsToParamsWithKind } from 'src/utils/transfer-params.utils';
 
 import { createLiquidityBakingStakeTransfersParams } from './create-liquidity-baking-stake-transfers-params';
diff --git a/src/modals/manage-earn-opportunity-modal/stake-form/index.tsx b/src/modals/manage-earn-opportunity-modal/stake-form/index.tsx
index 2ff722166..bab302dea 100644
--- a/src/modals/manage-earn-opportunity-modal/stake-form/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/stake-form/index.tsx
@@ -16,7 +16,7 @@ import { useFarmsStakesLoadingSelector } from 'src/store/farms/selectors';
 import { formatSize } from 'src/styles/format-size';
 import { KNOWN_TOKENS_SLUGS } from 'src/token/data/token-slugs';
 import { getTokenSlug, toTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { isFarm } from 'src/utils/earn.utils';
 import { isDefined } from 'src/utils/is-defined';
 
diff --git a/src/modals/manage-earn-opportunity-modal/stake-form/use-stake-formik.ts b/src/modals/manage-earn-opportunity-modal/stake-form/use-stake-formik.ts
index ce72b3279..1fd14655e 100644
--- a/src/modals/manage-earn-opportunity-modal/stake-form/use-stake-formik.ts
+++ b/src/modals/manage-earn-opportunity-modal/stake-form/use-stake-formik.ts
@@ -22,7 +22,7 @@ import { showErrorToastByError } from 'src/toast/error-toast.utils';
 import { TEZ_TOKEN_SLUG } from 'src/token/data/tokens-metadata';
 import { emptyTezosLikeToken } from 'src/token/interfaces/token.interface';
 import { toTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { AnalyticsEventCategory } from 'src/utils/analytics/analytics-event.enum';
 import { useAnalytics } from 'src/utils/analytics/use-analytics.hook';
 import { isDefined } from 'src/utils/is-defined';
diff --git a/src/modals/manage-earn-opportunity-modal/vesting-period-disclaimers/index.tsx b/src/modals/manage-earn-opportunity-modal/vesting-period-disclaimers/index.tsx
index 9a94a96c6..3f9992ade 100644
--- a/src/modals/manage-earn-opportunity-modal/vesting-period-disclaimers/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/vesting-period-disclaimers/index.tsx
@@ -1,11 +1,11 @@
-import React, { FC, useMemo } from 'react';
+import React, { memo, useMemo } from 'react';
 import { Text } from 'react-native';
 
 import { Disclaimer } from 'src/components/disclaimer/disclaimer';
 import { Divider } from 'src/components/divider/divider';
 import { IconNameEnum } from 'src/components/icon/icon-name.enum';
 import { formatSize } from 'src/styles/format-size';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { formatTimespan, SECONDS_IN_DAY, SECONDS_IN_HOUR, SECONDS_IN_MINUTE } from 'src/utils/date.utils';
 
 import { useVestingPeriodDisclaimersStyles } from './styles';
@@ -16,7 +16,7 @@ interface Props {
 
 const NEGLIGIBLE_VESTING_PERIOD_SECONDS = 15;
 
-export const VestingPeriodDisclaimers: FC<Props> = ({ earnOpportunityItem }) => {
+export const VestingPeriodDisclaimers = memo<Props>(({ earnOpportunityItem }) => {
   const vestingPeriodSeconds = Number(earnOpportunityItem.vestingPeriodSeconds);
   const formattedVestingPeriod = useMemo(() => {
     let unit: 'hour' | 'day' | 'second' | 'minute';
@@ -63,4 +63,4 @@ export const VestingPeriodDisclaimers: FC<Props> = ({ earnOpportunityItem }) =>
       {vestingPeriodSeconds > NEGLIGIBLE_VESTING_PERIOD_SECONDS && <Divider size={formatSize(16)} />}
     </>
   );
-};
+});
diff --git a/src/modals/manage-earn-opportunity-modal/withdraw-form/create-withdraw-operation-params.ts b/src/modals/manage-earn-opportunity-modal/withdraw-form/create-withdraw-operation-params.ts
index 1b002d7ea..41b577f1b 100644
--- a/src/modals/manage-earn-opportunity-modal/withdraw-form/create-withdraw-operation-params.ts
+++ b/src/modals/manage-earn-opportunity-modal/withdraw-form/create-withdraw-operation-params.ts
@@ -3,7 +3,7 @@ import { TezosToolkit, TransferParams } from '@taquito/taquito';
 import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { getKordFiWithdrawTransferParams } from 'src/modals/manage-earn-opportunity-modal/withdraw-form/create-kordfi-withdraw-transfer-params';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { parseTransferParamsToParamsWithKind } from 'src/utils/transfer-params.utils';
 
 import { createLiquidityBakingWithdrawTransfersParams } from './create-liquidity-baking-withdraw-transfers-params';
diff --git a/src/modals/manage-earn-opportunity-modal/withdraw-form/index.tsx b/src/modals/manage-earn-opportunity-modal/withdraw-form/index.tsx
index 7fb738c70..da060e723 100644
--- a/src/modals/manage-earn-opportunity-modal/withdraw-form/index.tsx
+++ b/src/modals/manage-earn-opportunity-modal/withdraw-form/index.tsx
@@ -21,7 +21,7 @@ import { useFiatToUsdRateSelector } from 'src/store/settings/settings-selectors'
 import { formatSize } from 'src/styles/format-size';
 import { TokenInterface } from 'src/token/interfaces/token.interface';
 import { getTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { isFarm } from 'src/utils/earn.utils';
 import { isDefined } from 'src/utils/is-defined';
 import { percentageToFraction } from 'src/utils/percentage.utils';
diff --git a/src/modals/manage-earn-opportunity-modal/withdraw-form/use-tokens-options.ts b/src/modals/manage-earn-opportunity-modal/withdraw-form/use-tokens-options.ts
index 34ac294a2..f2fedbbb5 100644
--- a/src/modals/manage-earn-opportunity-modal/withdraw-form/use-tokens-options.ts
+++ b/src/modals/manage-earn-opportunity-modal/withdraw-form/use-tokens-options.ts
@@ -9,7 +9,7 @@ import { useEarnOpportunityTokens } from 'src/hooks/use-earn-opportunity-tokens'
 import { useReadOnlyTezosToolkit } from 'src/hooks/use-read-only-tezos-toolkit.hook';
 import { useSlippageSelector } from 'src/store/settings/settings-selectors';
 import { showErrorToastByError } from 'src/toast/error-toast.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { isDefined } from 'src/utils/is-defined';
 
 import { WithdrawTokenOption } from './use-withdraw-formik';
diff --git a/src/modals/manage-earn-opportunity-modal/withdraw-form/use-withdraw-formik.ts b/src/modals/manage-earn-opportunity-modal/withdraw-form/use-withdraw-formik.ts
index 964cec0e5..fe977e900 100644
--- a/src/modals/manage-earn-opportunity-modal/withdraw-form/use-withdraw-formik.ts
+++ b/src/modals/manage-earn-opportunity-modal/withdraw-form/use-withdraw-formik.ts
@@ -18,7 +18,7 @@ import { useCurrentAccountPkhSelector } from 'src/store/wallet/wallet-selectors'
 import { showErrorToastByError } from 'src/toast/error-toast.utils';
 import { emptyTezosLikeToken, TokenInterface } from 'src/token/interfaces/token.interface';
 import { getTokenSlug } from 'src/token/utils/token.utils';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { AnalyticsEventCategory } from 'src/utils/analytics/analytics-event.enum';
 import { useAnalytics } from 'src/utils/analytics/use-analytics.hook';
 import { formatTimespan, MS_IN_SECOND, SECONDS_IN_DAY } from 'src/utils/date.utils';
diff --git a/src/navigator/enums/modals.enum.ts b/src/navigator/enums/modals.enum.ts
index be8e086b5..0f6f38d9d 100644
--- a/src/navigator/enums/modals.enum.ts
+++ b/src/navigator/enums/modals.enum.ts
@@ -1,7 +1,7 @@
 import { AccountInterface, AccountBaseInterface } from 'src/interfaces/account.interface';
 import { ConfirmationModalParams } from 'src/modals/confirmation-modal/confirmation-modal.params';
 import { TokenMetadataInterface } from 'src/token/interfaces/token-metadata.interface';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 
 export enum ModalsEnum {
   Receive = 'Receive',
diff --git a/src/screens/d-apps/d-apps.tsx b/src/screens/d-apps/d-apps.tsx
index 1ed0de05f..ecb7a9a7a 100644
--- a/src/screens/d-apps/d-apps.tsx
+++ b/src/screens/d-apps/d-apps.tsx
@@ -12,7 +12,6 @@ import { Divider } from 'src/components/divider/divider';
 import { IconNameEnum } from 'src/components/icon/icon-name.enum';
 import { InsetSubstitute } from 'src/components/inset-substitute/inset-substitute';
 import { SearchInput } from 'src/components/search-input/search-input';
-import { PERCENTAGE_DECIMALS } from 'src/config/earn-opportunities';
 import { SIDEBAR_WIDTH } from 'src/config/styles';
 import { LIMIT_DAPPS_FEATURES } from 'src/config/system';
 import { useTotalBalance } from 'src/hooks/use-total-balance';
@@ -23,10 +22,9 @@ import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { useNavigation } from 'src/navigator/hooks/use-navigation.hook';
 import { loadDAppsListActions } from 'src/store/d-apps/d-apps-actions';
 import { useDAppsListSelector } from 'src/store/d-apps/d-apps-selectors';
-import { useAllFarmsSelector } from 'src/store/farms/selectors';
-import { useSavingsItemsLoadingSelector } from 'src/store/savings/selectors';
 import { formatSize } from 'src/styles/format-size';
 import { usePageAnalytic } from 'src/utils/analytics/use-analytics.hook';
+import { formatOptionalPercentage } from 'src/utils/earn-opportunities/format.utils';
 import { isString } from 'src/utils/is-string';
 
 import { DAppsSelectors } from './d-apps.selectors';
@@ -51,16 +49,13 @@ export const DApps = () => {
 
   const { width: windowWidth } = useWindowDimensions();
 
-  const { isLoading: isFarmsLoading } = useAllFarmsSelector();
-  const isSavingsLoading = useSavingsItemsLoadingSelector();
-
   const { maxApr: farmsMaxApr } = useUserFarmingStats();
   const { maxApr: savingsMaxApr } = useUserSavingsStats();
 
   const { balance } = useTotalBalance();
 
   const maxRoundedApr = useMemo(
-    () => BigNumber.max(farmsMaxApr, savingsMaxApr).toFixed(PERCENTAGE_DECIMALS),
+    () => formatOptionalPercentage(farmsMaxApr && savingsMaxApr && BigNumber.max(farmsMaxApr, savingsMaxApr)),
     [farmsMaxApr, savingsMaxApr]
   );
 
@@ -139,7 +134,7 @@ export const DApps = () => {
 
             <IntegratedDApp
               iconName={IconNameEnum.EarnDapp}
-              title={`Earn up to ${isFarmsLoading || isSavingsLoading ? '---' : maxRoundedApr}% APR`}
+              title={`Earn up to ${maxRoundedApr}% APR`}
               description="Unlock on-chain earning potential"
               onPress={() => navigate(ScreensEnum.Earn)}
               testID={DAppsSelectors.earnButton}
diff --git a/src/screens/earn/index.tsx b/src/screens/earn/index.tsx
index 1cf248854..6e554f001 100644
--- a/src/screens/earn/index.tsx
+++ b/src/screens/earn/index.tsx
@@ -1,5 +1,4 @@
 import React, { FC, useEffect } from 'react';
-import { ActivityIndicator } from 'react-native';
 import { useDispatch } from 'react-redux';
 
 import { Divider } from 'src/components/divider/divider';
@@ -8,15 +7,13 @@ import { useUserFarmingStats } from 'src/hooks/use-user-farming-stats';
 import { useUserSavingsStats } from 'src/hooks/use-user-savings-stats';
 import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { loadAllFarmsAndStakesAction } from 'src/store/farms/actions';
-import { useAllFarmsSelector } from 'src/store/farms/selectors';
 import { loadAllSavingsAndStakesAction } from 'src/store/savings/actions';
-import { useSavingsItemsLoadingSelector } from 'src/store/savings/selectors';
+import { useCurrentAccountPkhSelector } from 'src/store/wallet/wallet-selectors';
 import { formatSize } from 'src/styles/format-size';
 import { usePageAnalytic } from 'src/utils/analytics/use-analytics.hook';
 
 import { OpportunityCategoryCard } from './opportunity-category-card';
 import { EarnPageSelectors } from './selectors';
-import { useEarnPageStyles } from './styles';
 
 export const Earn: FC = () => {
   const dispatch = useDispatch();
@@ -30,46 +27,38 @@ export const Earn: FC = () => {
     totalStakedAmountInFiat: savingsTotalStakedAmountInFiat,
     maxApr: savingsMaxApr
   } = useUserSavingsStats();
-  const farms = useAllFarmsSelector();
-  const savingsLoading = useSavingsItemsLoadingSelector();
-  const styles = useEarnPageStyles();
+  const accountPkh = useCurrentAccountPkhSelector();
 
   usePageAnalytic(ScreensEnum.Earn);
 
   useEffect(() => {
-    dispatch(loadAllFarmsAndStakesAction());
-    dispatch(loadAllSavingsAndStakesAction());
-  }, []);
+    dispatch(loadAllFarmsAndStakesAction(accountPkh));
+    dispatch(loadAllSavingsAndStakesAction(accountPkh));
+  }, [accountPkh, dispatch]);
 
   return (
     <>
-      {farms.isLoading || savingsLoading ? (
-        <ActivityIndicator style={styles.loader} size="large" />
-      ) : (
-        <>
-          <Divider size={formatSize(8)} />
-          <OpportunityCategoryCard
-            title="Savings"
-            description="Earn passive income and diversify your assets on Tezos."
-            screen={ScreensEnum.Savings}
-            depositAmountInFiat={savingsTotalStakedAmountInFiat}
-            iconName={IconNameEnum.Database}
-            netApr={savingsNetApr}
-            maxApr={savingsMaxApr}
-            testID={EarnPageSelectors.SavingsCard}
-          />
-          <OpportunityCategoryCard
-            title="Farming"
-            description="Earn extra rewards by participating in farm."
-            screen={ScreensEnum.Farming}
-            depositAmountInFiat={farmsTotalStakedAmountInFiat}
-            iconName={IconNameEnum.Data}
-            netApr={farmsNetApr}
-            maxApr={farmsMaxApr}
-            testID={EarnPageSelectors.FarmingCard}
-          />
-        </>
-      )}
+      <Divider size={formatSize(8)} />
+      <OpportunityCategoryCard
+        title="Savings"
+        description="Earn passive income and diversify your assets on Tezos."
+        screen={ScreensEnum.Savings}
+        depositAmountInFiat={savingsTotalStakedAmountInFiat}
+        iconName={IconNameEnum.Database}
+        netApr={savingsNetApr}
+        maxApr={savingsMaxApr}
+        testID={EarnPageSelectors.SavingsCard}
+      />
+      <OpportunityCategoryCard
+        title="Farming"
+        description="Earn extra rewards by participating in farm."
+        screen={ScreensEnum.Farming}
+        depositAmountInFiat={farmsTotalStakedAmountInFiat}
+        iconName={IconNameEnum.Data}
+        netApr={farmsNetApr}
+        maxApr={farmsMaxApr}
+        testID={EarnPageSelectors.FarmingCard}
+      />
     </>
   );
 };
diff --git a/src/screens/earn/opportunity-category-card/index.tsx b/src/screens/earn/opportunity-category-card/index.tsx
index 46bda1c7a..ba09bd9a2 100644
--- a/src/screens/earn/opportunity-category-card/index.tsx
+++ b/src/screens/earn/opportunity-category-card/index.tsx
@@ -1,17 +1,17 @@
 import { BigNumber } from 'bignumber.js';
-import React, { FC, useCallback, useMemo } from 'react';
+import React, { memo, useCallback, useMemo } from 'react';
 import { Text, TouchableOpacity, View } from 'react-native';
 
 import { Divider } from 'src/components/divider/divider';
-import { FormattedAmount } from 'src/components/formatted-amount';
 import { HorizontalBorder } from 'src/components/horizontal-border';
 import { Icon } from 'src/components/icon/icon';
 import { IconNameEnum } from 'src/components/icon/icon-name.enum';
-import { PERCENTAGE_DECIMALS } from 'src/config/earn-opportunities';
+import { OptionalFormattedAmount } from 'src/components/optional-formatted-amount';
 import { TestIdProps } from 'src/interfaces/test-id.props';
 import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { useNavigation } from 'src/navigator/hooks/use-navigation.hook';
 import { formatSize } from 'src/styles/format-size';
+import { formatOptionalPercentage } from 'src/utils/earn-opportunities/format.utils';
 
 import { useOpportunityCategoryCardStyles } from './styles';
 
@@ -19,59 +19,55 @@ interface OpportunityCategoryCardProps extends TestIdProps {
   title: string;
   description: string;
   screen: ScreensEnum.Farming | ScreensEnum.Savings;
-  depositAmountInFiat: BigNumber;
+  depositAmountInFiat?: BigNumber;
   iconName: IconNameEnum;
-  netApr: BigNumber;
-  maxApr: BigNumber;
+  netApr?: BigNumber;
+  maxApr?: BigNumber;
 }
 
-export const OpportunityCategoryCard: FC<OpportunityCategoryCardProps> = ({
-  title,
-  description,
-  screen,
-  depositAmountInFiat,
-  iconName,
-  netApr,
-  maxApr
-}) => {
-  const { navigate } = useNavigation();
-  const styles = useOpportunityCategoryCardStyles();
+export const OpportunityCategoryCard = memo<OpportunityCategoryCardProps>(
+  ({ title, description, screen, depositAmountInFiat, iconName, netApr, maxApr }) => {
+    const { navigate } = useNavigation();
+    const styles = useOpportunityCategoryCardStyles();
 
-  const handlePress = useCallback(() => navigate(screen), [navigate, screen]);
-  const netAprFormatted = useMemo(() => netApr.toFixed(PERCENTAGE_DECIMALS), [netApr]);
-  const maxAprFormatted = useMemo(() => maxApr.toFixed(PERCENTAGE_DECIMALS), [maxApr]);
+    const handlePress = useCallback(() => navigate(screen), [navigate, screen]);
+    const netAprFormatted = useMemo(() => formatOptionalPercentage(netApr), [netApr]);
+    const maxAprFormatted = useMemo(() => formatOptionalPercentage(maxApr), [maxApr]);
 
-  return (
-    <TouchableOpacity style={styles.root} onPress={handlePress}>
-      <View style={styles.title}>
-        <Icon size={formatSize(16)} name={iconName} />
+    return (
+      <TouchableOpacity style={styles.root} onPress={handlePress}>
+        <View style={styles.title}>
+          <Icon size={formatSize(16)} name={iconName} />
+          <Divider size={formatSize(8)} />
+          <Text style={styles.titleText}>{title}</Text>
+          <Icon name={IconNameEnum.ChevronRight} size={formatSize(24)} />
+        </View>
+        <Divider size={formatSize(8)} />
+        <HorizontalBorder />
         <Divider size={formatSize(8)} />
-        <Text style={styles.titleText}>{title}</Text>
-        <Icon name={IconNameEnum.ChevronRight} size={formatSize(24)} />
-      </View>
-      <Divider size={formatSize(8)} />
-      <HorizontalBorder />
-      <Divider size={formatSize(8)} />
-      <View style={styles.footer}>
-        {depositAmountInFiat.gt(0) ? (
-          <View style={styles.leftStatsItem}>
-            <Text style={styles.statsItemLabel}>Current deposit amount:</Text>
-            <Divider size={formatSize(2)} />
-            <FormattedAmount
-              hideApproximateSign
-              isDollarValue
-              amount={depositAmountInFiat}
-              style={styles.statsItemValue}
-            />
+        <View style={styles.footer}>
+          {depositAmountInFiat?.isZero() ?? false ? (
+            <Text style={styles.description}>{description}</Text>
+          ) : (
+            <View style={styles.leftStatsItem}>
+              <Text style={styles.statsItemLabel}>Current deposit amount:</Text>
+              <Divider size={formatSize(2)} />
+              <OptionalFormattedAmount
+                hideApproximateSign
+                isDollarValue
+                amount={depositAmountInFiat}
+                style={styles.statsItemValue}
+              />
+            </View>
+          )}
+          <View style={styles.rightStatsItem}>
+            <Text style={styles.statsItemLabel}>{depositAmountInFiat?.eq(0) ?? false ? 'Max APR:' : 'Net APR:'}</Text>
+            <Text style={styles.statsItemValue}>
+              {depositAmountInFiat?.eq(0) ?? false ? maxAprFormatted : netAprFormatted}
+            </Text>
           </View>
-        ) : (
-          <Text style={styles.description}>{description}</Text>
-        )}
-        <View style={styles.rightStatsItem}>
-          <Text style={styles.statsItemLabel}>{depositAmountInFiat.gt(0) ? 'Net APR:' : 'Max APR:'}</Text>
-          <Text style={styles.statsItemValue}>{depositAmountInFiat.gt(0) ? netAprFormatted : maxAprFormatted}%</Text>
         </View>
-      </View>
-    </TouchableOpacity>
-  );
-};
+      </TouchableOpacity>
+    );
+  }
+);
diff --git a/src/screens/earn/styles.ts b/src/screens/earn/styles.ts
deleted file mode 100644
index 3968b0bda..000000000
--- a/src/screens/earn/styles.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { createUseStylesMemoized } from 'src/styles/create-use-styles';
-import { formatSize } from 'src/styles/format-size';
-
-export const useEarnPageStyles = createUseStylesMemoized(() => ({
-  loader: {
-    marginTop: formatSize(100)
-  }
-}));
diff --git a/src/screens/farming/farm-item.tsx b/src/screens/farming/farm-item.tsx
index f70919189..f3f84496a 100644
--- a/src/screens/farming/farm-item.tsx
+++ b/src/screens/farming/farm-item.tsx
@@ -10,6 +10,7 @@ import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interfa
 import { ModalsEnum } from 'src/navigator/enums/modals.enum';
 import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { useNavigation } from 'src/navigator/hooks/use-navigation.hook';
+import { useFarmStakeWasLoadingSelector } from 'src/store/farms/selectors';
 import { navigateAction } from 'src/store/root-state.actions';
 import { Farm } from 'src/types/farm';
 import { AnalyticsEventCategory } from 'src/utils/analytics/analytics-event.enum';
@@ -22,16 +23,17 @@ import { HARVEST_CONFIRMATION_TEXT } from './constants';
 interface Props {
   farm: Farm;
   lastStakeRecord?: UserStakeValueInterface;
-  stakeIsLoading: boolean;
 }
 
-export const FarmItem: FC<Props> = ({ farm, lastStakeRecord, stakeIsLoading }) => {
+export const FarmItem: FC<Props> = ({ farm, lastStakeRecord }) => {
   const { id, contractAddress } = farm;
   const dispatch = useDispatch();
   const { navigate } = useNavigation();
   const tezos = useReadOnlyTezosToolkit();
   const { trackEvent } = useAnalytics();
 
+  const stakeWasLoading = useFarmStakeWasLoadingSelector(contractAddress);
+
   const navigateToFarm = useCallback(
     () => navigate(ModalsEnum.ManageFarmingPool, { id: id, contractAddress: contractAddress }),
     [id, contractAddress, navigate]
@@ -84,7 +86,7 @@ export const FarmItem: FC<Props> = ({ farm, lastStakeRecord, stakeIsLoading }) =
       lastStakeRecord={lastStakeRecord}
       navigateToOpportunity={navigateToFarm}
       harvestRewards={harvestAssetsApi}
-      stakeIsLoading={stakeIsLoading}
+      stakeWasLoading={stakeWasLoading}
     />
   );
 };
diff --git a/src/screens/farming/index.tsx b/src/screens/farming/index.tsx
index fa3fb0dc3..9594325ec 100644
--- a/src/screens/farming/index.tsx
+++ b/src/screens/farming/index.tsx
@@ -1,5 +1,5 @@
-import React, { FC, useCallback } from 'react';
-import { ActivityIndicator, ListRenderItem } from 'react-native';
+import React, { FC, useMemo } from 'react';
+import { ActivityIndicator } from 'react-native';
 import { FlatList } from 'react-native-gesture-handler';
 
 import { DataPlaceholder } from 'src/components/data-placeholder/data-placeholder';
@@ -10,27 +10,30 @@ import { useFilteredFarmings } from 'src/hooks/use-filtered-farmings.hook';
 import { useLoadOnEachBlock } from 'src/hooks/use-load-on-each-block.hook';
 import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { loadAllFarmsAndStakesAction } from 'src/store/farms/actions';
-import { useFarmsStakesLoadingSelector, useLastFarmsStakesSelector } from 'src/store/farms/selectors';
+import { useFarmsStakesLoadingSelector, useLastFarmsStakes } from 'src/store/farms/selectors';
 import { formatSize } from 'src/styles/format-size';
 import { Farm } from 'src/types/farm';
 import { usePageAnalytic } from 'src/utils/analytics/use-analytics.hook';
+import {
+  createItemsListWithLoader,
+  earnOpportunityKeyExtractor,
+  getRenderEarnOpportunityFn
+} from 'src/utils/earn-opportunities/list.utils';
 
 import { FarmItem } from './farm-item';
 import { MainInfo } from './main-info';
 import { FarmsSelectorsEnum } from './selectors';
 import { useFarmingStyles } from './styles';
 
-const keyExtractor = ({ id, contractAddress }: Farm) => `${id}_${contractAddress}`;
-
 export const Farming: FC = () => {
-  const stakes = useLastFarmsStakesSelector();
+  const stakes = useLastFarmsStakes();
   const stakesLoading = useFarmsStakesLoadingSelector();
   const styles = useFarmingStyles();
   const {
     sortField,
     depositedOnly,
     filteredItemsList,
-    pageIsLoading,
+    shouldShowLoader,
     setSearchValue,
     handleSetSortField,
     handleToggleDepositOnly
@@ -39,11 +42,23 @@ export const Farming: FC = () => {
   usePageAnalytic(ScreensEnum.Farming);
   useLoadOnEachBlock(stakesLoading, loadAllFarmsAndStakesAction);
 
-  const renderItem = useCallback<ListRenderItem<Farm>>(
-    ({ item }) => (
-      <FarmItem farm={item} lastStakeRecord={stakes[item.contractAddress]} stakeIsLoading={stakesLoading} />
-    ),
-    [stakes, stakesLoading]
+  const renderItem = useMemo(
+    () =>
+      getRenderEarnOpportunityFn<Farm>(
+        () => (
+          <ActivityIndicator
+            style={filteredItemsList.length === 0 ? styles.emptyListLoader : styles.bottomLoader}
+            size="large"
+          />
+        ),
+        item => <FarmItem farm={item} lastStakeRecord={stakes[item.contractAddress]} />
+      ),
+    [filteredItemsList.length, stakes, styles.bottomLoader, styles.emptyListLoader]
+  );
+
+  const data = useMemo(
+    () => createItemsListWithLoader(filteredItemsList, shouldShowLoader),
+    [filteredItemsList, shouldShowLoader]
   );
 
   return (
@@ -61,27 +76,19 @@ export const Farming: FC = () => {
         handleSetSortField={handleSetSortField}
       />
       <HorizontalBorder />
-      {pageIsLoading ? (
-        <ActivityIndicator style={styles.loader} size="large" />
-      ) : (
-        <>
-          <Divider size={formatSize(8)} />
-          <FlatList
-            data={filteredItemsList}
-            keyExtractor={keyExtractor}
-            ListEmptyComponent={
-              <DataPlaceholder
-                text={
-                  Object.keys(stakes).length === 0 && depositedOnly
-                    ? 'You have no deposits in farms'
-                    : 'No records found'
-                }
-              />
+      <Divider size={formatSize(8)} />
+      <FlatList
+        data={data}
+        keyExtractor={earnOpportunityKeyExtractor}
+        ListEmptyComponent={
+          <DataPlaceholder
+            text={
+              Object.keys(stakes).length === 0 && depositedOnly ? 'You have no deposits in farms' : 'No records found'
             }
-            renderItem={renderItem}
           />
-        </>
-      )}
+        }
+        renderItem={renderItem}
+      />
     </>
   );
 };
diff --git a/src/screens/farming/main-info.tsx b/src/screens/farming/main-info.tsx
index f591a8ade..68a065a31 100644
--- a/src/screens/farming/main-info.tsx
+++ b/src/screens/farming/main-info.tsx
@@ -9,8 +9,9 @@ import { DEFAULT_AMOUNT, DEFAULT_EXCHANGE_RATE } from 'src/config/earn-opportuni
 import { useReadOnlyTezosToolkit } from 'src/hooks/use-read-only-tezos-toolkit.hook';
 import { useUserFarmingStats } from 'src/hooks/use-user-farming-stats';
 import { ConfirmationTypeEnum } from 'src/interfaces/confirm-payload/confirmation-type.enum';
+import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { ModalsEnum } from 'src/navigator/enums/modals.enum';
-import { useAllFarmsSelector, useLastFarmsStakesSelector } from 'src/store/farms/selectors';
+import { useAllFarms, useLastFarmsStakes } from 'src/store/farms/selectors';
 import { navigateAction } from 'src/store/root-state.actions';
 import { useFiatToUsdRateSelector } from 'src/store/settings/settings-selectors';
 import { isDefined } from 'src/utils/is-defined';
@@ -19,21 +20,24 @@ import { parseTransferParamsToParamsWithKind } from 'src/utils/transfer-params.u
 
 export const MainInfo: FC = () => {
   const dispatch = useDispatch();
-  const farms = useAllFarmsSelector();
-  const stakes = useLastFarmsStakesSelector();
+  const farms = useAllFarms();
+  const stakes = useLastFarmsStakes();
   const tezos = useReadOnlyTezosToolkit();
   const fiatToUsdExchangeRate = useFiatToUsdRateSelector();
 
   const stakesEntriesWithEndedRewards = useMemo(() => {
     const now = Date.now();
 
-    return Object.entries(stakes).filter(
-      ([contractAddress, stakeRecord]) =>
-        stakeRecord?.claimableRewards &&
-        new BigNumber(stakeRecord.claimableRewards).isGreaterThan(DEFAULT_AMOUNT) &&
-        (!stakeRecord.rewardsDueDate || stakeRecord.rewardsDueDate < now) &&
-        farms.data.some(farm => farm.item.contractAddress === contractAddress)
-    );
+    return Object.entries(stakes).filter((value): value is [string, UserStakeValueInterface] => {
+      const [contractAddress, stakeRecord] = value;
+
+      return (
+        isDefined(stakeRecord) &&
+        new BigNumber(stakeRecord.claimableRewards ?? DEFAULT_AMOUNT).isGreaterThan(DEFAULT_AMOUNT) &&
+        (!isDefined(stakeRecord.rewardsDueDate) || stakeRecord.rewardsDueDate < now) &&
+        farms.some(farm => farm.contractAddress === contractAddress)
+      );
+    });
   }, [stakes, farms]);
 
   const { netApr, totalStakedAmountInFiat } = useUserFarmingStats();
@@ -42,15 +46,12 @@ export const MainInfo: FC = () => {
     let result = new BigNumber(0);
 
     stakesEntriesWithEndedRewards.forEach(([address, stakeRecord]) => {
-      const farm = farms.data.find(_farm => _farm.item.contractAddress === address);
+      const farm = farms.find(_farm => _farm.contractAddress === address);
 
       if (isDefined(farm)) {
         result = result.plus(
-          mutezToTz(
-            new BigNumber(stakeRecord.claimableRewards ?? DEFAULT_AMOUNT),
-            farm.item.rewardToken.metadata.decimals
-          )
-            .multipliedBy(farm.item.earnExchangeRate ?? DEFAULT_AMOUNT)
+          mutezToTz(new BigNumber(stakeRecord.claimableRewards ?? DEFAULT_AMOUNT), farm.rewardToken.metadata.decimals)
+            .multipliedBy(farm.earnExchangeRate ?? DEFAULT_AMOUNT)
             .multipliedBy(fiatToUsdExchangeRate ?? DEFAULT_EXCHANGE_RATE)
         );
       }
diff --git a/src/screens/farming/styles.ts b/src/screens/farming/styles.ts
index 98764284a..2fd9bab93 100644
--- a/src/screens/farming/styles.ts
+++ b/src/screens/farming/styles.ts
@@ -17,7 +17,10 @@ export const useFarmingStyles = createUseStyles(({ colors, typography }) => ({
     ...typography.caption11Regular,
     color: colors.gray1
   },
-  loader: {
+  emptyListLoader: {
     marginTop: formatSize(100)
+  },
+  bottomLoader: {
+    margin: formatSize(24)
   }
 }));
diff --git a/src/screens/savings/index.tsx b/src/screens/savings/index.tsx
index 286671252..644f080c1 100644
--- a/src/screens/savings/index.tsx
+++ b/src/screens/savings/index.tsx
@@ -1,5 +1,5 @@
-import React, { FC, useCallback } from 'react';
-import { ActivityIndicator, ListRenderItem } from 'react-native';
+import React, { FC, useMemo } from 'react';
+import { ActivityIndicator } from 'react-native';
 import { FlatList } from 'react-native-gesture-handler';
 
 import { DataPlaceholder } from 'src/components/data-placeholder/data-placeholder';
@@ -11,26 +11,29 @@ import { useLoadOnEachBlock } from 'src/hooks/use-load-on-each-block.hook';
 import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
 import { ScreensEnum } from 'src/navigator/enums/screens.enum';
 import { loadAllSavingsAndStakesAction } from 'src/store/savings/actions';
-import { useSavingsStakesLoadingSelector, useSavingsStakesSelector } from 'src/store/savings/selectors';
+import { useSavingsStakesLoadingSelector, useSavingsStakes } from 'src/store/savings/selectors';
 import { formatSize } from 'src/styles/format-size';
 import { usePageAnalytic } from 'src/utils/analytics/use-analytics.hook';
+import {
+  createItemsListWithLoader,
+  earnOpportunityKeyExtractor,
+  getRenderEarnOpportunityFn
+} from 'src/utils/earn-opportunities/list.utils';
 
 import { MainInfo } from './main-info';
 import { SavingsItemCard } from './savings-item-card';
 import { SavingsSelectorsEnum } from './selectors';
 import { useSavingsStyles } from './styles';
 
-const keyExtractor = ({ id, contractAddress }: SavingsItem) => `${id}_${contractAddress}`;
-
 export const Savings: FC = () => {
-  const savingsStakes = useSavingsStakesSelector();
+  const stakes = useSavingsStakes();
   const stakesLoading = useSavingsStakesLoadingSelector();
   const styles = useSavingsStyles();
   const {
     sortField,
     depositedOnly,
     filteredItemsList,
-    pageIsLoading,
+    shouldShowLoader,
     setSearchValue,
     handleSetSortField,
     handleToggleDepositOnly
@@ -39,15 +42,23 @@ export const Savings: FC = () => {
   usePageAnalytic(ScreensEnum.Savings);
   useLoadOnEachBlock(stakesLoading, loadAllSavingsAndStakesAction);
 
-  const renderItem = useCallback<ListRenderItem<SavingsItem>>(
-    ({ item }) => (
-      <SavingsItemCard
-        item={item}
-        lastStakeRecord={savingsStakes[item.contractAddress]}
-        stakeIsLoading={stakesLoading}
-      />
-    ),
-    [savingsStakes, stakesLoading]
+  const renderItem = useMemo(
+    () =>
+      getRenderEarnOpportunityFn<SavingsItem>(
+        () => (
+          <ActivityIndicator
+            style={filteredItemsList.length === 0 ? styles.emptyListLoader : styles.bottomLoader}
+            size="large"
+          />
+        ),
+        item => <SavingsItemCard item={item} lastStakeRecord={stakes[item.contractAddress]} />
+      ),
+    [filteredItemsList.length, stakes, styles.bottomLoader, styles.emptyListLoader]
+  );
+
+  const data = useMemo(
+    () => createItemsListWithLoader(filteredItemsList, shouldShowLoader),
+    [filteredItemsList, shouldShowLoader]
   );
 
   return (
@@ -65,27 +76,20 @@ export const Savings: FC = () => {
         handleSetSortField={handleSetSortField}
       />
       <HorizontalBorder />
-      {pageIsLoading ? (
-        <ActivityIndicator style={styles.loader} size="large" />
-      ) : (
-        <>
-          <Divider size={formatSize(8)} />
-          <FlatList
-            data={filteredItemsList}
-            keyExtractor={keyExtractor}
-            ListEmptyComponent={
-              <DataPlaceholder
-                text={
-                  Object.keys(savingsStakes).length === 0 && depositedOnly
-                    ? 'You have no deposited savings'
-                    : 'No records found'
-                }
-              />
+
+      <Divider size={formatSize(8)} />
+      <FlatList
+        data={data}
+        keyExtractor={earnOpportunityKeyExtractor}
+        ListEmptyComponent={
+          <DataPlaceholder
+            text={
+              Object.keys(stakes).length === 0 && depositedOnly ? 'You have no deposited savings' : 'No records found'
             }
-            renderItem={renderItem}
           />
-        </>
-      )}
+        }
+        renderItem={renderItem}
+      />
     </>
   );
 };
diff --git a/src/screens/savings/savings-item-card.tsx b/src/screens/savings/savings-item-card.tsx
index 628921f92..115bc54f2 100644
--- a/src/screens/savings/savings-item-card.tsx
+++ b/src/screens/savings/savings-item-card.tsx
@@ -5,15 +5,16 @@ import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interf
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { ModalsEnum } from 'src/navigator/enums/modals.enum';
 import { useNavigation } from 'src/navigator/hooks/use-navigation.hook';
+import { useSavingsItemStakeWasLoadingSelector } from 'src/store/savings/selectors';
 
 interface Props {
   item: SavingsItem;
   lastStakeRecord?: UserStakeValueInterface;
-  stakeIsLoading: boolean;
 }
 
-export const SavingsItemCard: FC<Props> = ({ item, lastStakeRecord, stakeIsLoading }) => {
+export const SavingsItemCard: FC<Props> = ({ item, lastStakeRecord }) => {
   const { navigate } = useNavigation();
+  const stakeWasLoading = useSavingsItemStakeWasLoadingSelector(item.contractAddress);
 
   const navigateToOpportunity = useCallback(
     () => navigate(ModalsEnum.ManageSavingsPool, { id: item.id, contractAddress: item.contractAddress }),
@@ -25,7 +26,7 @@ export const SavingsItemCard: FC<Props> = ({ item, lastStakeRecord, stakeIsLoadi
       item={item}
       lastStakeRecord={lastStakeRecord}
       navigateToOpportunity={navigateToOpportunity}
-      stakeIsLoading={stakeIsLoading}
+      stakeWasLoading={stakeWasLoading}
     />
   );
 };
diff --git a/src/screens/savings/styles.ts b/src/screens/savings/styles.ts
index fee89faec..6885fb6fe 100644
--- a/src/screens/savings/styles.ts
+++ b/src/screens/savings/styles.ts
@@ -19,5 +19,11 @@ export const useSavingsStyles = createUseStyles(({ colors, typography }) => ({
   },
   loader: {
     marginTop: formatSize(100)
+  },
+  emptyListLoader: {
+    marginTop: formatSize(100)
+  },
+  bottomLoader: {
+    margin: formatSize(24)
   }
 }));
diff --git a/src/store/farms/actions.ts b/src/store/farms/actions.ts
index 0b7436983..21f75b260 100644
--- a/src/store/farms/actions.ts
+++ b/src/store/farms/actions.ts
@@ -1,29 +1,35 @@
 import { createAction } from '@reduxjs/toolkit';
 
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
+import { FarmsProviderEnum } from 'src/enums/farms-provider.enum';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 import { Farm } from 'src/types/farm';
 import { SingleFarmResponse } from 'src/types/single-farm-response';
 
 import { createActions } from '../create-actions';
+import { LoadableEntityState } from '../types';
 
 export const loadSingleFarmStakeActions = createActions<
-  Farm,
-  { stake: UserStakeValueInterface | undefined; farmAddress: string },
-  { farmAddress: string; error: string }
+  { farm: Farm; accountPkh: string },
+  { farmAddress: string; accountPkh: string; stake: UserStakeValueInterface | null },
+  { farmAddress: string; accountPkh: string; error: string }
 >('farms/LOAD_SINGLE_FARM_STAKE');
 
-export const loadAllFarmsAndStakesAction = createAction<void>('farms/LOAD_ALL_FARMS_AND_STAKES');
+/** Use it for loading both farms and stakes gradually */
+export const loadAllFarmsAndStakesAction = createAction<string>('farms/LOAD_ALL_FARMS_AND_STAKES');
 
-export const loadAllFarmsActions = createActions<void, Array<SingleFarmResponse>, void>('farms/LOAD_ALL_FARMS');
+/** Use it to load farms only by "all or nothing" strategy */
+export const loadAllFarmsAction = createAction<void>('farms/LOAD_ALL_FARMS');
+
+export const loadFarmsByProviderActions = createActions<
+  FarmsProviderEnum,
+  { provider: FarmsProviderEnum; data: Array<SingleFarmResponse> },
+  { provider: FarmsProviderEnum; error: string }
+>('farms/LOAD_FARMS_BY_PROVIDER');
 
-/**
- * `undefined` as the value in success payload stands for failed attempt to load stake, so the old stake should be used;
- * `null` means that a user has no stake in the farm.
- */
 export const loadAllStakesActions = createActions<
-  Array<SingleFarmResponse>,
-  Record<string, UserStakeValueInterface | nullish>,
+  { accountPkh: string; farms: Array<SingleFarmResponse> },
+  { accountPkh: string; stakes: Record<string, LoadableEntityState<UserStakeValueInterface | null | undefined>> },
   void
 >('farms/LOAD_ALL_STAKES');
 
diff --git a/src/store/farms/epics.ts b/src/store/farms/epics.ts
index d80e97fe1..69df52ee9 100644
--- a/src/store/farms/epics.ts
+++ b/src/store/farms/epics.ts
@@ -1,61 +1,62 @@
 import { combineEpics, Epic } from 'redux-observable';
-import { catchError, forkJoin, from, map, merge, mergeMap, Observable, of, switchMap } from 'rxjs';
+import { catchError, delay, exhaustMap, forkJoin, from, map, merge, mergeMap, of, switchMap } from 'rxjs';
 import { Action } from 'ts-action';
 import { ofType } from 'ts-action-operators';
 
 import { getLiquidityBakingFarm } from 'src/apis/liquidity-baking';
 import { getV3FarmsList } from 'src/apis/quipuswap-staking';
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
-import { showErrorToast, showErrorToastByError } from 'src/toast/error-toast.utils';
+import { FarmsProviderEnum } from 'src/enums/farms-provider.enum';
+import { showErrorToast } from 'src/toast/error-toast.utils';
 import { showFailedStakeLoadWarning } from 'src/toast/toast.utils';
 import { KNOWN_TOKENS_SLUGS } from 'src/token/data/token-slugs';
 import { TEZ_TOKEN_SLUG } from 'src/token/data/tokens-metadata';
 import { getAxiosQueryErrorMessage } from 'src/utils/get-axios-query-error-message';
-import { isDefined } from 'src/utils/is-defined';
 import { createReadOnlyTezosToolkit } from 'src/utils/rpc/tezos-toolkit.utils';
 import { withSelectedAccount, withSelectedRpcUrl } from 'src/utils/wallet.utils';
 
 import type { RootState } from '../types';
 
 import {
-  loadAllFarmsActions,
+  loadAllFarmsAction,
   loadAllFarmsAndStakesAction,
   loadAllStakesActions,
+  loadFarmsByProviderActions,
   loadSingleFarmStakeActions
 } from './actions';
-import { getFarmStake, GetFarmStakeError, RawStakeValue, toUserStakeValueInterface, withExchangeRates } from './utils';
+import { getFarmStake, GetFarmStakeError, toUserStakeValueInterface, withExchangeRates } from './utils';
 
-const loadSingleFarmLastStake: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadSingleFarmLastStake: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
     ofType(loadSingleFarmStakeActions.submit),
-    withSelectedAccount(state$),
     withSelectedRpcUrl(state$),
-    switchMap(([[{ payload: farm }, selectedAccount], rpcUrl]) => {
-      const tezos = createReadOnlyTezosToolkit(rpcUrl, selectedAccount);
+    mergeMap(([{ payload }, rpcUrl]) => {
+      const { farm, accountPkh } = payload;
+      const tezos = createReadOnlyTezosToolkit(rpcUrl);
 
-      return from(getFarmStake(farm, tezos, selectedAccount.publicKeyHash)).pipe(
+      return from(getFarmStake(farm, tezos, accountPkh)).pipe(
         map(stake =>
           loadSingleFarmStakeActions.success({
-            stake: isDefined(stake) ? toUserStakeValueInterface(stake, farm.vestingPeriodSeconds) : undefined,
-            farmAddress: farm.contractAddress
+            stake: stake && toUserStakeValueInterface(stake, farm.vestingPeriodSeconds),
+            farmAddress: farm.contractAddress,
+            accountPkh
           })
         ),
         catchError(err => {
-          throw new GetFarmStakeError(farm.contractAddress, (err as Error).message);
+          throw new GetFarmStakeError(farm.contractAddress, accountPkh, (err as Error).message);
         })
       );
     }),
     catchError(err => {
-      const { farmAddress } = err as GetFarmStakeError;
-      showErrorToastByError(err);
+      const { farmAddress, accountPkh, message: errorMessage } = err as GetFarmStakeError;
+      showFailedStakeLoadWarning();
 
-      return of(loadSingleFarmStakeActions.fail({ farmAddress, error: (err as Error).message }));
+      return of(loadSingleFarmStakeActions.fail({ farmAddress, accountPkh, error: errorMessage }));
     })
   );
 
-const loadAllFarms: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadAllFarms: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
-    ofType(loadAllFarmsActions.submit),
+    ofType(loadAllFarmsAction),
     withExchangeRates(state$),
     withSelectedAccount(state$),
     withSelectedRpcUrl(state$),
@@ -63,65 +64,94 @@ const loadAllFarms: Epic = (action$: Observable<Action>, state$: Observable<Root
       const tezos = createReadOnlyTezosToolkit(rpcUrl, selectedAccount);
       const { [KNOWN_TOKENS_SLUGS.tzBTC]: tzbtcExchangeRate, [TEZ_TOKEN_SLUG]: tezExchangeRate } = exchangeRates;
 
-      return forkJoin([getV3FarmsList(), getLiquidityBakingFarm(tezos, tezExchangeRate, tzbtcExchangeRate)]).pipe(
-        map(([v3Farms, lbFarm]) => loadAllFarmsActions.success([...v3Farms, lbFarm])),
-        catchError(err => {
-          showErrorToast({ description: getAxiosQueryErrorMessage(err) });
+      return forkJoin([getLiquidityBakingFarm(tezos, tezExchangeRate, tzbtcExchangeRate), getV3FarmsList()]);
+    }),
+    switchMap(([lbFarm, v3Farms]) =>
+      of(
+        loadFarmsByProviderActions.success({ data: [lbFarm], provider: FarmsProviderEnum.LiquidityBaking }),
+        loadFarmsByProviderActions.success({ data: v3Farms, provider: FarmsProviderEnum.Quipuswap })
+      )
+    ),
+    catchError(err => {
+      showErrorToast({ description: getAxiosQueryErrorMessage(err) });
 
-          return of(loadAllFarmsActions.fail());
-        })
+      return of(
+        loadFarmsByProviderActions.fail({ provider: FarmsProviderEnum.LiquidityBaking, error: (err as Error).message }),
+        loadFarmsByProviderActions.fail({ provider: FarmsProviderEnum.Quipuswap, error: (err as Error).message })
       );
     })
   );
 
-const loadAllFarmsAndLastStake: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadFarmsByProvider: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
-    ofType(loadAllFarmsAndStakesAction),
+    ofType(loadFarmsByProviderActions.submit),
     withExchangeRates(state$),
     withSelectedAccount(state$),
     withSelectedRpcUrl(state$),
-    switchMap(([[[, exchangeRates], selectedAccount], rpcUrl]) => {
+    switchMap(([[[{ payload: farmsProvider }, exchangeRates], selectedAccount], rpcUrl]) => {
       const tezos = createReadOnlyTezosToolkit(rpcUrl, selectedAccount);
       const { [KNOWN_TOKENS_SLUGS.tzBTC]: tzbtcExchangeRate, [TEZ_TOKEN_SLUG]: tezExchangeRate } = exchangeRates;
 
-      return forkJoin([getV3FarmsList(), getLiquidityBakingFarm(tezos, tezExchangeRate, tzbtcExchangeRate)]).pipe(
-        switchMap(([v3Farms, lbFarm]) => {
-          const farms = [...v3Farms, lbFarm];
-
-          return forkJoin(
-            farms.map(async ({ item: farm }) =>
-              getFarmStake(farm, tezos, selectedAccount.publicKeyHash)
-                .then((stake): [string, RawStakeValue | null] => [farm.contractAddress, stake])
-                .catch((): [string, undefined] => {
-                  console.error('Error while loading farm stakes: ', farm.contractAddress);
-                  showFailedStakeLoadWarning();
+      return from(
+        farmsProvider === FarmsProviderEnum.LiquidityBaking
+          ? getLiquidityBakingFarm(tezos, tezExchangeRate, tzbtcExchangeRate).then(lbFarm => [lbFarm])
+          : getV3FarmsList()
+      ).pipe(
+        map(data => loadFarmsByProviderActions.success({ data, provider: farmsProvider })),
+        catchError(err => {
+          showErrorToast({ description: getAxiosQueryErrorMessage(err) });
 
-                  return [farm.contractAddress, undefined];
-                })
-            )
-          ).pipe(
-            map(stakesEntries =>
-              Object.fromEntries(
-                stakesEntries.map(([farmAddress, stake]): [string, UserStakeValueInterface | null | undefined] => {
-                  const farm = farms.find(({ item }) => item.contractAddress === farmAddress);
-
-                  return [
-                    farmAddress,
-                    stake && toUserStakeValueInterface(stake, farm?.item.vestingPeriodSeconds ?? '0')
-                  ];
-                })
-              )
-            ),
-            mergeMap(stakes => merge(of(loadAllFarmsActions.success(farms)), of(loadAllStakesActions.success(stakes))))
-          );
+          return of(loadFarmsByProviderActions.fail({ provider: farmsProvider, error: (err as Error).message }));
         })
       );
-    }),
-    catchError(err => {
-      showErrorToast({ description: getAxiosQueryErrorMessage(err) });
+    })
+  );
+
+const loadAllFarmsAndStakes: Epic<Action, Action, RootState> = (action$, state$) =>
+  action$.pipe(
+    ofType(loadAllFarmsAndStakesAction),
+    withExchangeRates(state$),
+    withSelectedRpcUrl(state$),
+    exhaustMap(([[{ payload: accountPkh }, exchangeRates], rpcUrl]) => {
+      const tezos = createReadOnlyTezosToolkit(rpcUrl);
+      const { [KNOWN_TOKENS_SLUGS.tzBTC]: tzbtcExchangeRate, [TEZ_TOKEN_SLUG]: tezExchangeRate } = exchangeRates;
 
-      return of(loadAllFarmsActions.fail());
+      const makeFarmsListErrorHandler = (farmsProvider: FarmsProviderEnum) => (err: unknown) => {
+        showErrorToast({ description: getAxiosQueryErrorMessage(err) });
+
+        return of(
+          loadFarmsByProviderActions.fail({ provider: farmsProvider, error: (err as Error).message }),
+          loadAllStakesActions.fail()
+        );
+      };
+
+      return merge(
+        from(getV3FarmsList()).pipe(
+          delay(20_000),
+          switchMap(v3Farms =>
+            of(
+              loadFarmsByProviderActions.success({ data: v3Farms, provider: FarmsProviderEnum.Quipuswap }),
+              ...v3Farms.map(({ item: farm }) => loadSingleFarmStakeActions.submit({ farm, accountPkh }))
+            )
+          ),
+          catchError(makeFarmsListErrorHandler(FarmsProviderEnum.Quipuswap))
+        ),
+        from(getLiquidityBakingFarm(tezos, tezExchangeRate, tzbtcExchangeRate)).pipe(
+          switchMap(lbFarm =>
+            of(
+              loadFarmsByProviderActions.success({ data: [lbFarm], provider: FarmsProviderEnum.LiquidityBaking }),
+              loadSingleFarmStakeActions.submit({ farm: lbFarm.item, accountPkh })
+            )
+          ),
+          catchError(makeFarmsListErrorHandler(FarmsProviderEnum.LiquidityBaking))
+        )
+      );
     })
   );
 
-export const farmsEpics = combineEpics(loadSingleFarmLastStake, loadAllFarms, loadAllFarmsAndLastStake);
+export const farmsEpics = combineEpics(
+  loadSingleFarmLastStake,
+  loadAllFarms,
+  loadFarmsByProvider,
+  loadAllFarmsAndStakes
+);
diff --git a/src/store/farms/reducers.ts b/src/store/farms/reducers.ts
index 4a0816d02..a0d532196 100644
--- a/src/store/farms/reducers.ts
+++ b/src/store/farms/reducers.ts
@@ -1,92 +1,89 @@
 import { createReducer } from '@reduxjs/toolkit';
-import { omit } from 'lodash-es';
 
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
-import { isDefined } from 'src/utils/is-defined';
+import { FarmsProviderEnum } from 'src/enums/farms-provider.enum';
+import { getStakeState, setStakeState } from 'src/utils/earn-opportunities/store.utils';
 
 import { createEntity } from '../create-entity';
-import { setSelectedAccountAction } from '../wallet/wallet-actions';
 
 import {
-  loadAllFarmsActions,
+  loadFarmsByProviderActions,
   loadAllFarmsAndStakesAction,
   loadAllStakesActions,
   loadSingleFarmStakeActions,
   selectFarmsSortValueAction
 } from './actions';
-import { farmsInitialState, FarmsState, LastUserStakeInterface } from './state';
+import { farmsInitialState, FarmsState } from './state';
 
 export const farmsReducer = createReducer<FarmsState>(farmsInitialState, builder => {
-  builder.addCase(loadSingleFarmStakeActions.submit, state => ({
-    ...state,
-    lastStakes: createEntity(state.lastStakes.data, true)
-  }));
-  builder.addCase(loadSingleFarmStakeActions.success, (state, { payload: { stake, farmAddress } }) => {
-    const currentStakes = state.lastStakes.data;
-
-    const lastStakes = isDefined(stake)
-      ? {
-          ...currentStakes,
-          [farmAddress]: stake
-        }
-      : omit(currentStakes, farmAddress);
-
-    return {
-      ...state,
-      lastStakes: createEntity(lastStakes)
-    };
+  builder.addCase(loadSingleFarmStakeActions.submit, (state, { payload }) => {
+    const { farm, accountPkh } = payload;
+
+    const prevStakeState = getStakeState(state, accountPkh, farm.contractAddress);
+    setStakeState(state, accountPkh, farm.contractAddress, createEntity(prevStakeState?.data, true));
+  });
+
+  builder.addCase(loadSingleFarmStakeActions.success, (state, { payload }) => {
+    const { stake, farmAddress, accountPkh } = payload;
+
+    setStakeState(state, accountPkh, farmAddress, createEntity(stake, false));
   });
+
   builder.addCase(loadSingleFarmStakeActions.fail, (state, { payload }) => {
-    return {
-      ...state,
-      lastStakes: createEntity(state.lastStakes.data, false, payload.error)
-    };
+    const { accountPkh, farmAddress, error } = payload;
+
+    const prevStakeState = getStakeState(state, accountPkh, farmAddress);
+    setStakeState(state, accountPkh, farmAddress, createEntity(prevStakeState?.data, false, error));
   });
-  builder.addCase(loadAllFarmsAndStakesAction, state => ({
-    ...state,
-    allFarms: createEntity(state.allFarms.data, true),
-    lastStakes: createEntity(state.lastStakes.data, true)
-  }));
-  builder.addCase(loadAllFarmsActions.submit, state => ({
-    ...state,
-    allFarms: createEntity(state.allFarms.data, true)
-  }));
-  builder.addCase(loadAllFarmsActions.success, (state, { payload }) => ({
-    ...state,
-    allFarms: createEntity(payload, false)
-  }));
-  builder.addCase(loadAllFarmsActions.fail, (state, { payload }) => ({
-    ...state,
-    allFarms: createEntity(state.allFarms.data, false, payload)
-  }));
+
+  builder.addCase(loadAllFarmsAndStakesAction, (state, { payload: accountPkh }) => {
+    const previousStakes = state.stakes[accountPkh] ?? {};
+    state.stakes[accountPkh] = {};
+
+    Object.values(FarmsProviderEnum).forEach(provider => {
+      const previousFarms = state.allFarms[provider];
+      state.allFarms[provider] = createEntity(previousFarms.data, true);
+      Object.assign(
+        state.stakes[accountPkh],
+        Object.fromEntries(
+          previousFarms.data.map(({ item }) => {
+            const { contractAddress } = item;
+            const stakeState = previousStakes[contractAddress];
+
+            return [contractAddress, createEntity(stakeState?.data, true)];
+          })
+        )
+      );
+    });
+  });
+
+  builder.addCase(loadFarmsByProviderActions.submit, (state, { payload: provider }) => {
+    state.allFarms[provider] = createEntity(state.allFarms[provider].data, true);
+  });
+  builder.addCase(loadFarmsByProviderActions.success, (state, { payload }) => {
+    state.allFarms[payload.provider] = createEntity(payload.data, false);
+  });
+  builder.addCase(loadFarmsByProviderActions.fail, (state, { payload }) => {
+    state.allFarms[payload.provider] = createEntity(state.allFarms[payload.provider].data, false, payload.error);
+  });
+
   builder.addCase(loadAllStakesActions.success, (state, { payload }) => {
-    const newStakes = Object.entries(payload).reduce<LastUserStakeInterface>((acc, [farmAddress, stake]) => {
-      let newStake: UserStakeValueInterface | undefined;
-      switch (stake) {
-        case undefined:
-          newStake = state.lastStakes.data[farmAddress];
-          break;
-        case null:
-          break;
-        default:
-          newStake = stake;
-      }
-      if (isDefined(newStake)) {
-        acc[farmAddress] = newStake;
-      }
-
-      return acc;
-    }, {});
-
-    return {
-      ...state,
-      lastStakes: createEntity(newStakes)
-    };
+    const { accountPkh, stakes } = payload;
+    const prevStakes = state.stakes[accountPkh] ?? {};
+
+    const newStakes = Object.fromEntries(
+      Object.entries(stakes).map(([farmAddress, newStakeState]) => [
+        farmAddress,
+        createEntity(
+          newStakeState.data === undefined ? prevStakes[farmAddress]?.data : newStakeState.data,
+          false,
+          newStakeState.error
+        )
+      ])
+    );
+
+    state.stakes[accountPkh] = newStakes;
   });
-  builder.addCase(setSelectedAccountAction, state => ({
-    ...state,
-    lastStakes: farmsInitialState.lastStakes
-  }));
+
   builder.addCase(selectFarmsSortValueAction, (state, { payload }) => ({
     ...state,
     sortField: payload
diff --git a/src/store/farms/selectors.ts b/src/store/farms/selectors.ts
index 59e6d29a5..a631ccc50 100644
--- a/src/store/farms/selectors.ts
+++ b/src/store/farms/selectors.ts
@@ -3,16 +3,27 @@ import { useMemo } from 'react';
 import { earnOpportunitiesTypesToDisplay } from 'src/config/earn-opportunities';
 import { EarnOpportunityTypeEnum } from 'src/enums/earn-opportunity-type.enum';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { nullableEntityWasLoading } from 'src/utils/earn-opportunities/store.utils';
+import { isDefined } from 'src/utils/is-defined';
 
 import { useSelector } from '../selector';
 
-export const useFarmsLoadingSelector = () => useSelector(({ farms }) => farms.allFarms.isLoading);
+export const useAllFarmsWereLoadingSelector = () =>
+  useSelector(({ farms }) =>
+    Object.values(farms.allFarms).every(({ data, error }) => data.length > 0 || isDefined(error))
+  );
 
-export const useFarmSelector = (id: string, contractAddress: string) => {
-  const list = useSelector(({ farms }) => farms.allFarms.data);
+export const useFarmsLoadingSelector = () =>
+  useSelector(({ farms }) => Object.values(farms.allFarms).some(({ isLoading }) => isLoading));
+
+export const useFarm = (id: string, contractAddress: string) => {
+  const allFarms = useSelector(({ farms }) => farms.allFarms);
 
   return useMemo(() => {
-    const sameContractFarms = list.filter(({ item }) => item.contractAddress === contractAddress);
+    const sameContractFarms = Object.values(allFarms)
+      .map(({ data }) => data)
+      .flat()
+      .filter(({ item }) => item.contractAddress === contractAddress);
 
     // IDs of the same farms from Quipuswap API may differ
     if (sameContractFarms.length === 1) {
@@ -20,32 +31,57 @@ export const useFarmSelector = (id: string, contractAddress: string) => {
     }
 
     return sameContractFarms.find(({ item }) => item.id === id);
-  }, [list, id, contractAddress]);
+  }, [allFarms, id, contractAddress]);
 };
 
 export const useFarmStakeSelector = (farmAddress: string): UserStakeValueInterface | undefined =>
-  useSelector(({ farms }) => farms.lastStakes.data[farmAddress]);
+  useSelector(
+    ({ farms, wallet }) => farms.stakes[wallet.selectedAccountPublicKeyHash]?.[farmAddress]?.data ?? undefined
+  );
 
-export const useAllFarmsSelector = () => {
-  const allFarms = useSelector(({ farms }) => farms.allFarms);
+export const useAllFarms = () => {
+  const allFarmsStates = useSelector(({ farms }) => farms.allFarms);
 
-  return useMemo(() => {
-    const data = allFarms.data.filter(
-      farm =>
-        earnOpportunitiesTypesToDisplay.includes(farm.item.type ?? EarnOpportunityTypeEnum.DEX_TWO) &&
-        farm.item.dailyDistribution !== '0'
-    );
-
-    return {
-      data,
-      isLoading: allFarms.isLoading,
-      error: allFarms.error
-    };
-  }, [allFarms]);
+  return useMemo(
+    () =>
+      Object.values(allFarmsStates)
+        .map(({ data }) => data.map(({ item }) => item))
+        .flat()
+        .filter(
+          farm =>
+            earnOpportunitiesTypesToDisplay.includes(farm.type ?? EarnOpportunityTypeEnum.DEX_TWO) &&
+            farm.dailyDistribution !== '0'
+        ),
+    [allFarmsStates]
+  );
+};
+
+export const useLastFarmsStakes = () => {
+  const rawStakes = useSelector(({ farms, wallet }) => farms.stakes[wallet.selectedAccountPublicKeyHash]);
+
+  return useMemo(
+    () => Object.fromEntries(Object.entries(rawStakes ?? {}).map(([key, { data }]) => [key, data ?? undefined])),
+    [rawStakes]
+  );
 };
 
-export const useLastFarmsStakesSelector = () => useSelector(({ farms }) => farms.lastStakes.data);
+export const useFarmsStakesLoadingSelector = () =>
+  useSelector(({ farms, wallet }) => {
+    const accountStakes = farms.stakes[wallet.selectedAccountPublicKeyHash] ?? {};
+
+    return Object.values(accountStakes).some(({ isLoading }) => isLoading);
+  });
+
+export const useSomeFarmsStakesWereLoadingSelector = () =>
+  useSelector(({ farms, wallet }) => {
+    const accountStakes = farms.stakes[wallet.selectedAccountPublicKeyHash] ?? {};
+
+    return Object.values(accountStakes).some(nullableEntityWasLoading);
+  });
 
-export const useFarmsStakesLoadingSelector = () => useSelector(({ farms }) => farms.lastStakes.isLoading);
+export const useFarmStakeWasLoadingSelector = (farmAddress: string) =>
+  useSelector(({ farms, wallet }) =>
+    nullableEntityWasLoading(farms.stakes[wallet.selectedAccountPublicKeyHash]?.[farmAddress])
+  );
 
 export const useFarmSortFieldSelector = () => useSelector(({ farms }) => farms.sortField);
diff --git a/src/store/farms/state.mock.ts b/src/store/farms/state.mock.ts
index dc0227d4c..4b46c43ba 100644
--- a/src/store/farms/state.mock.ts
+++ b/src/store/farms/state.mock.ts
@@ -1,11 +1,12 @@
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
+import { FarmsProviderEnum } from 'src/enums/farms-provider.enum';
 
 import { createEntity } from '../create-entity';
 
 import { FarmsState } from './state';
 
 export const mockFarmsState: FarmsState = {
-  allFarms: createEntity([]),
-  lastStakes: createEntity({}),
+  allFarms: { [FarmsProviderEnum.Quipuswap]: createEntity([]), [FarmsProviderEnum.LiquidityBaking]: createEntity([]) },
+  stakes: {},
   sortField: EarnOpportunitiesSortFieldEnum.Default
 };
diff --git a/src/store/farms/state.ts b/src/store/farms/state.ts
index 70373e2a1..a1d523a89 100644
--- a/src/store/farms/state.ts
+++ b/src/store/farms/state.ts
@@ -1,19 +1,19 @@
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { FarmsProviderEnum } from 'src/enums/farms-provider.enum';
+import { UserEarnOpportunitiesStakes } from 'src/types/earn-opportunity.types';
 import { SingleFarmResponse } from 'src/types/single-farm-response';
 
 import { createEntity } from '../create-entity';
 import { LoadableEntityState } from '../types';
 
-export type LastUserStakeInterface = Record<string, UserStakeValueInterface>;
 export interface FarmsState {
-  lastStakes: LoadableEntityState<LastUserStakeInterface>;
-  allFarms: LoadableEntityState<Array<SingleFarmResponse>>;
+  stakes: Record<string, UserEarnOpportunitiesStakes>;
+  allFarms: Record<FarmsProviderEnum, LoadableEntityState<Array<SingleFarmResponse>>>;
   sortField: EarnOpportunitiesSortFieldEnum;
 }
 
 export const farmsInitialState: FarmsState = {
-  lastStakes: createEntity({}),
-  allFarms: createEntity([]),
+  stakes: {},
+  allFarms: { [FarmsProviderEnum.Quipuswap]: createEntity([]), [FarmsProviderEnum.LiquidityBaking]: createEntity([]) },
   sortField: EarnOpportunitiesSortFieldEnum.Default
 };
diff --git a/src/store/farms/utils.ts b/src/store/farms/utils.ts
index 06613beaf..5b04f2839 100644
--- a/src/store/farms/utils.ts
+++ b/src/store/farms/utils.ts
@@ -14,7 +14,7 @@ import { getBalance } from 'src/utils/token-balance.utils';
 import { ExchangeRateRecord } from '../currency/currency-state';
 import { RootState } from '../types';
 
-export interface RawStakeValue {
+interface RawStakeValue {
   lastStakeId: string;
   depositAmountAtomic: string;
   claimableRewards: string;
@@ -23,7 +23,7 @@ export interface RawStakeValue {
 }
 
 export class GetFarmStakeError extends Error {
-  constructor(public readonly farmAddress: string, message: string) {
+  constructor(public readonly farmAddress: string, public readonly accountPkh: string, message: string) {
     super(message);
   }
 }
diff --git a/src/store/savings/actions.ts b/src/store/savings/actions.ts
index fd4fd8be3..c4fdf427d 100644
--- a/src/store/savings/actions.ts
+++ b/src/store/savings/actions.ts
@@ -1,29 +1,35 @@
 import { createAction } from '@reduxjs/toolkit';
 
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
+import { SavingsProviderEnum } from 'src/enums/savings-provider.enum';
 import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
 
 import { createActions } from '../create-actions';
+import { LoadableEntityState } from '../types';
 
-export const loadAllSavingsAndStakesAction = createAction<void>('savings/LOAD_ALL_SAVINGS_AND_STAKES');
+export const loadSingleSavingStakeActions = createActions<
+  { item: SavingsItem; accountPkh: string },
+  { contractAddress: string; accountPkh: string; stake: UserStakeValueInterface | null },
+  { contractAddress: string; accountPkh: string; error: string }
+>('savings/LOAD_SINGLE_SAVING_STAKE');
+
+/** Use it for loading both savings and stakes gradually */
+export const loadAllSavingsAndStakesAction = createAction<string>('savings/LOAD_ALL_SAVINGS_AND_STAKES');
+
+/** Use it to load savings only by "all or nothing" strategy */
+export const loadAllSavingsAction = createAction<void>('savings/LOAD_ALL_SAVINGS');
 
-export const loadAllSavingsActions = createActions<void, Array<SavingsItem>, void>('savings/LOAD_ALL_FARMS');
+export const loadSavingsByProviderActions = createActions<
+  SavingsProviderEnum,
+  { provider: SavingsProviderEnum; data: Array<SavingsItem> },
+  { provider: SavingsProviderEnum; error: string }
+>('savings/LOAD_SAVINGS_BY_PROVIDER');
 
-/**
- * `undefined` as the value in success payload stands for failed attempt to load stake, so the old stake should be used;
- * `null` means that a user has no stake in the farm.
- */
 export const loadAllStakesActions = createActions<
-  Array<SavingsItem>,
-  Record<string, UserStakeValueInterface | nullish>,
+  { accountPkh: string; savings: Array<SavingsItem> },
+  { accountPkh: string; stakes: Record<string, LoadableEntityState<UserStakeValueInterface | null | undefined>> },
   void
 >('savings/LOAD_ALL_STAKES');
 
-export const loadSingleSavingStakeActions = createActions<
-  SavingsItem,
-  { stake: UserStakeValueInterface | undefined; contractAddress: string },
-  { contractAddress: string; error: string }
->('savings/LOAD_SINGLE_SAVING_STAKE');
-
 export const selectSavingsSortValueAction = createAction<EarnOpportunitiesSortFieldEnum>('savings/SELECT_SORT_VALUE');
diff --git a/src/store/savings/epics.ts b/src/store/savings/epics.ts
index 5e28e3f6d..64603c5d4 100644
--- a/src/store/savings/epics.ts
+++ b/src/store/savings/epics.ts
@@ -1,40 +1,49 @@
 import { combineEpics, Epic } from 'redux-observable';
-import { catchError, forkJoin, map, merge, mergeMap, Observable, of, switchMap } from 'rxjs';
+import { catchError, forkJoin, from, map, merge, mergeMap, of, switchMap } from 'rxjs';
 import { Action } from 'ts-action';
 import { ofType } from 'ts-action-operators';
 
-import { getKordFiItems$, getKordFiUserDeposits$ } from 'src/apis/kord-fi';
-import { getUserStake, getYouvesSavingsItems$ } from 'src/apis/youves';
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
-import { showErrorToastByError } from 'src/toast/error-toast.utils';
+import { getKordFiItems$ } from 'src/apis/kord-fi';
+import { getYouvesSavingsItems$ } from 'src/apis/youves';
+import { SavingsProviderEnum } from 'src/enums/savings-provider.enum';
+import { showErrorToast, showErrorToastByError } from 'src/toast/error-toast.utils';
 import { showFailedStakeLoadWarning } from 'src/toast/toast.utils';
-import { withSelectedAccount, withSelectedRpcUrl, withUsdToTokenRates } from 'src/utils/wallet.utils';
+import { getAxiosQueryErrorMessage } from 'src/utils/get-axios-query-error-message';
+import { withAccount, withSelectedRpcUrl, withUsdToTokenRates } from 'src/utils/wallet.utils';
 
 import { RootState } from '../types';
 
 import {
-  loadAllSavingsActions,
+  loadAllSavingsAction,
   loadAllSavingsAndStakesAction,
   loadAllStakesActions,
+  loadSavingsByProviderActions,
   loadSingleSavingStakeActions
 } from './actions';
 import { loadSingleSavingStake$ } from './utils';
 
-const loadSingleSavingLastStake: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadSingleSavingLastStake: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
     ofType(loadSingleSavingStakeActions.submit),
     withSelectedRpcUrl(state$),
-    withSelectedAccount(state$),
-    switchMap(([[{ payload: savingsItem }, rpcUrl], selectedAccount]) =>
-      loadSingleSavingStake$(savingsItem, selectedAccount, rpcUrl).pipe(
-        map(stake => loadSingleSavingStakeActions.success({ stake, contractAddress: savingsItem.contractAddress })),
+    withAccount(state$, ([{ payload }]) => payload.accountPkh),
+    mergeMap(([[{ payload }, rpcUrl], account]) =>
+      loadSingleSavingStake$(payload.item, account, rpcUrl).pipe(
+        map(stake =>
+          loadSingleSavingStakeActions.success({
+            stake,
+            contractAddress: payload.item.contractAddress,
+            accountPkh: payload.accountPkh
+          })
+        ),
         catchError(err => {
-          showErrorToastByError(err, undefined, true);
+          showFailedStakeLoadWarning();
 
           return of(
             loadSingleSavingStakeActions.fail({
-              contractAddress: savingsItem.contractAddress,
-              error: (err as Error).message
+              contractAddress: payload.item.contractAddress,
+              error: (err as Error).message,
+              accountPkh: payload.accountPkh
             })
           );
         })
@@ -42,65 +51,92 @@ const loadSingleSavingLastStake: Epic = (action$: Observable<Action>, state$: Ob
     )
   );
 
-const loadAllSavingsItems: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadAllSavingsItems: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
-    ofType(loadAllSavingsActions.submit),
+    ofType(loadAllSavingsAction),
     withSelectedRpcUrl(state$),
     withUsdToTokenRates(state$),
-    switchMap(([[, rpcUrl], rates]) => getYouvesSavingsItems$(rates, rpcUrl)),
-    map(savings => loadAllSavingsActions.success(savings)),
+    switchMap(([[, rpcUrl], rates]) => forkJoin([getYouvesSavingsItems$(rates, rpcUrl), getKordFiItems$(rates)])),
+    switchMap(([youvesSavings, kordFiSavings]) =>
+      of(
+        loadSavingsByProviderActions.success({ data: youvesSavings, provider: SavingsProviderEnum.Youves }),
+        loadSavingsByProviderActions.success({ data: kordFiSavings, provider: SavingsProviderEnum.KordFi })
+      )
+    ),
     catchError(err => {
       showErrorToastByError(err, undefined, true);
 
-      return of(loadAllSavingsActions.fail());
+      return of(
+        loadSavingsByProviderActions.fail({ provider: SavingsProviderEnum.Youves, error: (err as Error).message }),
+        loadSavingsByProviderActions.fail({ provider: SavingsProviderEnum.KordFi, error: (err as Error).message })
+      );
     })
   );
 
-const loadAllSavingsItemsAndStakes: Epic = (action$: Observable<Action>, state$: Observable<RootState>) =>
+const loadSavingsItemsByProvider: Epic<Action, Action, RootState> = (action$, state$) =>
   action$.pipe(
-    ofType(loadAllSavingsAndStakesAction),
+    ofType(loadSavingsByProviderActions.submit),
     withSelectedRpcUrl(state$),
     withUsdToTokenRates(state$),
-    switchMap(([[, rpcUrl], rates]) => forkJoin([getYouvesSavingsItems$(rates, rpcUrl), getKordFiItems$(rates)])),
+    switchMap(([[{ payload: savingsProvider }, rpcUrl], rates]) =>
+      from(
+        savingsProvider === SavingsProviderEnum.KordFi ? getKordFiItems$(rates) : getYouvesSavingsItems$(rates, rpcUrl)
+      ).pipe(
+        map(data => loadSavingsByProviderActions.success({ data, provider: savingsProvider })),
+        catchError(err => {
+          showErrorToast({ description: getAxiosQueryErrorMessage(err) });
+
+          return of(loadSavingsByProviderActions.fail({ provider: savingsProvider, error: (err as Error).message }));
+        })
+      )
+    )
+  );
+
+const loadAllSavingsItemsAndStakes: Epic<Action, Action, RootState> = (action$, state$) =>
+  action$.pipe(
+    ofType(loadAllSavingsAndStakesAction),
     withSelectedRpcUrl(state$),
-    withSelectedAccount(state$),
-    switchMap(([[[youvesSavings, kordFiSavings], rpcUrl], selectedAccount]) => {
-      if (youvesSavings.length === 0 && kordFiSavings.length === 0) {
-        throw new Error('Failed to fetch any savings items');
-      }
+    withUsdToTokenRates(state$),
+    switchMap(([[{ payload: accountPkh }, rpcUrl], rates]) => {
+      const makeSavingsListErrorHandler = (savingsProvider: SavingsProviderEnum) => (err: unknown) => {
+        showErrorToast({ description: getAxiosQueryErrorMessage(err) });
 
-      return forkJoin([
-        forkJoin(
-          youvesSavings.map(savingsItem =>
-            getUserStake(selectedAccount, savingsItem.id, savingsItem.type, rpcUrl)
-              .then((stake): [string, UserStakeValueInterface | undefined] => [savingsItem.contractAddress, stake])
-              .catch((): [string, nullish] => {
-                console.error('Error while loading saving stakes: ', savingsItem.contractAddress);
-                showFailedStakeLoadWarning();
+        return of(
+          loadSavingsByProviderActions.fail({ provider: savingsProvider, error: (err as Error).message }),
+          loadAllStakesActions.fail()
+        );
+      };
 
-                return [savingsItem.contractAddress, null];
-              })
-          )
+      return merge(
+        getYouvesSavingsItems$(rates, rpcUrl).pipe(
+          switchMap(youvesSavings =>
+            of(
+              loadSavingsByProviderActions.success({ data: youvesSavings, provider: SavingsProviderEnum.Youves }),
+              ...youvesSavings.map(savingsItem =>
+                loadSingleSavingStakeActions.submit({ item: savingsItem, accountPkh })
+              )
+            )
+          ),
+          catchError(makeSavingsListErrorHandler(SavingsProviderEnum.Youves))
         ),
-        getKordFiUserDeposits$(selectedAccount.publicKeyHash)
-      ]).pipe(
-        map(([youvesStakesEntries, kordFiStakesEntries]) => ({
-          ...Object.fromEntries(youvesStakesEntries),
-          ...kordFiStakesEntries
-        })),
-        mergeMap(stakes =>
-          merge(
-            of(loadAllSavingsActions.success([...youvesSavings, ...kordFiSavings])),
-            of(loadAllStakesActions.success(stakes))
-          )
+        getKordFiItems$(rates).pipe(
+          switchMap(kordFiSavings =>
+            of(
+              loadSavingsByProviderActions.success({ data: kordFiSavings, provider: SavingsProviderEnum.KordFi }),
+              ...kordFiSavings.map(savingsItem =>
+                loadSingleSavingStakeActions.submit({ item: savingsItem, accountPkh })
+              )
+            )
+          ),
+          catchError(makeSavingsListErrorHandler(SavingsProviderEnum.KordFi))
         )
       );
-    }),
-    catchError(err => {
-      showErrorToastByError(err, undefined, true);
-
-      return of(loadAllSavingsActions.fail(), loadAllStakesActions.fail());
     })
   );
 
-export const savingsEpics = combineEpics(loadSingleSavingLastStake, loadAllSavingsItems, loadAllSavingsItemsAndStakes);
+export const savingsEpics = combineEpics(
+  loadSingleSavingLastStake,
+  loadAllSavingsItems,
+  loadSavingsItemsByProvider,
+  loadAllSavingsItemsAndStakes
+);
diff --git a/src/store/savings/reducers.ts b/src/store/savings/reducers.ts
index 69239b553..9ae8a8b8e 100644
--- a/src/store/savings/reducers.ts
+++ b/src/store/savings/reducers.ts
@@ -1,65 +1,90 @@
 import { createReducer } from '@reduxjs/toolkit';
 
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
-import { isDefined } from 'src/utils/is-defined';
+import { SavingsProviderEnum } from 'src/enums/savings-provider.enum';
+import { getStakeState, setStakeState } from 'src/utils/earn-opportunities/store.utils';
 
 import { createEntity } from '../create-entity';
-import { setSelectedAccountAction } from '../wallet/wallet-actions';
 
 import {
-  loadAllSavingsActions,
   loadAllSavingsAndStakesAction,
   loadAllStakesActions,
+  loadSavingsByProviderActions,
+  loadSingleSavingStakeActions,
   selectSavingsSortValueAction
 } from './actions';
-import { savingsInitialState, SavingsState, UserStakeInterface } from './state';
+import { savingsInitialState, SavingsState } from './state';
 
 export const savingsReducer = createReducer<SavingsState>(savingsInitialState, builder => {
-  builder.addCase(loadAllSavingsAndStakesAction, state => ({
-    ...state,
-    allSavingsItems: createEntity(state.allSavingsItems.data, true),
-    stakes: createEntity(state.stakes.data, true)
-  }));
-  builder.addCase(loadAllSavingsActions.submit, state => ({
-    ...state,
-    allSavingsItems: createEntity(state.allSavingsItems.data, true)
-  }));
-  builder.addCase(loadAllSavingsActions.success, (state, { payload }) => ({
-    ...state,
-    allSavingsItems: createEntity(payload, false)
-  }));
-  builder.addCase(loadAllSavingsActions.fail, (state, { payload }) => ({
-    ...state,
-    allSavingsItems: createEntity(state.allSavingsItems.data, false, payload)
-  }));
+  builder.addCase(loadSingleSavingStakeActions.submit, (state, { payload }) => {
+    const { item, accountPkh } = payload;
+
+    const prevStakeState = getStakeState(state, accountPkh, item.contractAddress);
+    setStakeState(state, accountPkh, item.contractAddress, createEntity(prevStakeState?.data, true));
+  });
+
+  builder.addCase(loadSingleSavingStakeActions.success, (state, { payload }) => {
+    const { stake, contractAddress, accountPkh } = payload;
+
+    setStakeState(state, accountPkh, contractAddress, createEntity(stake, false));
+  });
+
+  builder.addCase(loadSingleSavingStakeActions.fail, (state, { payload }) => {
+    const { accountPkh, contractAddress, error } = payload;
+
+    const prevStakeState = getStakeState(state, accountPkh, contractAddress);
+    setStakeState(state, accountPkh, contractAddress, createEntity(prevStakeState?.data, false, error));
+  });
+
+  builder.addCase(loadAllSavingsAndStakesAction, (state, { payload: accountPkh }) => {
+    const previousStakes = state.stakes[accountPkh] ?? {};
+    state.stakes[accountPkh] = {};
+
+    Object.values(SavingsProviderEnum).forEach(provider => {
+      const previousSavingsItems = state.allSavingsItems[provider];
+      state.allSavingsItems[provider] = createEntity(previousSavingsItems.data, true);
+      Object.assign(
+        state.stakes[accountPkh],
+        Object.fromEntries(
+          previousSavingsItems.data.map(({ contractAddress }) => {
+            const stakeState = previousStakes[contractAddress];
+
+            return [contractAddress, createEntity(stakeState?.data, true)];
+          })
+        )
+      );
+    });
+  });
+
+  builder.addCase(loadSavingsByProviderActions.submit, (state, { payload: provider }) => {
+    state.allSavingsItems[provider] = createEntity(state.allSavingsItems[provider].data, true);
+  });
+  builder.addCase(loadSavingsByProviderActions.success, (state, { payload }) => {
+    state.allSavingsItems[payload.provider] = createEntity(payload.data, false);
+  });
+  builder.addCase(loadSavingsByProviderActions.fail, (state, { payload }) => {
+    state.allSavingsItems[payload.provider] = createEntity(
+      state.allSavingsItems[payload.provider].data,
+      false,
+      payload.error
+    );
+  });
+
   builder.addCase(loadAllStakesActions.success, (state, { payload }) => {
-    const newStakes = Object.entries(payload).reduce<UserStakeInterface>((acc, [savingAddress, stake]) => {
-      let newStake: UserStakeValueInterface | undefined;
-      switch (stake) {
-        case undefined:
-          break;
-        case null:
-          newStake = state.stakes.data[savingAddress];
-          break;
-        default:
-          newStake = stake;
-      }
-      if (isDefined(newStake)) {
-        acc[savingAddress] = newStake;
-      }
-
-      return acc;
-    }, {});
-
-    return {
-      ...state,
-      stakes: createEntity(newStakes)
-    };
+    const { accountPkh, stakes } = payload;
+    const prevStakes = state.stakes[accountPkh] ?? {};
+
+    state.stakes[accountPkh] = Object.fromEntries(
+      Object.entries(stakes).map(([itemAddress, newStakeState]) => [
+        itemAddress,
+        createEntity(
+          newStakeState.data === undefined ? prevStakes[itemAddress]?.data : newStakeState.data,
+          false,
+          newStakeState.error
+        )
+      ])
+    );
   });
-  builder.addCase(setSelectedAccountAction, state => ({
-    ...state,
-    stakes: savingsInitialState.stakes
-  }));
+
   builder.addCase(selectSavingsSortValueAction, (state, { payload }) => ({
     ...state,
     sortField: payload
diff --git a/src/store/savings/selectors.ts b/src/store/savings/selectors.ts
index a12287f07..114a29a7f 100644
--- a/src/store/savings/selectors.ts
+++ b/src/store/savings/selectors.ts
@@ -1,27 +1,75 @@
 import { useMemo } from 'react';
 
 import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { nullableEntityWasLoading } from 'src/utils/earn-opportunities/store.utils';
+import { isDefined } from 'src/utils/is-defined';
 
 import { useSelector } from '../selector';
 
-export const useSavingsItemSelector = (id: string, contractAddress: string) => {
-  const list = useSelector(({ savings }) => savings.allSavingsItems.data);
+export const useAllSavingsItemsWereLoadingSelector = () =>
+  useSelector(({ savings }) =>
+    Object.values(savings.allSavingsItems).every(({ data, error }) => data.length > 0 || isDefined(error))
+  );
+
+export const useSavingsItem = (id: string, contractAddress: string) => {
+  const allSavings = useSelector(({ savings }) => savings.allSavingsItems);
 
   return useMemo(
-    () => list.find(item => item.id === id && item.contractAddress === contractAddress),
-    [list, id, contractAddress]
+    () =>
+      Object.values(allSavings)
+        .map(({ data }) => data)
+        .flat()
+        .find(item => item.id === id && item.contractAddress === contractAddress),
+    [allSavings, id, contractAddress]
   );
 };
 
-export const useSavingsItemStakeSelector = (farmAddress: string): UserStakeValueInterface | undefined =>
-  useSelector(({ savings }) => savings.stakes.data[farmAddress]);
+export const useSavingsItemsLoadingSelector = () =>
+  useSelector(({ savings }) => Object.values(savings.allSavingsItems).some(({ isLoading }) => isLoading));
+
+export const useSavingsItemStakeSelector = (itemAddress: string): UserStakeValueInterface | undefined =>
+  useSelector(
+    ({ savings, wallet }) => savings.stakes[wallet.selectedAccountPublicKeyHash]?.[itemAddress]?.data ?? undefined
+  );
+
+export const useSavingsItems = () => {
+  const allSavingsItemsStates = useSelector(({ savings }) => savings.allSavingsItems);
 
-export const useSavingsItemsLoadingSelector = () => useSelector(({ savings }) => savings.allSavingsItems.isLoading);
+  return useMemo(
+    () =>
+      Object.values(allSavingsItemsStates)
+        .map(({ data }) => data)
+        .flat(),
+    [allSavingsItemsStates]
+  );
+};
 
-export const useSavingsItemsSelector = () => useSelector(({ savings }) => savings.allSavingsItems.data);
+export const useSavingsStakes = () => {
+  const rawStakes = useSelector(({ savings, wallet }) => savings.stakes[wallet.selectedAccountPublicKeyHash]);
 
-export const useSavingsStakesSelector = () => useSelector(({ savings }) => savings.stakes.data);
+  return useMemo(
+    () => Object.fromEntries(Object.entries(rawStakes ?? {}).map(([key, { data }]) => [key, data ?? undefined])),
+    [rawStakes]
+  );
+};
 
 export const useSavingsSortFieldSelector = () => useSelector(({ savings }) => savings.sortField);
 
-export const useSavingsStakesLoadingSelector = () => useSelector(({ savings }) => savings.stakes.isLoading);
+export const useSavingsStakesLoadingSelector = () =>
+  useSelector(({ savings, wallet }) => {
+    const accountStakes = savings.stakes[wallet.selectedAccountPublicKeyHash] ?? {};
+
+    return Object.values(accountStakes).some(({ isLoading }) => isLoading);
+  });
+
+export const useSomeSavingsStakesWereLoadingSelector = () =>
+  useSelector(({ savings, wallet }) => {
+    const accountStakes = savings.stakes[wallet.selectedAccountPublicKeyHash] ?? {};
+
+    return Object.values(accountStakes).some(nullableEntityWasLoading);
+  });
+
+export const useSavingsItemStakeWasLoadingSelector = (itemAddress: string) =>
+  useSelector(({ savings, wallet }) =>
+    nullableEntityWasLoading(savings.stakes[wallet.selectedAccountPublicKeyHash]?.[itemAddress])
+  );
diff --git a/src/store/savings/state.mock.ts b/src/store/savings/state.mock.ts
index a094e9ae8..2143a05fe 100644
--- a/src/store/savings/state.mock.ts
+++ b/src/store/savings/state.mock.ts
@@ -1,11 +1,12 @@
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
+import { SavingsProviderEnum } from 'src/enums/savings-provider.enum';
 
 import { createEntity } from '../create-entity';
 
 import { SavingsState } from './state';
 
 export const mockSavingsState: SavingsState = {
-  stakes: createEntity({}),
-  allSavingsItems: createEntity([]),
+  stakes: {},
+  allSavingsItems: { [SavingsProviderEnum.Youves]: createEntity([]), [SavingsProviderEnum.KordFi]: createEntity([]) },
   sortField: EarnOpportunitiesSortFieldEnum.Default
 };
diff --git a/src/store/savings/state.ts b/src/store/savings/state.ts
index 0862473a4..5a1073db5 100644
--- a/src/store/savings/state.ts
+++ b/src/store/savings/state.ts
@@ -1,19 +1,19 @@
 import { EarnOpportunitiesSortFieldEnum } from 'src/enums/earn-opportunities-sort-fields.enum';
+import { SavingsProviderEnum } from 'src/enums/savings-provider.enum';
 import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
-import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { UserEarnOpportunitiesStakes } from 'src/types/earn-opportunity.types';
 
 import { createEntity } from '../create-entity';
 import { LoadableEntityState } from '../types';
 
-export type UserStakeInterface = Record<string, UserStakeValueInterface>;
 export interface SavingsState {
-  stakes: LoadableEntityState<UserStakeInterface>;
-  allSavingsItems: LoadableEntityState<Array<SavingsItem>>;
+  stakes: Record<string, UserEarnOpportunitiesStakes>;
+  allSavingsItems: Record<SavingsProviderEnum, LoadableEntityState<Array<SavingsItem>>>;
   sortField: EarnOpportunitiesSortFieldEnum;
 }
 
 export const savingsInitialState: SavingsState = {
-  stakes: createEntity({}),
-  allSavingsItems: createEntity([]),
+  stakes: {},
+  allSavingsItems: { [SavingsProviderEnum.Youves]: createEntity([]), [SavingsProviderEnum.KordFi]: createEntity([]) },
   sortField: EarnOpportunitiesSortFieldEnum.Default
 };
diff --git a/src/store/savings/utils.ts b/src/store/savings/utils.ts
index 3c0ec8108..63c241a1e 100644
--- a/src/store/savings/utils.ts
+++ b/src/store/savings/utils.ts
@@ -1,4 +1,4 @@
-import { from, of, switchMap } from 'rxjs';
+import { from, of, map, switchMap } from 'rxjs';
 
 import { getKordFiUserDeposits$ } from 'src/apis/kord-fi';
 import { getUserStake } from 'src/apis/youves';
@@ -11,7 +11,9 @@ export const loadSingleSavingStake$ = (savingsItem: SavingsItem, selectedAccount
     switchMap(item => {
       switch (item.type) {
         case EarnOpportunityTypeEnum.KORD_FI_SAVING:
-          return getKordFiUserDeposits$(selectedAccount.publicKeyHash);
+          return getKordFiUserDeposits$(selectedAccount.publicKeyHash).pipe(
+            map(deposits => deposits[item.contractAddress])
+          );
         default:
           return from(getUserStake(selectedAccount, item.id, item.type, rpcUrl));
       }
diff --git a/src/types/earn-opportunity.type.ts b/src/types/earn-opportunity.type.ts
deleted file mode 100644
index 68cb7df6e..000000000
--- a/src/types/earn-opportunity.type.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
-
-import { Farm } from './farm';
-
-export type EarnOpportunity = Farm | SavingsItem;
diff --git a/src/types/earn-opportunity.types.ts b/src/types/earn-opportunity.types.ts
new file mode 100644
index 000000000..88a5defe6
--- /dev/null
+++ b/src/types/earn-opportunity.types.ts
@@ -0,0 +1,12 @@
+import { SavingsItem } from 'src/interfaces/earn-opportunity/savings-item.interface';
+import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { LoadableEntityState } from 'src/store/types';
+
+import { Farm } from './farm';
+
+export type EarnOpportunity = Farm | SavingsItem;
+
+export type UserEarnOpportunitiesStakes = Record<
+  string,
+  LoadableEntityState<UserStakeValueInterface | null | undefined>
+>;
diff --git a/src/utils/earn-opportunities/format.utils.ts b/src/utils/earn-opportunities/format.utils.ts
new file mode 100644
index 000000000..d80adcc72
--- /dev/null
+++ b/src/utils/earn-opportunities/format.utils.ts
@@ -0,0 +1,8 @@
+import { BigNumber } from 'bignumber.js';
+
+import { PERCENTAGE_DECIMALS } from 'src/config/earn-opportunities';
+
+export const formatOptionalPercentage = (percentage: BigNumber.Value | undefined, emptyValueStr = '---') =>
+  percentage === undefined || new BigNumber(percentage).isNaN()
+    ? emptyValueStr
+    : `${new BigNumber(percentage).toFixed(PERCENTAGE_DECIMALS)}%`;
diff --git a/src/utils/earn-opportunities/list.utils.ts b/src/utils/earn-opportunities/list.utils.ts
new file mode 100644
index 000000000..7cb8f3a98
--- /dev/null
+++ b/src/utils/earn-opportunities/list.utils.ts
@@ -0,0 +1,25 @@
+import { ListRenderItem } from 'react-native';
+
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
+
+const LOADER_PLACEHOLDER = 'loader-placeholder';
+
+export const earnOpportunityKeyExtractor = (item: EarnOpportunity | typeof LOADER_PLACEHOLDER) =>
+  item === LOADER_PLACEHOLDER ? LOADER_PLACEHOLDER : `${item.id}_${item.contractAddress}`;
+
+export const getRenderEarnOpportunityFn =
+  <T extends EarnOpportunity>(
+    renderPlaceholder: () => JSX.Element,
+    renderItem: (item: T) => JSX.Element
+  ): ListRenderItem<T | typeof LOADER_PLACEHOLDER> =>
+  ({ item }) =>
+    item === LOADER_PLACEHOLDER ? renderPlaceholder() : renderItem(item);
+
+export const createItemsListWithLoader = <T extends EarnOpportunity>(
+  items: T[],
+  shouldShowLoader: boolean
+): Array<T | typeof LOADER_PLACEHOLDER> => {
+  const initialItems: Array<T | typeof LOADER_PLACEHOLDER> = items;
+
+  return shouldShowLoader ? initialItems.concat(LOADER_PLACEHOLDER) : initialItems;
+};
diff --git a/src/utils/earn-opportunities/store.utils.ts b/src/utils/earn-opportunities/store.utils.ts
new file mode 100644
index 000000000..57a450860
--- /dev/null
+++ b/src/utils/earn-opportunities/store.utils.ts
@@ -0,0 +1,32 @@
+import { Draft } from '@reduxjs/toolkit';
+
+import { UserStakeValueInterface } from 'src/interfaces/user-stake-value.interface';
+import { FarmsState } from 'src/store/farms/state';
+import { SavingsState } from 'src/store/savings/state';
+import { LoadableEntityState } from 'src/store/types';
+
+import { isDefined } from '../is-defined';
+
+export const nullableEntityWasLoading = <T>(entity: LoadableEntityState<T | null | undefined> | undefined) => {
+  return isDefined(entity) && (isDefined(entity.error) || entity.data !== undefined);
+};
+
+export const getStakeState = (
+  state: Draft<SavingsState | FarmsState>,
+  accountPkh: string,
+  contractAddress: string
+): Draft<LoadableEntityState<UserStakeValueInterface | null | undefined>> | undefined =>
+  state.stakes[accountPkh]?.[contractAddress];
+
+export const setStakeState = (
+  state: Draft<SavingsState | FarmsState>,
+  accountPkh: string,
+  contractAddress: string,
+  stake: LoadableEntityState<UserStakeValueInterface | null | undefined>
+) => {
+  if (!isDefined(state.stakes[accountPkh])) {
+    state.stakes[accountPkh] = {};
+  }
+
+  state.stakes[accountPkh][contractAddress] = stake;
+};
diff --git a/src/utils/earn.utils.ts b/src/utils/earn.utils.ts
index ffccd9932..35666382d 100644
--- a/src/utils/earn.utils.ts
+++ b/src/utils/earn.utils.ts
@@ -9,7 +9,7 @@ import { EarnOpportunityToken } from 'src/interfaces/earn-opportunity/earn-oppor
 import { StakesValueInterface } from 'src/interfaces/earn.interface';
 import { TokenMetadataInterface, TokenStandardsEnum } from 'src/token/interfaces/token-metadata.interface';
 import { TokenInterface } from 'src/token/interfaces/token.interface';
-import { EarnOpportunity } from 'src/types/earn-opportunity.type';
+import { EarnOpportunity } from 'src/types/earn-opportunity.types';
 import { Farm } from 'src/types/farm';
 
 import { calculateTimeDiffInSeconds } from './date.utils';
diff --git a/src/utils/rpc/tezos-toolkit.utils.ts b/src/utils/rpc/tezos-toolkit.utils.ts
index 844c44db5..d671260dd 100644
--- a/src/utils/rpc/tezos-toolkit.utils.ts
+++ b/src/utils/rpc/tezos-toolkit.utils.ts
@@ -7,6 +7,8 @@ import memoize from 'memoizee';
 import { ReadOnlySignerPayload } from 'src/types/read-only-signer-payload';
 import { ReadOnlySigner } from 'src/utils/read-only.signer.util';
 
+import { isDefined } from '../is-defined';
+
 import { getFastRpcClient } from './fast-rpc';
 
 const michelEncoder = new MichelCodecPacker();
@@ -22,11 +24,13 @@ export const createTezosToolkit = (rpcUrl: string) => {
 };
 
 export const createReadOnlyTezosToolkit = memoize(
-  (rpcUrl: string, sender: ReadOnlySignerPayload) => {
+  (rpcUrl: string, sender?: ReadOnlySignerPayload) => {
     const readOnlyTezosToolkit = createTezosToolkit(rpcUrl);
-    readOnlyTezosToolkit.setSignerProvider(new ReadOnlySigner(sender.publicKeyHash, sender.publicKey));
+    if (isDefined(sender)) {
+      readOnlyTezosToolkit.setSignerProvider(new ReadOnlySigner(sender.publicKeyHash, sender.publicKey));
+    }
 
     return readOnlyTezosToolkit;
   },
-  { normalizer: ([rpcUrl, sender]) => `${rpcUrl}_${sender.publicKeyHash}`, max: 10 }
+  { normalizer: ([rpcUrl, sender]) => `${rpcUrl}_${sender?.publicKeyHash}`, max: 10 }
 );
diff --git a/src/utils/wallet.utils.ts b/src/utils/wallet.utils.ts
index 972cb256f..f6a446ef9 100644
--- a/src/utils/wallet.utils.ts
+++ b/src/utils/wallet.utils.ts
@@ -33,6 +33,18 @@ export const withSelectedAccount =
       })
     );
 
+export const withAccount =
+  <T>(state$: Observable<RootState>, getAccountPkh: (value: T) => string) =>
+  (observable$: Observable<T>) =>
+    observable$.pipe(
+      withLatestFrom(state$, (value, { wallet }): [T, AccountInterface] => {
+        const account =
+          wallet.accounts.find(({ publicKeyHash }) => publicKeyHash === getAccountPkh(value)) ?? emptyAccount;
+
+        return [value, account];
+      })
+    );
+
 export const withOnRampOverlayState =
   <T>(state$: Observable<RootState>) =>
   (observable$: Observable<T>) =>