Updated on 2026-08-14

2025-12-05 14:27:19 +03:00 · 2025-12-05 14:27:19 +03:00 · 94a6b98f54
commit 94a6b98f54
parent d99d5ba674 def92569d3
237 changed files with 2879 additions and 1365 deletions
--- a/app/src/androidTest/kotlin/com/tangem/tests/send/addressScreen/RecentBlockTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/send/addressScreen/RecentBlockTest.kt
@ -276,7 +276,10 @@ class RecentBlockTest : BaseTestCase() {
            }
            step("Swipe up") {
                waitForIdle()
-                swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                onSendAddressScreen {
+                    swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                    swipeVertical(SwipeDirection.UP, startHeightRatio = 0.6f)
+                }
            }
            step("Check recent address item №7") {
                checkRecentAddressItem(address = recipientAddressBase + "f", description = recentTransactionAmount2)
--- a/app/src/androidTest/kotlin/com/tangem/tests/send/warnings/SolanaWarningsTest.kt
+++ b/app/src/androidTest/kotlin/com/tangem/tests/send/warnings/SolanaWarningsTest.kt
@ -22,7 +22,7 @@ class SolanaWarningsTest : BaseTestCase() {
    private val tokenName = "Solana"
    private val amountToLeaveLessThanRent = "0.0016941"
    private val amountToLeaveGreaterThanRent = "0.0000941"
-    private val amountToLeaveRentOnly = "0.00168934"
+    private val amountToLeaveRentOnly = "0.001689338"
    private val rentAmount = "SOL 0.00089088"

    private val invalidAmountTitle = getResourceString(R.string.send_notification_invalid_amount_title)
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -19,7 +19,7 @@
    <uses-feature android:name="android.hardware.camera.autofocus" />
    <uses-feature
        android:name="android.hardware.nfc"
-        android:required="true" />
+        android:required="false" />

    <queries>
        <intent>
--- a/app/src/main/java/com/tangem/tap/TangemApplication.kt
+++ b/app/src/main/java/com/tangem/tap/TangemApplication.kt
@ -328,7 +328,7 @@ open class TangemApplication : Application(), ImageLoaderFactory, Configuration.

        ExceptionHandler.append(blockchainExceptionHandler)

-        if (LogConfig.network.blockchainSdkNetwork) {
+        if (LogConfig.network.isBlockchainSdkNetworkLogEnabled) {
            BlockchainSdkRetrofitBuilder.interceptors = listOf(
                createNetworkLoggingInterceptor(),
                ChuckerInterceptor(this),
--- a/app/src/main/java/com/tangem/tap/common/analytics/DefaultTrackingContextProxy.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/DefaultTrackingContextProxy.kt
@ -25,8 +25,6 @@ internal class DefaultTrackingContextProxy(private val abTestsManager: ABTestsMa
    override fun setContext(scanResponse: ScanResponse) {
        val userWalletId = UserWalletIdBuilder.scanResponse(scanResponse).build()

-        Analytics.setContext(userWalletId, scanResponse)
-
        abTestsManager.setUserProperties(
            userId = calculateUserIdHash(userWalletId),
            batch = scanResponse.card.batchId,
@ -73,6 +71,12 @@ internal class DefaultTrackingContextProxy(private val abTestsManager: ABTestsMa
        Analytics.removeContext()
    }

+    override fun proceedWithContext(userWallet: UserWallet, action: () -> Unit) {
+        setContext(userWallet)
+        action()
+        eraseContext()
+    }
+
    private fun calculateUserIdHash(userWalletId: UserWalletId?): String? {
        return userWalletId?.value
            ?.calculateSha256()
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/amplitude/AmplitudeAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/amplitude/AmplitudeAnalyticsHandler.kt
@ -29,7 +29,7 @@ class AmplitudeAnalyticsHandler(
    class Builder : AnalyticsHandlerBuilder {
        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler {
            return AmplitudeAnalyticsHandler(
-                client = if (data.logConfig.amplitude) {
+                client = if (data.logConfig.isAmplitudeLogEnabled) {
                    AmplitudeLogClient(data.jsonConverter)
                } else {
                    AmplitudeClient(data.application, data.config.amplitudeApiKey)
--- a/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseAnalyticsHandler.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/handlers/firebase/FirebaseAnalyticsHandler.kt
@ -49,7 +49,7 @@ class FirebaseAnalyticsHandler(
    class Builder : AnalyticsHandlerBuilder {
        override fun build(data: AnalyticsHandlerBuilder.Data): AnalyticsHandler? = when {
            !data.isDebug -> FirebaseClient()
-            data.isDebug && data.logConfig.firebase -> FirebaseLogClient(data.jsonConverter)
+            data.isDebug && data.logConfig.isFirebaseLogEnabled -> FirebaseLogClient(data.jsonConverter)
            else -> null
        }?.let { FirebaseAnalyticsHandler(it) }
    }
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/CardContextInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/CardContextInterceptor.kt
@ -30,6 +30,7 @@ class CardContextInterceptor(

    override fun canBeAppliedTo(event: AnalyticsEvent): Boolean {
        return when (event) {
+            is IntroductionProcess.ButtonScanCardLegacy -> false
            is IntroductionProcess.ButtonScanCard -> false
            else -> true
        }
--- a/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/HotWalletContextInterceptor.kt
+++ b/app/src/main/java/com/tangem/tap/common/analytics/paramsInterceptor/HotWalletContextInterceptor.kt
@ -14,6 +14,9 @@ class HotWalletContextInterceptor(

    override fun intercept(params: MutableMap<String, String>) {
        params[AnalyticsParam.PRODUCT_TYPE] = AnalyticsParam.ProductType.MobileWallet.value
+        params.remove(AnalyticsParam.BATCH)
+        params.remove(AnalyticsParam.FIRMWARE)
+        params.remove(AnalyticsParam.CURRENCY)
    }

    companion object {
--- a/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/AccountDomainModule.kt
@ -67,11 +67,13 @@ internal object AccountDomainModule {
        accountsCRUDRepository: AccountsCRUDRepository,
        mainAccountTokensMigration: MainAccountTokensMigration,
        cryptoCurrencyBalanceFetcher: CryptoCurrencyBalanceFetcher,
+        singleAccountListFetcher: SingleAccountListFetcher,
    ): RecoverCryptoPortfolioUseCase {
        return RecoverCryptoPortfolioUseCase(
            crudRepository = accountsCRUDRepository,
            mainAccountTokensMigration = mainAccountTokensMigration,
            cryptoCurrencyBalanceFetcher = cryptoCurrencyBalanceFetcher,
+            singleAccountListFetcher = singleAccountListFetcher,
        )
    }

--- a/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt
@ -12,6 +12,7 @@ import com.tangem.domain.settings.repositories.SettingsRepository
 import com.tangem.domain.staking.StakingIdFactory
 import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
 import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
 import com.tangem.features.hotwallet.HotWalletFeatureToggles
@ -65,6 +66,7 @@ object MarketsDomainModule {
    fun provideSaveMarketTokensUseCase(
        derivationsRepository: DerivationsRepository,
        marketsTokenRepository: MarketsTokenRepository,
+        walletManagersFacade: WalletManagersFacade,
        currenciesRepository: CurrenciesRepository,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
@ -75,6 +77,7 @@ object MarketsDomainModule {
        return SaveMarketTokensUseCase(
            derivationsRepository = derivationsRepository,
            marketsTokenRepository = marketsTokenRepository,
+            walletManagersFacade = walletManagersFacade,
            currenciesRepository = currenciesRepository,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
--- a/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/NFTDomainModule.kt
@ -1,11 +1,11 @@
 package com.tangem.tap.di.domain

 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
-import com.tangem.domain.account.status.supplier.SingleAccountStatusListSupplier
 import com.tangem.domain.account.supplier.SingleAccountListSupplier
 import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
 import com.tangem.domain.nft.*
 import com.tangem.domain.nft.repository.NFTRepository
+import com.tangem.domain.nft.utils.NFTCleaner
 import com.tangem.domain.quotes.single.SingleQuoteStatusFetcher
 import com.tangem.domain.quotes.single.SingleQuoteStatusSupplier
 import com.tangem.domain.tokens.MultiWalletCryptoCurrenciesSupplier
@ -27,12 +27,12 @@ internal object NFTDomainModule {
    fun providesGetNFTCollectionsUseCase(
        currenciesRepository: CurrenciesRepository,
        nftRepository: NFTRepository,
-        singleAccountStatusListSupplier: SingleAccountStatusListSupplier,
+        singleAccountListSupplier: SingleAccountListSupplier,
        accountsFeatureToggles: AccountsFeatureToggles,
    ): GetNFTCollectionsUseCase = GetNFTCollectionsUseCase(
        currenciesRepository = currenciesRepository,
        nftRepository = nftRepository,
-        singleAccountStatusListSupplier = singleAccountStatusListSupplier,
+        singleAccountListSupplier = singleAccountListSupplier,
        accountsFeatureToggles = accountsFeatureToggles,
    )

@ -67,12 +67,12 @@ internal object NFTDomainModule {
    @Singleton
    fun providesGetNFTAvailableNetworksUseCase(
        nftRepository: NFTRepository,
-        singleAccountStatusListSupplier: SingleAccountStatusListSupplier,
+        singleAccountListSupplier: SingleAccountListSupplier,
        currenciesRepository: CurrenciesRepository,
    ): GetNFTNetworksUseCase = GetNFTNetworksUseCase(
        currenciesRepository = currenciesRepository,
        nftRepository = nftRepository,
-        singleAccountStatusListSupplier = singleAccountStatusListSupplier,
+        singleAccountListSupplier = singleAccountListSupplier,
    )

    @Provides
@ -126,13 +126,13 @@ internal object NFTDomainModule {
    @Singleton
    fun provideDisableWalletNFTUseCase(
        walletsRepository: WalletsRepository,
-        nftRepository: NFTRepository,
        multiWalletCryptoCurrenciesSupplier: MultiWalletCryptoCurrenciesSupplier,
+        nftCleaner: NFTCleaner,
    ): DisableWalletNFTUseCase {
        return DisableWalletNFTUseCase(
            walletsRepository = walletsRepository,
-            nftRepository = nftRepository,
            multiWalletCryptoCurrenciesSupplier = multiWalletCryptoCurrenciesSupplier,
+            nftCleaner = nftCleaner,
        )
    }

@ -145,13 +145,13 @@ internal object NFTDomainModule {
    @Provides
    @Singleton
    fun provideClearNFTCacheUseCase(
-        nftRepository: NFTRepository,
+        nftCleaner: NFTCleaner,
        currenciesRepository: CurrenciesRepository,
        accountsFeatureToggles: AccountsFeatureToggles,
        singleAccountListSupplier: SingleAccountListSupplier,
    ): ObserveAndClearNFTCacheIfNeedUseCase {
        return ObserveAndClearNFTCacheIfNeedUseCase(
-            nftRepository = nftRepository,
+            nftCleaner = nftCleaner,
            currenciesRepository = currenciesRepository,
            accountsFeatureToggles = accountsFeatureToggles,
            singleAccountListSupplier = singleAccountListSupplier,
--- a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
@ -20,7 +20,10 @@ import com.tangem.domain.staking.single.SingleYieldBalanceSupplier
 import com.tangem.domain.tokens.*
 import com.tangem.domain.tokens.operations.BaseCurrencyStatusOperations
 import com.tangem.domain.tokens.operations.CachedCurrenciesStatusesOperations
-import com.tangem.domain.tokens.repository.*
+import com.tangem.domain.tokens.repository.CurrenciesRepository
+import com.tangem.domain.tokens.repository.CurrencyChecksRepository
+import com.tangem.domain.tokens.repository.TokenReceiveWarningsViewedRepository
+import com.tangem.domain.tokens.repository.YieldSupplyWarningsViewedRepository
 import com.tangem.domain.tokens.wallet.WalletBalanceFetcher
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.tap.domain.tokens.DefaultTokensFeatureToggles
@ -40,6 +43,7 @@ internal object TokensDomainModule {
    @Singleton
    fun provideAddCryptoCurrenciesUseCase(
        currenciesRepository: CurrenciesRepository,
+        walletManagersFacade: WalletManagersFacade,
        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
        multiQuoteStatusFetcher: MultiQuoteStatusFetcher,
        singleYieldBalanceFetcher: SingleYieldBalanceFetcher,
@ -48,6 +52,7 @@ internal object TokensDomainModule {
    ): AddCryptoCurrenciesUseCase {
        return AddCryptoCurrenciesUseCase(
            currenciesRepository = currenciesRepository,
+            walletManagersFacade = walletManagersFacade,
            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
            multiQuoteStatusFetcher = multiQuoteStatusFetcher,
            singleYieldBalanceFetcher = singleYieldBalanceFetcher,
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
@ -7,6 +7,7 @@ import com.tangem.common.authentication.storage.AuthenticatedStorage
 import com.tangem.common.json.TangemSdkAdapter
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.scan.serialization.*
@ -124,6 +125,8 @@ internal object UserWalletsListManagerModule {
        appPreferencesStore: AppPreferencesStore,
        hotWalletAccessCodeAttemptsRepository: HotWalletAccessCodeAttemptsRepository,
        tangemHotSdk: TangemHotSdk,
+        trackingContextProxy: TrackingContextProxy,
+        analyticsEventHandler: AnalyticsEventHandler,
    ): UserWalletsListRepository {
        val moshi = buildMoshi()
        val secureStorage = buildSecureStorage(applicationContext = applicationContext)
@ -171,6 +174,8 @@ internal object UserWalletsListManagerModule {
            savePersistentInformation = ProviderSuspend { true }, // Always save persistent information for now
            hotWalletAccessCodeAttemptsRepository = hotWalletAccessCodeAttemptsRepository,
            tangemHotSdk = tangemHotSdk,
+            trackingContextProxy = trackingContextProxy,
+            analyticsEventHandler = analyticsEventHandler,
        )
    }

--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/DefaultUserWalletsListRepository.kt
@ -7,6 +7,9 @@ import arrow.core.raise.either
 import arrow.core.right
 import com.tangem.common.*
 import com.tangem.common.core.TangemSdkError
+import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.models.Basic
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.datasource.local.preferences.AppPreferencesStore
 import com.tangem.datasource.local.preferences.PreferencesKeys
 import com.tangem.datasource.local.preferences.utils.getSyncOrDefault
@ -50,6 +53,8 @@ internal class DefaultUserWalletsListRepository(
    private val appPreferencesStore: AppPreferencesStore,
    private val hotWalletAccessCodeAttemptsRepository: HotWalletAccessCodeAttemptsRepository,
    private val tangemHotSdk: TangemHotSdk,
+    private val trackingContextProxy: TrackingContextProxy,
+    private val analyticsEventHandler: AnalyticsEventHandler,
 ) : UserWalletsListRepository {

    override val userWallets = MutableStateFlow<List<UserWallet>?>(null)
@ -235,6 +240,7 @@ internal class DefaultUserWalletsListRepository(
        when (unlockMethod) {
            UserWalletsListRepository.UnlockMethod.Biometric -> {
                unlockAllWallets().bind()
+                trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Biometric)
                select(userWalletId)
            }
            UserWalletsListRepository.UnlockMethod.AccessCode -> {
@ -263,7 +269,10 @@ internal class DefaultUserWalletsListRepository(
                removePasswordAttempts(userWallet)

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
-                    .doOnSuccess { sensitiveInfo -> updateWallets { it?.updateWith(sensitiveInfo) } }
+                    .doOnSuccess { sensitiveInfo ->
+                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        trackSignInEvent(userWallet, Basic.SignedIn.SignInType.AccessCode)
+                    }
                    .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
            }
            is UserWalletsListRepository.UnlockMethod.Scan -> {
@ -291,7 +300,10 @@ internal class DefaultUserWalletsListRepository(
                )

                sensitiveInformationRepository.getAll(listOf(encryptionKey))
-                    .doOnSuccess { sensitiveInfo -> updateWallets { it?.updateWith(sensitiveInfo) } }
+                    .doOnSuccess { sensitiveInfo ->
+                        updateWallets { it?.updateWith(sensitiveInfo) }
+                        trackSignInEvent(userWallet, Basic.SignedIn.SignInType.Card)
+                    }
                    .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
            }
        }
@ -332,6 +344,9 @@ internal class DefaultUserWalletsListRepository(
        sensitiveInformationRepository.getAll(allKeys)
            .doOnSuccess { sensitiveInfo ->
                updateWallets { wallets -> wallets?.updateWith(sensitiveInfo) }
+                selectedUserWallet.value?.let {
+                    trackSignInEvent(it, Basic.SignedIn.SignInType.Biometric)
+                }
            }
            .doOnFailure { error -> raise(UnlockWalletError.UnableToUnlock.RawException(error)) }
    }
@ -508,4 +523,15 @@ internal class DefaultUserWalletsListRepository(

        return lastOrNull()
    }
+
+    private fun trackSignInEvent(userWallet: UserWallet, type: Basic.SignedIn.SignInType) {
+        trackingContextProxy.proceedWithContext(userWallet) {
+            analyticsEventHandler.send(
+                event = Basic.SignedIn(
+                    signInType = type,
+                    walletsCount = userWallets.value?.size ?: 0,
+                ),
+            )
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/repository/UserWalletEncryptionKeysRepository.kt
@ -4,6 +4,7 @@ import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.Types
 import com.tangem.common.authentication.storage.AuthenticatedStorage
+import com.tangem.common.core.TangemSdkError
 import com.tangem.common.services.secure.SecureStorage
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.hot.sdk.android.crypto.AESEncryptionProtocol
@ -96,7 +97,13 @@ internal class UserWalletEncryptionKeysRepository(
            StorageKey.UserWalletEncryptionKey(userWalletId).name
        }

-        authenticatedStorage.get(keys).mapNotNull {
+        val result = authenticatedStorage.get(keys)
+
+        if (keys.isNotEmpty() && result.isEmpty()) {
+            throw TangemSdkError.KeystoreInvalidated(Exception("Keys is empty"))
+        }
+
+        result.mapNotNull {
            it.value.decodeToKey()
        }
    }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreen.kt
@ -16,6 +16,7 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.tooling.preview.Preview
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
@ -24,6 +25,9 @@ import com.tangem.tap.features.details.ui.common.DetailsMainButton
 import com.tangem.tap.features.details.ui.common.SettingsScreensScaffold
 import com.tangem.wallet.R

+private const val CARD_PLACEHOLDER_SECONDARY_ROTATION = -15f
+private const val CARD_PLACEHOLDER_PRIMARY_ROTATION = -1f
+
@Composable
 internal fun CardSettingsScreen(state: CardSettingsScreenState, modifier: Modifier = Modifier) {
    val isCardReadingNeeded = state.cardDetails == null
@ -42,74 +46,85 @@ internal fun CardSettingsScreen(state: CardSettingsScreenState, modifier: Modifi
    )
 }

-@Suppress("MagicNumber")
@Composable
 private fun CardSettingsReadCard(onScanCardClick: () -> Unit) {
    Column(
-        modifier = Modifier.fillMaxSize(),
+        modifier = Modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState()),
    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(bottom = TangemTheme.dimens.spacing40)
-                .testTag(DeviceSettingsScreenTestTags.IMAGE_BLOCK),
-        ) {
-            Image(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(
-                        start = TangemTheme.dimens.spacing80,
-                        end = TangemTheme.dimens.spacing80,
-                        top = TangemTheme.dimens.spacing70,
-                    )
-                    .rotate(-15f),
-                painter = painterResource(id = R.drawable.card_placeholder_secondary),
-                contentDescription = null,
-                contentScale = ContentScale.FillWidth,
-            )
-            Image(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(
-                        start = TangemTheme.dimens.spacing60,
-                        end = TangemTheme.dimens.spacing60,
-                    )
-                    .rotate(-1f),
-                painter = painterResource(id = R.drawable.card_placeholder_black),
-                contentDescription = null,
-                contentScale = ContentScale.FillWidth,
-            )
-        }
+        CardPlaceholderImages()
        Spacer(modifier = Modifier.weight(1f))
-        Column(
+        ScanCardContent(onScanCardClick = onScanCardClick)
+    }
+}
+
+@Composable
+private fun CardPlaceholderImages() {
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(bottom = TangemTheme.dimens.spacing40)
+            .testTag(DeviceSettingsScreenTestTags.IMAGE_BLOCK),
+    ) {
+        Image(
            modifier = Modifier
                .fillMaxWidth()
                .padding(
-                    start = TangemTheme.dimens.spacing16,
-                    end = TangemTheme.dimens.spacing16,
-                    bottom = TangemTheme.dimens.spacing32,
-                ),
-        ) {
-            Text(
-                text = stringResourceSafe(id = R.string.scan_card_settings_title),
-                color = TangemTheme.colors.text.primary1,
-                style = TangemTheme.typography.h3,
-            )
-            Spacer(modifier = Modifier.size(TangemTheme.dimens.size20))
-            Text(
-                text = stringResourceSafe(id = R.string.scan_card_settings_message),
-                color = TangemTheme.colors.text.secondary,
-                style = TangemTheme.typography.body1,
-                modifier = Modifier
-                    .verticalScroll(rememberScrollState())
-                    .weight(weight = 1f, fill = false),
-            )
-            Spacer(modifier = Modifier.size(TangemTheme.dimens.size32))
-            DetailsMainButton(
-                title = stringResourceSafe(id = R.string.scan_card_settings_button),
-                onClick = onScanCardClick,
-            )
-        }
+                    start = TangemTheme.dimens.spacing80,
+                    end = TangemTheme.dimens.spacing80,
+                    top = TangemTheme.dimens.spacing70,
+                )
+                .rotate(CARD_PLACEHOLDER_SECONDARY_ROTATION),
+            painter = painterResource(id = R.drawable.card_placeholder_secondary),
+            contentDescription = null,
+            contentScale = ContentScale.FillWidth,
+        )
+        Image(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = TangemTheme.dimens.spacing60,
+                    end = TangemTheme.dimens.spacing60,
+                )
+                .rotate(CARD_PLACEHOLDER_PRIMARY_ROTATION),
+            painter = painterResource(id = R.drawable.card_placeholder_black),
+            contentDescription = null,
+            contentScale = ContentScale.FillWidth,
+        )
+    }
+}
+
+@Composable
+private fun ScanCardContent(onScanCardClick: () -> Unit) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                start = TangemTheme.dimens.spacing16,
+                end = TangemTheme.dimens.spacing16,
+                bottom = TangemTheme.dimens.spacing32,
+            ),
+    ) {
+        Text(
+            text = stringResourceSafe(id = R.string.scan_card_settings_title),
+            color = TangemTheme.colors.text.primary1,
+            style = TangemTheme.typography.h3,
+        )
+        Spacer(modifier = Modifier.size(TangemTheme.dimens.size20))
+        Text(
+            text = stringResourceSafe(id = R.string.scan_card_settings_message),
+            color = TangemTheme.colors.text.secondary,
+            style = TangemTheme.typography.body1,
+            modifier = Modifier
+                .verticalScroll(rememberScrollState())
+                .weight(weight = 1f, fill = false),
+        )
+        Spacer(modifier = Modifier.size(TangemTheme.dimens.size32))
+        DetailsMainButton(
+            title = stringResourceSafe(id = R.string.scan_card_settings_button),
+            onClick = onScanCardClick,
+        )
    }
 }

--- a/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/cardsettings/CardSettingsScreenState.kt
@ -1,9 +1,7 @@
 package com.tangem.tap.features.details.ui.cardsettings

-import androidx.annotation.StringRes
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.ReadOnlyComposable
-import com.tangem.core.ui.extensions.stringResourceSafe
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.wrappedList
 import com.tangem.tap.features.details.redux.SecurityOption
 import com.tangem.tap.features.details.ui.securitymode.toTitleRes
 import com.tangem.wallet.R
@ -32,7 +30,7 @@ internal sealed class CardInfo(

    class SignedHashes(hashes: String) : CardInfo(
        titleRes = TextReference.Res(R.string.details_row_title_signed_hashes),
-        subtitle = TextReference.Res(R.string.details_row_subtitle_signed_hashes_format, hashes),
+        subtitle = TextReference.Res(R.string.details_row_subtitle_signed_hashes_format, wrappedList(hashes)),
    )

    class SecurityMode(securityOption: SecurityOption, clickable: Boolean) : CardInfo(
@ -47,7 +45,7 @@ internal sealed class CardInfo(
        isClickable = true,
    )

-    class AccessCodeRecovery(val isEnabled: Boolean) : CardInfo(
+    class AccessCodeRecovery(isEnabled: Boolean) : CardInfo(
        titleRes = TextReference.Res(R.string.card_settings_access_code_recovery_title),
        subtitle = if (isEnabled) {
            TextReference.Res(R.string.common_enabled)
@ -62,22 +60,4 @@ internal sealed class CardInfo(
        subtitle = description,
        isClickable = true,
    )
-}
-
-// TODO("Remove and use the same from coreUI")
-internal sealed interface TextReference {
-    class Res(@StringRes val id: Int, val formatArgs: List<Any> = emptyList()) : TextReference {
-        constructor(@StringRes id: Int, vararg formatArgs: Any) : this(id, formatArgs.toList())
-    }
-
-    class Str(val value: String) : TextReference
-}
-
-@Composable
-@ReadOnlyComposable
-internal fun TextReference.resolveReference(): String {
-    return when (this) {
-        is TextReference.Res -> stringResourceSafe(this.id, *this.formatArgs.toTypedArray())
-        is TextReference.Str -> this.value
-    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/common/utils/ResetToFactory.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/common/utils/ResetToFactory.kt
@ -1,7 +1,7 @@
 package com.tangem.tap.features.details.ui.common.utils

 import com.tangem.domain.card.CardTypesResolver
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.wallet.R

 internal fun getResetToFactoryDescription(
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreen.kt
@ -17,8 +17,8 @@ import com.tangem.core.ui.extensions.stringResourceSafe
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
 import com.tangem.core.ui.test.ResetCardScreenTestTags
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
-import com.tangem.tap.features.details.ui.cardsettings.resolveReference
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.tap.features.details.ui.common.DetailsMainButton
 import com.tangem.tap.features.details.ui.common.SettingsScreensScaffold
 import com.tangem.wallet.R
@ -198,7 +198,7 @@ private fun ResetButton(enabled: Boolean, onResetButtonClick: () -> Unit) {
 }

@Composable
-private fun CommonResetDialog(dialog: ResetCardScreenState.Dialog) {
+private fun CommonResetDialog(dialog: ResetCardDialog) {
    BasicDialog(
        title = stringResourceSafe(dialog.titleResId),
        message = stringResourceSafe(dialog.messageResId),
--- a/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/resetcard/ResetCardScreenState.kt
@ -1,7 +1,7 @@
 package com.tangem.tap.features.details.ui.resetcard

 import androidx.annotation.StringRes
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.wallet.R

 internal data class ResetCardScreenState(
--- a/app/src/main/java/com/tangem/tap/features/welcome/model/WelcomeModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/model/WelcomeModel.kt
@ -10,7 +10,7 @@ import com.tangem.core.navigation.finisher.AppFinisher
 import com.tangem.domain.wallets.legacy.UserWalletsListError
 import com.tangem.tap.common.analytics.events.SignIn
 import com.tangem.tap.common.redux.global.GlobalAction
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.tap.features.welcome.component.WelcomeComponent
 import com.tangem.tap.features.welcome.redux.WelcomeAction
 import com.tangem.tap.features.welcome.redux.WelcomeState
--- a/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/redux/WelcomeMiddleware.kt
@ -58,7 +58,7 @@ internal class WelcomeMiddleware {
            .doOnSuccess { selectedUserWallet ->
                sendSignedInAnalyticsEvent(
                    userWallet = selectedUserWallet,
-                    signInType = Basic.SignedIn.SignInType.Biometric,
+                    signInType = Basic.SignedInLegacy.SignInType.Biometric,
                )

                store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
@ -80,7 +80,7 @@ internal class WelcomeMiddleware {
                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Error(error))
                }
                .doOnSuccess {
-                    sendSignedInAnalyticsEvent(userWallet, signInType = Basic.SignedIn.SignInType.Card)
+                    sendSignedInAnalyticsEvent(userWallet, signInType = Basic.SignedInLegacy.SignInType.Card)

                    store.dispatchNavigationAction { replaceAll(AppRoute.Wallet) }
                    store.dispatchWithMain(WelcomeAction.ProceedWithCard.Success)
@ -89,9 +89,7 @@ internal class WelcomeMiddleware {
        }
    }

-    private fun sendSignedInAnalyticsEvent(userWallet: UserWallet, signInType: Basic.SignedIn.SignInType) {
-        // TODO [REDACTED_TASK_KEY] [Hot Wallet] Analytics
-
+    private fun sendSignedInAnalyticsEvent(userWallet: UserWallet, signInType: Basic.SignedInLegacy.SignInType) {
        if (userWallet !is UserWallet.Cold) {
            return
        }
@ -108,7 +106,7 @@ internal class WelcomeMiddleware {
            val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)

            Analytics.send(
-                event = Basic.SignedIn(
+                event = Basic.SignedInLegacy(
                    currency = currency,
                    batch = scanResponse.card.batchId,
                    signInType = signInType,
--- a/app/src/main/java/com/tangem/tap/features/welcome/ui/WelcomeScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/ui/WelcomeScreenState.kt
@ -1,6 +1,6 @@
 package com.tangem.tap.features.welcome.ui

-import com.tangem.tap.features.details.ui.cardsettings.TextReference
+import com.tangem.core.ui.extensions.TextReference
 import com.tangem.tap.features.welcome.ui.model.WarningModel

 internal data class WelcomeScreenState(
--- a/app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreen.kt
+++ b/app/src/main/java/com/tangem/tap/features/welcome/ui/components/WelcomeScreen.kt
@ -18,8 +18,8 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider
 import androidx.compose.ui.unit.dp
 import com.tangem.core.ui.res.TangemTheme
 import com.tangem.core.ui.res.TangemThemePreview
-import com.tangem.tap.features.details.ui.cardsettings.TextReference
-import com.tangem.tap.features.details.ui.cardsettings.resolveReference
+import com.tangem.core.ui.extensions.TextReference
+import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.tap.features.welcome.component.WelcomeComponent
 import com.tangem.tap.features.welcome.component.impl.PreviewWelcomeComponent
 import com.tangem.tap.features.welcome.ui.WelcomeScreenState
--- a/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
+++ b/app/src/main/java/com/tangem/tap/network/auth/DefaultAuthProvider.kt
@ -51,7 +51,9 @@ internal class DefaultAuthProvider(
                ApiEnvironment.DEV_2,
                ApiEnvironment.DEV_3,
                -> environmentConfigStorage.getConfigSync().tangemApiKeyDev
-                ApiEnvironment.STAGE -> environmentConfigStorage.getConfigSync().tangemApiKeyStage
+                ApiEnvironment.STAGE_2,
+                ApiEnvironment.STAGE,
+                -> environmentConfigStorage.getConfigSync().tangemApiKeyStage
                ApiEnvironment.PROD -> environmentConfigStorage.getConfigSync().tangemApiKey
            } ?: error("No tangem tech api config provided")
        }
--- a/app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt
+++ b/app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt
@ -10,6 +10,9 @@ import com.arkivanov.essenty.lifecycle.subscribe
 import com.google.android.material.snackbar.Snackbar
 import com.tangem.common.routing.AppRoute
 import com.tangem.common.routing.entity.InitScreenLaunchMode
+import com.tangem.core.analytics.api.AnalyticsEventHandler
+import com.tangem.core.analytics.models.Basic
+import com.tangem.core.analytics.utils.TrackingContextProxy
 import com.tangem.core.decompose.context.AppComponentContext
 import com.tangem.core.decompose.context.child
 import com.tangem.core.decompose.context.childByContext
@ -23,6 +26,7 @@ import com.tangem.domain.common.wallets.UserWalletsListRepository
 import com.tangem.domain.models.wallet.isLocked
 import com.tangem.domain.onboarding.repository.OnboardingRepository
 import com.tangem.features.hotwallet.HotAccessCodeRequestComponent
+import com.tangem.features.hotwallet.HotWalletFeatureToggles
 import com.tangem.features.hotwallet.accesscoderequest.proxy.HotWalletPasswordRequesterProxy
 import com.tangem.features.walletconnect.components.WcRoutingComponent
 import com.tangem.hot.sdk.TangemHotSdk
@ -59,6 +63,9 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
    private val userWalletsListRepository: UserWalletsListRepository,
    private val cardRepository: CardRepository,
    private val onboardingRepository: OnboardingRepository,
+    private val hotWalletFeatureToggles: HotWalletFeatureToggles,
+    private val trackingContextProxy: TrackingContextProxy,
+    private val analyticsEventHandler: AnalyticsEventHandler,
 ) : RoutingComponent,
    AppComponentContext by context,
    SnackbarHandler {
@ -130,6 +137,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
                )
            }
            else -> {
+                trackSignInEvent()
                AppRoute.Wallet
            }
        }.also {
@ -214,4 +222,19 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
            store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound(onboardingScanResponse)))
        }
    }
+
+    private suspend fun trackSignInEvent() {
+        if (hotWalletFeatureToggles.isHotWalletEnabled) {
+            val userWallets = userWalletsListRepository.userWalletsSync()
+            val selectedWallet = userWalletsListRepository.selectedUserWalletSync() ?: return
+            trackingContextProxy.proceedWithContext(selectedWallet) {
+                analyticsEventHandler.send(
+                    event = Basic.SignedIn(
+                        signInType = Basic.SignedIn.SignInType.NoSecurity,
+                        walletsCount = userWallets.size,
+                    ),
+                )
+            }
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/routing/transitions/RoutingTransitionAnimationFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/transitions/RoutingTransitionAnimationFactory.kt
@ -14,7 +14,6 @@ object RoutingTransitionAnimationFactory {
    @Suppress("MagicNumber")
    fun create(appRoute: AppRoute): StackAnimator {
        return when (appRoute) {
-            is AppRoute.Onboarding,
            is AppRoute.Welcome,
            is AppRoute.Home,
            -> fade(tween(400)).plus(scale(tween(400)))
--- a/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
+++ b/app/src/main/java/com/tangem/tap/routing/utils/ChildFactory.kt
@ -565,7 +565,7 @@ internal class ChildFactory @Inject constructor(
                    params = CreateWalletBackupComponent.Params(
                        userWalletId = route.userWalletId,
                        isUpgradeFlow = route.isUpgradeFlow,
-                        shouldSetAccessCode = route.setAccessCode,
+                        shouldSetAccessCode = route.shouldSetAccessCode,
                        analyticsSource = route.analyticsSource,
                        analyticsAction = route.analyticsAction,
                    ),
--- a/common/routing/detekt-baseline-debug.xml
+++ b/common/routing/detekt-baseline-debug.xml
@ -1,9 +0,0 @@
-<?xml version="1.0" ?>
-<SmellBaseline>
-  <ManuallySuppressedIssues/>
-  <CurrentIssues>
-    <ID>BooleanPropertyNaming:AppRoute.kt$AppRoute.CreateWalletBackup$val setAccessCode: Boolean = false</ID>
-    <ID>NestedScopeFunctions:PayloadToDeeplinkConverter.kt$PayloadToDeeplinkConverter$let { addQueryParam(NAME_KEY, it) }</ID>
-    <ID>NestedScopeFunctions:PayloadToDeeplinkConverter.kt$PayloadToDeeplinkConverter$let { addQueryParam(TRANSACTION_ID_KEY, it) }</ID>
-  </CurrentIssues>
-</SmellBaseline>
--- a/common/routing/src/main/kotlin/com/tangem/common/routing/AppRoute.kt
+++ b/common/routing/src/main/kotlin/com/tangem/common/routing/AppRoute.kt
@ -368,7 +368,7 @@ sealed class AppRoute(val path: String) : Route {
        val analyticsSource: String,
        val analyticsAction: String,
        val isUpgradeFlow: Boolean = false,
-        val setAccessCode: Boolean = false,
+        val shouldSetAccessCode: Boolean = false,
    ) : AppRoute(path = "/create_wallet_backup/${userWalletId.stringValue}")

    @Serializable
--- a/common/routing/src/main/kotlin/com/tangem/common/routing/deeplink/PayloadToDeeplinkConverter.kt
+++ b/common/routing/src/main/kotlin/com/tangem/common/routing/deeplink/PayloadToDeeplinkConverter.kt
@ -55,8 +55,12 @@ object PayloadToDeeplinkConverter : Converter<Map<String, String>, String?> {
                addQueryParam(DERIVATION_PATH_KEY, derivationPath)
            }

-            transactionId?.let { addQueryParam(TRANSACTION_ID_KEY, it) }
-            name?.let { addQueryParam(NAME_KEY, it) }
+            if (transactionId != null) {
+                addQueryParam(TRANSACTION_ID_KEY, transactionId)
+            }
+            if (name != null) {
+                addQueryParam(NAME_KEY, name)
+            }
        }.build()
    }

--- a/common/test/src/main/java/com/tangem/common/test/data/staking/MockP2PEthPoolAccountResponseFactory.kt
+++ b/common/test/src/main/java/com/tangem/common/test/data/staking/MockP2PEthPoolAccountResponseFactory.kt
@ -0,0 +1,82 @@
+package com.tangem.common.test.data.staking
+
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolExitQueueDTO
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolStakeDTO
+import com.tangem.domain.models.staking.StakingID
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolVault
+import java.math.BigDecimal
+
+/**
+ * Factory for creating mock P2P ETH Pool account responses for testing
+ */
+object MockP2PEthPoolAccountResponseFactory {
+
+    private val defaultStakingId = StakingID(
+        integrationId = "p2p-ethereum-pooled",
+        address = "0x5aa711F440Eb6d4361148bBD89d03464628ace84",
+    )
+
+    const val defaultVaultAddress = "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+
+    fun createWithBalance(
+        stakingId: StakingID = defaultStakingId,
+        vaultAddress: String = defaultVaultAddress,
+        stakedAmount: BigDecimal = BigDecimal("1.5"),
+        earnedAmount: BigDecimal = BigDecimal("0.05"),
+    ): P2PEthPoolAccountResponse {
+        return P2PEthPoolAccountResponse(
+            delegatorAddress = stakingId.address,
+            vaultAddress = vaultAddress,
+            stake = P2PEthPoolStakeDTO(
+                assets = stakedAmount,
+                totalEarnedAssets = earnedAmount,
+            ),
+            availableToUnstake = stakedAmount,
+            availableToWithdraw = BigDecimal.ZERO,
+            exitQueue = P2PEthPoolExitQueueDTO(
+                total = 0.0,
+                requests = emptyList(),
+            ),
+        )
+    }
+
+    fun createWithEmptyBalance(
+        stakingId: StakingID = defaultStakingId,
+        vaultAddress: String = defaultVaultAddress,
+    ): P2PEthPoolAccountResponse {
+        return P2PEthPoolAccountResponse(
+            delegatorAddress = stakingId.address,
+            vaultAddress = vaultAddress,
+            stake = P2PEthPoolStakeDTO(
+                assets = BigDecimal.ZERO,
+                totalEarnedAssets = BigDecimal.ZERO,
+            ),
+            availableToUnstake = BigDecimal.ZERO,
+            availableToWithdraw = BigDecimal.ZERO,
+            exitQueue = P2PEthPoolExitQueueDTO(
+                total = 0.0,
+                requests = emptyList(),
+            ),
+        )
+    }
+
+    fun createMockVault(vaultAddress: String = defaultVaultAddress): P2PEthPoolVault {
+        return P2PEthPoolVault(
+            vaultAddress = vaultAddress,
+            displayName = "Test Vault",
+            apy = BigDecimal("3.5"),
+            baseApy = BigDecimal("3.0"),
+            capacity = BigDecimal("10000"),
+            totalAssets = BigDecimal("5000"),
+            feePercent = BigDecimal("10"),
+            isPrivate = false,
+            isGenesis = false,
+            isSmoothingPool = false,
+            isErc20 = false,
+            tokenName = "Test Token",
+            tokenSymbol = "TT",
+            createdAt = 0L,
+        )
+    }
+}
--- a/core/analytics/models/src/main/java/com/tangem/core/analytics/models/AnalyticsParam.kt
+++ b/core/analytics/models/src/main/java/com/tangem/core/analytics/models/AnalyticsParam.kt
@ -83,12 +83,14 @@ sealed class AnalyticsParam {
        data object Onboarding : ScreensSources("Onboarding")
        data object LongTap : ScreensSources("Long Tap")
        data object Markets : ScreensSources("Markets")
-        data object HotWallet : ScreensSources("Hot Wallet")
        data object TangemPay : ScreensSources("Tangem Pay")
        data object WalletSettings : ScreensSources("Wallet Settings")
        data object Upgrade : ScreensSources("Upgrade")
        data object HardwareWallet : ScreensSources("Hardware Wallet")
        data object ImportWallet : ScreensSources("Import Wallet")
+        data object CreateNewWallet : ScreensSources("Create New Wallet")
+        data object AddNewWallet : ScreensSources("Add New Wallet")
+        data object CreateWallet : ScreensSources("Create Wallet")
    }

    sealed class TxSentFrom(val value: String) {
--- a/core/analytics/models/src/main/java/com/tangem/core/analytics/models/Basic.kt
+++ b/core/analytics/models/src/main/java/com/tangem/core/analytics/models/Basic.kt
@ -10,11 +10,11 @@ sealed class Basic(
    ) : Basic(
        event = "Card Was Scanned",
        params = mapOf(
-            AnalyticsParam.SOURCE to source.value,
+            AnalyticsParam.Key.SOURCE to source.value,
        ),
    )

-    class SignedIn(
+    class SignedInLegacy(
        currency: AnalyticsParam.WalletType,
        batch: String,
        signInType: SignInType,
@ -24,8 +24,8 @@ sealed class Basic(
    ) : Basic(
        event = "Signed in",
        params = buildMap {
-            put(AnalyticsParam.CURRENCY, currency.value)
-            put(AnalyticsParam.BATCH, batch)
+            put(AnalyticsParam.Key.CURRENCY, currency.value)
+            put(AnalyticsParam.Key.BATCH, batch)
            put("Wallet Type", if (isImported) "Seed Phrase" else "Seedless")
            put("Sign in type", signInType.name)
            put("Wallets Count", walletsCount)
@ -39,10 +39,37 @@ sealed class Basic(
        }
    }

+    class SignedIn(
+        signInType: SignInType,
+        walletsCount: Int,
+    ) : Basic(
+        event = "Signed in",
+        params = buildMap {
+            put("Sign in type", signInType.value)
+            put("Wallets Count", walletsCount.toString())
+        },
+    ) {
+        enum class SignInType(val value: String) {
+            Card("Card"),
+            Biometric("Biometric"),
+            NoSecurity("No Security"),
+            AccessCode("Access Code"),
+        }
+    }
+
+    class ButtonBuy(
+        source: AnalyticsParam.ScreensSources,
+    ) : Basic(
+        event = "Button - Buy",
+        params = buildMap {
+            put(AnalyticsParam.Key.SOURCE, source.value)
+        },
+    )
+
    class ToppedUp(userWalletId: String, currency: AnalyticsParam.WalletType) :
        Basic(
            event = "Topped up",
-            params = mapOf(AnalyticsParam.CURRENCY to currency.value),
+            params = mapOf(AnalyticsParam.Key.CURRENCY to currency.value),
        ),
        OneTimeAnalyticsEvent {

@ -53,16 +80,16 @@ sealed class Basic(
        Basic(
            event = "Transaction sent",
            params = buildMap {
-                this[AnalyticsParam.SOURCE] = sentFrom.value
+                this[AnalyticsParam.Key.SOURCE] = sentFrom.value
                if (sentFrom is AnalyticsParam.TxData) {
-                    this[AnalyticsParam.BLOCKCHAIN] = sentFrom.blockchain
-                    this[AnalyticsParam.TOKEN_PARAM] = sentFrom.token
+                    this[AnalyticsParam.Key.BLOCKCHAIN] = sentFrom.blockchain
+                    this[AnalyticsParam.Key.TOKEN_PARAM] = sentFrom.token
                    sentFrom.feeType?.value?.let {
-                        this[AnalyticsParam.FEE_TYPE] = it
+                        this[AnalyticsParam.Key.FEE_TYPE] = it
                    }
                }
                if (sentFrom is AnalyticsParam.TxSentFrom.Approve) {
-                    this[AnalyticsParam.PERMISSION_TYPE] = sentFrom.permissionType
+                    this[AnalyticsParam.Key.PERMISSION_TYPE] = sentFrom.permissionType
                }
                this["Memo"] = memoType.name
            },
@ -79,7 +106,7 @@ sealed class Basic(
    class ButtonSupport(source: AnalyticsParam.ScreensSources) : Basic(
        event = "Request Support",
        params = mapOf(
-            AnalyticsParam.SOURCE to source.value,
+            AnalyticsParam.Key.SOURCE to source.value,
        ),
    )

@ -89,7 +116,7 @@ sealed class Basic(
    ) : Basic(
        event = "Biometry Failed",
        params = mapOf(
-            AnalyticsParam.SOURCE to source.value,
+            AnalyticsParam.Key.SOURCE to source.value,
            "Reason" to reason.value,
        ),
    ) {
--- a/core/analytics/models/src/main/java/com/tangem/core/analytics/models/event/SignIn.kt
+++ b/core/analytics/models/src/main/java/com/tangem/core/analytics/models/event/SignIn.kt
@ -0,0 +1,46 @@
+package com.tangem.core.analytics.models.event
+
+import com.tangem.core.analytics.models.AnalyticsEvent
+import com.tangem.core.analytics.models.AnalyticsParam
+
+sealed class SignIn(
+    event: String,
+    params: Map<String, String> = emptyMap(),
+) : AnalyticsEvent("Sign In", event, params) {
+
+    data class ScreenOpened(
+        val walletsCount: Int,
+    ) : SignIn(
+        event = "Sign In Screen Opened",
+        params = mapOf(
+            "Wallets Count" to walletsCount.toString(),
+        ),
+    )
+
+    class ButtonUnlockAllWithBiometric : SignIn(event = "Button - Unlock All With Biometric")
+
+    class ButtonWallet(
+        signInType: SignInType,
+    ) : SignIn(
+        event = "Button - Wallet",
+        params = buildMap {
+            put("Sign in type", signInType.value)
+        },
+    ) {
+        enum class SignInType(val value: String) {
+            Card("Card"),
+            Biometric("Biometric"),
+            NoSecurity("No Security"),
+            AccessCode("Access Code"),
+        }
+    }
+
+    data class ButtonAddWallet(
+        val sources: AnalyticsParam.ScreensSources,
+    ) : SignIn(
+        event = "Button - Add Wallet",
+        params = mapOf(
+            AnalyticsParam.SOURCE to sources.value,
+        ),
+    )
+}
--- a/core/analytics/src/main/java/com/tangem/core/analytics/utils/TrackingContextProxy.kt
+++ b/core/analytics/src/main/java/com/tangem/core/analytics/utils/TrackingContextProxy.kt
@ -23,4 +23,6 @@ interface TrackingContextProxy {
    fun addHotWalletContext()

    fun removeContext()
+
+    fun proceedWithContext(userWallet: UserWallet, action: () -> Unit)
 }
--- a/core/config-toggles/detekt-baseline-debug.xml
+++ b/core/config-toggles/detekt-baseline-debug.xml
@ -2,8 +2,6 @@
 <SmellBaseline>
  <ManuallySuppressedIssues/>
  <CurrentIssues>
-    <ID>DoubleMutabilityForCollection:DevExcludedBlockchainsManager.kt$DevExcludedBlockchainsManager$private var blockchainTogglesMap: MutableMap&lt;String, Boolean&gt; by Delegates.notNull()</ID>
-    <ID>DoubleMutabilityForCollection:DevFeatureTogglesManager.kt$DevFeatureTogglesManager$private var featureTogglesMap: MutableMap&lt;String, Boolean&gt; by Delegates.notNull()</ID>
    <ID>Indentation:ExcludedBlockchainToggles.kt$ExcludedBlockchainToggles$ </ID>
    <ID>Indentation:FeatureToggles.kt$FeatureToggles$ </ID>
  </CurrentIssues>
--- a/core/config-toggles/src/main/assets/configs/feature_toggles_config.json
+++ b/core/config-toggles/src/main/assets/configs/feature_toggles_config.json
@ -33,7 +33,7 @@
    },
    {
        "name": "HOT_WALLET_ENABLED",
-        "version": "undefined"
+        "version": "5.32.0"
    },
    {
        "name": "TANGEM_PAY_ENABLED",
--- a/core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/blockchain/impl/DevExcludedBlockchainsManager.kt
+++ b/core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/blockchain/impl/DevExcludedBlockchainsManager.kt
@ -21,6 +21,8 @@ internal class DevExcludedBlockchainsManager(
 ) : MutableExcludedBlockchainsManager {

    private val fileBlockchainToggles: Map<String, Boolean> = getFileBlockchainToggles()
+
+    @Suppress("DoubleMutabilityForCollection")
    private var blockchainTogglesMap: MutableMap<String, Boolean> by Delegates.notNull()

    override val excludedBlockchainsIds: Set<String>
--- a/core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/impl/DevFeatureTogglesManager.kt
+++ b/core/config-toggles/src/main/kotlin/com/tangem/core/configtoggle/feature/impl/DevFeatureTogglesManager.kt
@ -22,6 +22,8 @@ internal class DevFeatureTogglesManager(
 ) : MutableFeatureTogglesManager {

    private val fileFeatureTogglesMap: Map<String, Boolean> = getFileFeatureToggles()
+
+    @Suppress("DoubleMutabilityForCollection")
    private var featureTogglesMap: MutableMap<String, Boolean> by Delegates.notNull()

    init {
--- a/core/datasource/src/main/java/com/tangem/datasource/api/common/config/ApiEnvironment.kt
+++ b/core/datasource/src/main/java/com/tangem/datasource/api/common/config/ApiEnvironment.kt
@ -22,6 +22,9 @@ enum class ApiEnvironment {
    @Json(name = "STAGE")
    STAGE,

+    @Json(name = "STAGE_2")
+    STAGE_2,
+
    @Json(name = "MOCK")
    MOCK,

--- a/core/datasource/src/main/java/com/tangem/datasource/api/common/config/Express.kt
+++ b/core/datasource/src/main/java/com/tangem/datasource/api/common/config/Express.kt
@ -30,6 +30,7 @@ internal class Express(
        createDev2Environment(),
        createDev3Environment(),
        createStageEnvironment(),
+        createStage2Environment(),
        createMockedEnvironment(),
        createProdEnvironment(),
    )
@ -73,6 +74,12 @@ internal class Express(
        headers = createHeaders(isProd = false),
    )

+    private fun createStage2Environment(): ApiEnvironmentConfig = ApiEnvironmentConfig(
+        environment = ApiEnvironment.STAGE_2,
+        baseUrl = "[REDACTED_ENV_URL]",
+        headers = createHeaders(isProd = false),
+    )
+
    private fun createMockedEnvironment(): ApiEnvironmentConfig = ApiEnvironmentConfig(
        environment = ApiEnvironment.MOCK,
        baseUrl = "[REDACTED_ENV_URL]",
--- a/core/datasource/src/main/java/com/tangem/datasource/api/common/config/YieldSupply.kt
+++ b/core/datasource/src/main/java/com/tangem/datasource/api/common/config/YieldSupply.kt
@ -77,6 +77,7 @@ internal class YieldSupply(
            ApiEnvironment.DEV_2,
            ApiEnvironment.DEV_3,
            ApiEnvironment.STAGE,
+            ApiEnvironment.STAGE_2,
            -> environmentConfigStorage.getConfigSync().yieldModuleApiKeyDev
            ApiEnvironment.PROD -> environmentConfigStorage.getConfigSync().yieldModuleApiKey
        } ?: error("No tangem tech api config provided")
--- a/core/datasource/src/main/java/com/tangem/datasource/di/StakingStoreModule.kt
+++ b/core/datasource/src/main/java/com/tangem/datasource/di/StakingStoreModule.kt
@ -5,6 +5,7 @@ import androidx.datastore.core.DataStore
 import androidx.datastore.core.DataStoreFactory
 import androidx.datastore.dataStoreFile
 import com.squareup.moshi.Moshi
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
 import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
 import com.tangem.datasource.api.stakekit.models.response.model.YieldDTO
 import com.tangem.datasource.local.datastore.RuntimeDataStore
@ -77,6 +78,24 @@ internal object StakingStoreModule {
        return DefaultStakingActionsStore(dataStore = RuntimeDataStore())
    }

+    @Provides
+    @Singleton
+    fun provideP2PBalancesPersistenceStore(
+        @NetworkMoshi moshi: Moshi,
+        @ApplicationContext context: Context,
+        dispatchers: CoroutineDispatcherProvider,
+    ): DataStore<Map<String, Set<P2PEthPoolAccountResponse>>> {
+        return DataStoreFactory.create(
+            serializer = MoshiDataStoreSerializer(
+                moshi = moshi,
+                types = mapWithStringKeyTypes(valueTypes = setTypes<P2PEthPoolAccountResponse>()),
+                defaultValue = emptyMap(),
+            ),
+            produceFile = { context.dataStoreFile(fileName = "p2p_balances") },
+            scope = CoroutineScope(context = dispatchers.io + SupervisorJob()),
+        )
+    }
+
    @Provides
    @Singleton
    fun provideP2PEthPoolVaultsStore(
--- a/core/res/src/main/res/values-ja/strings.xml
+++ b/core/res/src/main/res/values-ja/strings.xml
@ -3,6 +3,10 @@
  <string name="access_code_alert_skip_description">アクセスコードがないとウォレットは安全ではありません。</string>
  <string name="access_code_alert_skip_ok">とにかくスキップ</string>
  <string name="access_code_alert_skip_title">アクセスコードが設定されていません</string>
+  <string name="access_code_alert_validation_cancel">コードを変更</string>
+  <string name="access_code_alert_validation_description">アクセスコードは、ウォレットのロック解除・資産へのアクセス保護に使用されます</string>
+  <string name="access_code_alert_validation_ok">このまま使用</string>
+  <string name="access_code_alert_validation_title">このアクセスコードは簡単に推測される可能性があります</string>
  <string name="access_code_check_title">アクセスコードを入力</string>
  <string name="access_code_check_warining_delete">アクセスコードが間違っています。あと%s回間違えると、モバイルウォレットが削除されます。</string>
  <string name="access_code_check_warining_lock">アクセスコードが間違っています。あと%s回失敗すると、アプリはロックされます。</string>
@ -773,6 +777,10 @@
  <string name="markets_token_details_volume">取引量</string>
  <string name="markets_tooltip_message">これをドラッグするか、検索窓をタップして、マーケットから直接トークンを追加します</string>
  <string name="markets_tooltip_title">トークンを追加</string>
+  <string name="markets_yield_supply_banner_description">資産を即時アクセス可能な状態に保ったまま、パワーアップさせよう。%s</string>
+  <string name="markets_yield_supply_banner_title">利息モードを有効にする</string>
+  <string name="mobile_wallet_requires_min_os_warning_body">モバイルウォレットを作成するには、%1$sにアップデートする必要があります</string>
+  <string name="mobile_wallet_requires_min_os_warning_title">モバイルウォレットを使用するには、%1$s以降が必要です</string>
  <string name="news_all_news">すべてのニュース</string>
  <string name="news_stay_in_the_loop">最新情報を入手</string>
  <string name="nfc_error_unavailable">お使いのデバイスではNFCが使用できません</string>
@ -1897,6 +1905,7 @@
  <string name="yield_module_fee_policy_tangem_service_fee_title">Tangemは、生成された利息に対して15%サービス手数料も徴収します。</string>
  <string name="yield_module_high_fee_error">ネットワーク手数料が下がるか、残高が最低必要額に達すると、資金は自動的にAaveに供給されます。</string>
  <string name="yield_module_historical_returns">過去のリターン</string>
+  <string name="yield_module_main_screen_promo_banner_message">保有資産に年利%1$s%%を適用</string>
  <string name="yield_module_main_view_approve_notification_description">利息モードでのトークンの承認が取り消されました。トークンを開いて再度許可してください。</string>
  <string name="yield_module_main_view_approve_notification_title">トークンの承認が必要です</string>
  <string name="yield_module_network_fee_unreachable_notification_description">ネットワーク接続を確認してください</string>
@ -1911,7 +1920,9 @@
  <string name="yield_module_promo_screen_self_custodial_title">分散型・自己管理型</string>
  <string name="yield_module_promo_screen_terms_disclaimer">このサービスを利用することにより、プロバイダー\n%1$sおよび%2$sに同意するものとします。</string>
  <string name="yield_module_promo_screen_title">Aaveに接続</string>
+  <string name="yield_module_promo_screen_title_v2">残高に %1$s%% の年利（APY）を適用</string>
  <string name="yield_module_promo_screen_variable_rate_info">Aave %1$s%% • 変動金利</string>
+  <string name="yield_module_promo_screen_variable_rate_info_v2">変動金利</string>
  <string name="yield_module_provider">Aave</string>
  <string name="yield_module_rate_info_sheet_chart_average">平均%s</string>
  <string name="yield_module_rate_info_sheet_chart_title">昨年のリターン</string>
@ -1938,12 +1949,16 @@
  <string name="yield_module_token_details_earn_notification_earning_on_your_balance_title">利息モード</string>
  <string name="yield_module_token_details_earn_notification_processing">利息モードの有効化</string>
  <string name="yield_module_token_details_earn_notification_title">利息モード</string>
-  <string name="yield_module_transaction_enter">利息モードが有効になりました</string>
+  <string name="yield_module_transaction_deploy_contract">利息モードコントラクトのデプロイ</string>
+  <string name="yield_module_transaction_enter">利息モードを有効にする</string>
  <string name="yield_module_transaction_enter_subtitle">%1$sがAaveに供給されました</string>
-  <string name="yield_module_transaction_exit">利息モードが無効になりました</string>
+  <string name="yield_module_transaction_exit">利息モードを無効にする</string>
  <string name="yield_module_transaction_exit_subtitle">%1$sがAaveから引き出されました</string>
+  <string name="yield_module_transaction_initialize">利息モードをセットアップ</string>
+  <string name="yield_module_transaction_reactivate">利息モードの再有効化</string>
  <string name="yield_module_transaction_topup">Aaveへの供給</string>
  <string name="yield_module_transaction_topup_subtitle">%1$sがAaveに供給されました</string>
+  <string name="yield_module_transaction_withdraw">Aaveから引き出す</string>
  <string name="yield_module_transfer_mode_automatic">自動</string>
  <string name="yield_module_unable_to_cover_fee_description">取引のネットワーク手数料をカバーするために、 %1$s %2$sを追加してください。</string>
  <string name="yield_module_unable_to_cover_fee_title">%s手数料を支払えません</string>
--- a/core/res/src/main/res/values-ru/strings.xml
+++ b/core/res/src/main/res/values-ru/strings.xml
@ -274,7 +274,7 @@
  <string name="common_from">Из</string>
  <string name="common_from_wallet_name">Из %s</string>
  <string name="common_generate_addresses">Синхронизировать адреса</string>
-  <string name="common_get_started">Начать зарабатывать</string>
+  <string name="common_get_started">Начать</string>
  <string name="common_get_token">Получить токен</string>
  <string name="common_go_to_provider">К провайдеру</string>
  <string name="common_go_to_token">Перейти в токен</string>
@ -1075,7 +1075,7 @@
  <string name="save_user_wallet_agreement_notice">Обратите внимание, что для совершения транзакции с вашими средствами по-прежнему потребуется ваша карта или кольцо</string>
  <string name="scan_card_settings_button">Сканировать</string>
  <string name="scan_card_settings_message">Отсканируйте карту или кольцо, чтобы изменить ее настройки. Изменения затронут только ту карту или кольцо, которые вы отсканировали, и не повлияют на другие устройства, привязанные к вашему кошельку.</string>
-  <string name="scan_card_settings_title">Приготовьте свой Tangem!</string>
+  <string name="scan_card_settings_title">Приготовьте устройство Tangem!</string>
  <string name="security_alert_title">Уведомление безопасности</string>
  <string name="seed_warning_no">Нет</string>
  <string name="seed_warning_yes">Да</string>
@ -1854,9 +1854,9 @@
  <string name="yield_module_token_details_earn_notification_earning_on_your_balance_title">Режим доходности</string>
  <string name="yield_module_token_details_earn_notification_processing">Включение режима доходности</string>
  <string name="yield_module_token_details_earn_notification_title">Режим доходности</string>
-  <string name="yield_module_transaction_enter">Режим доходности включен</string>
+  <string name="yield_module_transaction_enter">Включение режима доходности</string>
  <string name="yield_module_transaction_enter_subtitle">%1$s отправлено в Aave</string>
-  <string name="yield_module_transaction_exit">Режим доходности выключен</string>
+  <string name="yield_module_transaction_exit">Отключение режима доходности</string>
  <string name="yield_module_transaction_exit_subtitle">%1$s выведено из Aave</string>
  <string name="yield_module_transaction_topup">Перевод средств в Aave</string>
  <string name="yield_module_transaction_topup_subtitle">%1$s отправлено в Aave</string>
--- a/core/res/src/main/res/values/strings.xml
+++ b/core/res/src/main/res/values/strings.xml
@ -3,6 +3,10 @@
  <string name="access_code_alert_skip_description">Without an access code, your wallet is not secure.</string>
  <string name="access_code_alert_skip_ok">Skip anyway</string>
  <string name="access_code_alert_skip_title">Access code not set</string>
+  <string name="access_code_alert_validation_cancel">Change code</string>
+  <string name="access_code_alert_validation_description">Your access code will be used to unlock your wallet and to protect access to the assets</string>
+  <string name="access_code_alert_validation_ok">Use anyway</string>
+  <string name="access_code_alert_validation_title">This access code can be easily guessed</string>
  <string name="access_code_check_title">Enter access code</string>
  <string name="access_code_check_warining_delete">Wrong access code. Your mobile wallet will be deleted after %s more incorrect attempts.</string>
  <string name="access_code_check_warining_lock">Wrong access code. The app will be locked after %s more failed attempts</string>
@ -788,6 +792,10 @@
  <string name="markets_token_details_volume">Volume</string>
  <string name="markets_tooltip_message">Pull this up or tap the search bar to add tokens directly from the market</string>
  <string name="markets_tooltip_title">Add tokens</string>
+  <string name="markets_yield_supply_banner_description">Power up your assets while supplying them with instant access. %s</string>
+  <string name="markets_yield_supply_banner_title">Activate Yield Mode</string>
+  <string name="mobile_wallet_requires_min_os_warning_body">You must update to %1$s in order to create mobile wallet</string>
+  <string name="mobile_wallet_requires_min_os_warning_title">Mobile Wallet requires %1$s or later</string>
  <string name="news_all_news">All news</string>
  <string name="news_stay_in_the_loop">Stay in the loop</string>
  <string name="nfc_error_unavailable">NFC is not available on your device</string>
@ -1973,6 +1981,7 @@
  <string name="yield_module_fee_policy_tangem_service_fee_title">Tangem also takes a 15% service fee on yield generated.</string>
  <string name="yield_module_high_fee_error">Your funds will be automatically supplied to Aave once network fees are lower or your balance meets the minimum required amount.</string>
  <string name="yield_module_historical_returns">Historical returns</string>
+  <string name="yield_module_main_screen_promo_banner_message">"Enable %1$s%% APY on your balance"</string>
  <string name="yield_module_main_view_approve_notification_description">Approval for your token in Yield Mode has been revoked. Open the token to grant permission again.</string>
  <string name="yield_module_main_view_approve_notification_title">Token approval needed</string>
  <string name="yield_module_network_fee_unreachable_notification_description">Check your network connection</string>
@ -2016,12 +2025,16 @@
  <string name="yield_module_token_details_earn_notification_earning_on_your_balance_title">Yield Mode</string>
  <string name="yield_module_token_details_earn_notification_processing">Enabling Yield Mode</string>
  <string name="yield_module_token_details_earn_notification_title">Yield Mode</string>
-  <string name="yield_module_transaction_enter">Yield Mode enabled</string>
+  <string name="yield_module_transaction_deploy_contract">Yield Mode contract deploy</string>
+  <string name="yield_module_transaction_enter">Yield Mode enable</string>
  <string name="yield_module_transaction_enter_subtitle">%1$s supplied to Aave</string>
-  <string name="yield_module_transaction_exit">Yield Mode disabled</string>
+  <string name="yield_module_transaction_exit">Yield Mode disable</string>
  <string name="yield_module_transaction_exit_subtitle">%1$s withdrawn from Aave</string>
+  <string name="yield_module_transaction_initialize">Yield Mode initialize</string>
+  <string name="yield_module_transaction_reactivate">Yield Mode reactivate</string>
  <string name="yield_module_transaction_topup">Supply to Aave</string>
  <string name="yield_module_transaction_topup_subtitle">%1$s supplied to Aave</string>
+  <string name="yield_module_transaction_withdraw">Withdraw from Aave</string>
  <string name="yield_module_transfer_mode_automatic">Automatic</string>
  <string name="yield_module_unable_to_cover_fee_description">Add some %1$s %2$s to cover the network fee for transactions.</string>
  <string name="yield_module_unable_to_cover_fee_title">Unable to cover %s fee</string>
--- a/data/account/detekt-baseline-debug.xml
+++ b/data/account/detekt-baseline-debug.xml
@ -6,8 +6,6 @@
    <ID>MultilineLambdaItParameter:DefaultAccountsCRUDRepository.kt$DefaultAccountsCRUDRepository${ if (it is HttpException &amp;&amp; it.code == HttpException.Code.NOT_MODIFIED) { null } else { throw it } }</ID>
    <ID>MultilineLambdaItParameter:GetWalletAccountsResponseExt.kt${ enrichedTokensByAccountId[it].orEmpty().map { token -&gt; // Tokens from unexisting accounts should be copied to the main account token.copy(accountId = accountDTO.id) } }</ID>
    <ID>NoNameShadowing:GetWalletAccountsResponseExt.kt$tokens</ID>
-    <ID>NullableToStringCall:AccountListCryptoCurrenciesProducer.kt$AccountListCryptoCurrenciesProducer$${this::class.simpleName}</ID>
-    <ID>NullableToStringCall:DefaultMultiWalletCryptoCurrenciesProducer.kt$DefaultMultiWalletCryptoCurrenciesProducer$${this::class.simpleName}</ID>
    <ID>UnnecessaryLet:DefaultAccountsCRUDRepository.kt$DefaultAccountsCRUDRepository$let(AccountName::invoke)</ID>
  </CurrentIssues>
 </SmellBaseline>
--- a/data/account/src/main/kotlin/com/tangem/data/account/fetcher/DefaultWalletAccountsFetcher.kt
+++ b/data/account/src/main/kotlin/com/tangem/data/account/fetcher/DefaultWalletAccountsFetcher.kt
@ -115,7 +115,7 @@ internal class DefaultWalletAccountsFetcher @Inject constructor(

                saveETag(userWalletId, apiResponse)

-                apiResponse.bind()
+                apiResponse.bind().enrichByAccountId()
            },
            onError = { error ->
                if (error.isNetworkError(code = Code.PRECONDITION_FAILED)) {
@ -142,10 +142,11 @@ internal class DefaultWalletAccountsFetcher @Inject constructor(

                saveETag(userWalletId, apiResponse)

-                val responseBody = apiResponse.bind()
-                store(userWalletId = userWalletId, response = responseBody)
+                val response = apiResponse.bind().enrichByAccountId()

-                FetchResult(responseBody)
+                store(userWalletId = userWalletId, response = response)
+
+                FetchResult(response)
            },
            onError = { throwable ->
                // pushWalletAccounts and storeWalletAccounts help to avoid cyclic dependency
@ -215,6 +216,18 @@ internal class DefaultWalletAccountsFetcher @Inject constructor(
        }
    }

+    private fun GetWalletAccountsResponse.enrichByAccountId(): GetWalletAccountsResponse {
+        return copy(
+            accounts = accounts.map { accountDTO ->
+                accountDTO.copy(
+                    tokens = accountDTO.tokens?.map { token ->
+                        token.copy(accountId = accountDTO.id)
+                    },
+                )
+            },
+        )
+    }
+
    private fun getAccountsResponseStore(userWalletId: UserWalletId): AccountsResponseStore {
        return accountsResponseStoreFactory.create(userWalletId = userWalletId)
    }
--- a/data/account/src/main/kotlin/com/tangem/data/account/producer/AccountListCryptoCurrenciesProducer.kt
+++ b/data/account/src/main/kotlin/com/tangem/data/account/producer/AccountListCryptoCurrenciesProducer.kt
@ -36,11 +36,12 @@ internal class AccountListCryptoCurrenciesProducer @AssistedInject constructor(

    override val fallback: Option<Set<CryptoCurrency>> = emptySet<CryptoCurrency>().some()

+    @Suppress("NullableToStringCall")
    override fun produce(): Flow<Set<CryptoCurrency>> {
        val userWallet = userWalletsStore.getSyncStrict(key = params.userWalletId)

        if (!userWallet.isMultiCurrency) {
-            error("${this::class.simpleName} supports only multi-currency wallet")
+            error("${this::class.simpleName ?: this::class.toString()} supports only multi-currency wallet")
        }

        return accountsResponseStoreFactory.create(userWalletId = userWallet.walletId).data
@ -49,10 +50,13 @@ internal class AccountListCryptoCurrenciesProducer @AssistedInject constructor(
                if (response == null) return@map emptySet()

                response.accounts.flatMapTo(hashSetOf()) { accountDTO ->
+                    val accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull()
+                        ?: return@map emptySet()
+
                    responseCryptoCurrenciesFactory.createCurrencies(
                        tokens = accountDTO.tokens.orEmpty(),
                        userWallet = userWallet,
-                        accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull(),
+                        accountIndex = accountIndex,
                    )
                }
            }
--- a/data/account/src/main/kotlin/com/tangem/data/account/producer/DefaultMultiWalletCryptoCurrenciesProducer.kt
+++ b/data/account/src/main/kotlin/com/tangem/data/account/producer/DefaultMultiWalletCryptoCurrenciesProducer.kt
@ -5,6 +5,7 @@ import arrow.core.some
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.wallet.isMultiCurrency
 import com.tangem.domain.tokens.MultiWalletCryptoCurrenciesProducer
@ -39,7 +40,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducer @AssistedInject constr
        val userWallet = userWalletsStore.getSyncStrict(key = params.userWalletId)

        if (!userWallet.isMultiCurrency) {
-            error("${this::class.simpleName} supports only multi-currency wallet")
+            error("${this::class.simpleName ?: this::class.toString()} supports only multi-currency wallet")
        }

        return userTokensResponseStore.get(userWalletId = params.userWalletId)
@ -50,6 +51,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducer @AssistedInject constr
                responseCryptoCurrenciesFactory.createCurrencies(
                    response = response,
                    userWallet = userWallet,
+                    accountIndex = DerivationIndex.Main,
                ).toSet()
            }
            .onEmpty { emit(emptySet()) }
--- a/data/account/src/main/kotlin/com/tangem/data/account/tokens/DefaultMainAccountTokensMigration.kt
+++ b/data/account/src/main/kotlin/com/tangem/data/account/tokens/DefaultMainAccountTokensMigration.kt
@ -61,7 +61,7 @@ internal class DefaultMainAccountTokensMigration(

        val unassignedTokens = mainAccount.findUnassignedTokens(derivationIndex)

-        if (unassignedTokens == null) {
+        if (unassignedTokens.isNullOrEmpty()) {
            Timber.i("No unassigned tokens found for migration")
            return@either
        }
--- a/data/account/src/test/java/com/tangem/data/account/producer/DefaultMultiWalletCryptoCurrenciesProducerTest.kt
+++ b/data/account/src/test/java/com/tangem/data/account/producer/DefaultMultiWalletCryptoCurrenciesProducerTest.kt
@ -10,6 +10,7 @@ import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
 import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.card.configs.GenericCardConfig
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.isMultiCurrency
@ -72,7 +73,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
        }

        verify(inverse = true) {
-            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any())
+            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any(), accountIndex = any())
        }
    }

@ -115,6 +116,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        } returns cryptoCurrencies.toList()

@ -122,6 +124,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = updatedUserTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        } returns updatedCryptoCurrencies.toList()

@ -144,6 +147,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }

@ -162,6 +166,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = updatedUserTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }
    }
@ -186,6 +191,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        } returns cryptoCurrencies.toList()

@ -208,6 +214,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }

@ -252,6 +259,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        } returns cryptoCurrencies.toList()

@ -283,6 +291,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
            responseCryptoCurrenciesFactory.createCurrencies(
                response = userTokensResponse,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }
    }
@ -307,7 +316,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {
        }

        verify(inverse = true) {
-            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any())
+            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any(), accountIndex = any())
        }
    }

@ -335,7 +344,7 @@ internal class DefaultMultiWalletCryptoCurrenciesProducerTest {

        verify(inverse = true) {
            userTokensResponseStore.get(any())
-            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any())
+            responseCryptoCurrenciesFactory.createCurrencies(response = any(), userWallet = any(), accountIndex = any())
        }
    }

--- a/data/common/build.gradle.kts
+++ b/data/common/build.gradle.kts
@ -27,6 +27,7 @@ dependencies {
    implementation(projects.domain.tokens.models)
    implementation(projects.domain.wallets.models)
    implementation(projects.domain.networks)
+    implementation(projects.domain.walletManager)
    implementation(projects.domain.wallets)

    /* Libs - SDK */
--- a/data/common/src/main/kotlin/com/tangem/data/common/currency/DefaultCardCryptoCurrencyFactory.kt
+++ b/data/common/src/main/kotlin/com/tangem/data/common/currency/DefaultCardCryptoCurrencyFactory.kt
@ -144,6 +144,9 @@ internal class DefaultCardCryptoCurrencyFactory(
                ?: return emptyMap()

            response.accounts.flatMapTo(hashSetOf()) { accountDTO ->
+                val accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull()
+                    ?: return@flatMapTo emptySet()
+
                responseCryptoCurrenciesFactory.createCurrencies(
                    tokens = accountDTO.tokens.orEmpty().filter { token ->
                        networks.any {
@ -151,7 +154,7 @@ internal class DefaultCardCryptoCurrencyFactory(
                        }
                    },
                    userWallet = userWallet,
-                    accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull(),
+                    accountIndex = accountIndex,
                )
            }
        } else {
@ -163,6 +166,7 @@ internal class DefaultCardCryptoCurrencyFactory(
                    networks.any { it.backendId == token.networkId && it.derivationPath.value == token.derivationPath }
                },
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }
            .groupBy(CryptoCurrency::network)
@ -181,10 +185,13 @@ internal class DefaultCardCryptoCurrencyFactory(
                ?: return emptyMap()

            response.accounts.flatMapTo(hashSetOf()) { accountDTO ->
+                val accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull()
+                    ?: return@flatMapTo emptySet()
+
                responseCryptoCurrenciesFactory.createCurrencies(
                    tokens = accountDTO.tokens.orEmpty().filter { token -> token.networkId in networkIds },
                    userWallet = userWallet,
-                    accountIndex = DerivationIndex(accountDTO.derivationIndex).getOrNull(),
+                    accountIndex = accountIndex,
                )
            }
        } else {
@ -194,6 +201,7 @@ internal class DefaultCardCryptoCurrencyFactory(
            responseCryptoCurrenciesFactory.createCurrencies(
                tokens = response.tokens.filter { token -> token.networkId in networkIds },
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }
            .groupBy { it.network.id.rawId }
--- a/data/common/src/main/kotlin/com/tangem/data/common/currency/ResponseCryptoCurrenciesFactory.kt
+++ b/data/common/src/main/kotlin/com/tangem/data/common/currency/ResponseCryptoCurrenciesFactory.kt
@ -22,7 +22,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
    fun createCurrencies(
        response: UserTokensResponse,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex? = null,
+        accountIndex: DerivationIndex,
    ): List<CryptoCurrency> {
        return createCurrencies(tokens = response.tokens, userWallet = userWallet, accountIndex = accountIndex)
    }
@ -30,7 +30,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
    fun createCurrencies(
        tokens: List<UserTokensResponse.Token>,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex? = null,
+        accountIndex: DerivationIndex,
    ): List<CryptoCurrency> {
        return tokens
            .asSequence()
@ -42,7 +42,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
    fun createCurrency(
        responseToken: UserTokensResponse.Token,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex? = null,
+        accountIndex: DerivationIndex,
    ): CryptoCurrency? {
        var blockchain = Blockchain.fromNetworkId(responseToken.networkId)
        if (blockchain == null || blockchain == Blockchain.Unknown) {
@ -103,7 +103,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
        blockchain: Blockchain,
        responseToken: UserTokensResponse.Token,
        network: Network,
-    ): CryptoCurrency.Coin? {
+    ): CryptoCurrency.Coin {
        return CryptoCurrency.Coin(
            id = getCoinId(network, blockchain.toCoinId()),
            network = network,
@ -127,7 +127,7 @@ class ResponseCryptoCurrenciesFactory @Inject constructor(
        }
    }

-    private fun createToken(blockchain: Blockchain, sdkToken: Token, network: Network): CryptoCurrency.Token? {
+    private fun createToken(blockchain: Blockchain, sdkToken: Token, network: Network): CryptoCurrency.Token {
        val id = getTokenId(network, sdkToken)

        return CryptoCurrency.Token(
--- a/data/common/src/main/kotlin/com/tangem/data/common/currency/UserTokensResponseAddressesEnricher.kt
+++ b/data/common/src/main/kotlin/com/tangem/data/common/currency/UserTokensResponseAddressesEnricher.kt
@ -1,55 +1,45 @@
 package com.tangem.data.common.currency

+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.address.Address
+import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
-import com.tangem.domain.models.network.NetworkStatus
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.networks.multi.MultiNetworkStatusProducer
-import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeoutOrNull
 import javax.inject.Inject
-import kotlin.time.Duration.Companion.seconds

 class UserTokensResponseAddressesEnricher @Inject constructor(
    private val walletsRepository: WalletsRepository,
    private val dispatchers: CoroutineDispatcherProvider,
-    private val multiNetworkStatusSupplier: MultiNetworkStatusSupplier,
+    private val walletManagersFacade: WalletManagersFacade,
 ) {

    suspend operator fun invoke(userWalletId: UserWalletId, response: UserTokensResponse): UserTokensResponse {
        val isNotificationsEnabled = walletsRepository.isNotificationsEnabled(userWalletId)

        return withContext(dispatchers.default) {
-            val networksStatuses = if (isNotificationsEnabled) {
-                withTimeoutOrNull(
-                    FETCH_TIMEOUT_SECONDS.seconds,
-                    { multiNetworkStatusSupplier.invoke(MultiNetworkStatusProducer.Params(userWalletId)).first() },
-                ).orEmpty()
+            val addressByToken = if (isNotificationsEnabled) {
+                response.tokens.associateWith { token ->
+                    val blockchain = Blockchain.fromNetworkId(token.networkId) ?: return@associateWith null
+
+                    val walletManager = walletManagersFacade.getOrCreateWalletManager(
+                        userWalletId = userWalletId,
+                        blockchain = blockchain,
+                        derivationPath = token.derivationPath,
+                    )
+
+                    walletManager?.wallet?.addresses?.map(Address::value)
+                }
            } else {
-                emptySet()
+                emptyMap()
            }

            val enrichedTokens = response.tokens.map { token ->
                if (isNotificationsEnabled) {
-                    val matchingNetwork = networksStatuses.find { status ->
-                        status.network.backendId == token.networkId &&
-                            status.network.derivationPath.value == token.derivationPath
-                    } ?: return@map token
-
-                    val networkAddress = when (matchingNetwork.value) {
-                        is NetworkStatus.Verified -> (matchingNetwork.value as NetworkStatus.Verified).address
-                        is NetworkStatus.NoAccount -> (matchingNetwork.value as NetworkStatus.NoAccount).address
-                        else -> null
-                    }
-
-                    val addresses = networkAddress
-                        ?.availableAddresses
-                        ?.map { it.value }
-                        ?.toList()
-                        .orEmpty()
+                    val addresses = addressByToken[token] ?: return@map token

                    token.copy(addresses = addresses)
                } else {
@ -60,8 +50,4 @@ class UserTokensResponseAddressesEnricher @Inject constructor(
            response.copy(tokens = enrichedTokens, notifyStatus = isNotificationsEnabled)
        }
    }
-
-    companion object {
-        private const val FETCH_TIMEOUT_SECONDS = 3
-    }
 }
--- a/data/common/src/main/kotlin/com/tangem/data/common/di/DataCommonModule.kt
+++ b/data/common/src/main/kotlin/com/tangem/data/common/di/DataCommonModule.kt
@ -13,7 +13,7 @@ import com.tangem.datasource.local.token.UserTokensResponseStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.account.featuretoggle.AccountsFeatureToggles
 import com.tangem.domain.demo.models.DemoConfig
-import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.repository.WalletsRepository
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.retryer.RetryerPool
@ -54,12 +54,12 @@ internal object DataCommonModule {
    @Singleton
    fun provideUserTokensEncricher(
        walletsRepository: WalletsRepository,
-        multiNetworkStatusSupplier: MultiNetworkStatusSupplier,
+        walletManagersFacade: WalletManagersFacade,
        dispatchers: CoroutineDispatcherProvider,
    ): UserTokensResponseAddressesEnricher {
        return UserTokensResponseAddressesEnricher(
            walletsRepository = walletsRepository,
-            multiNetworkStatusSupplier = multiNetworkStatusSupplier,
+            walletManagersFacade = walletManagersFacade,
            dispatchers = dispatchers,
        )
    }
--- a/data/common/src/main/kotlin/com/tangem/data/common/network/NetworkFactory.kt
+++ b/data/common/src/main/kotlin/com/tangem/data/common/network/NetworkFactory.kt
@ -74,6 +74,7 @@ class NetworkFactory @Inject constructor(
                blockchain = blockchain,
                excludedBlockchains = excludedBlockchains,
            ),
+            shouldCheckChia = false,
        )
    }

@ -128,9 +129,10 @@ class NetworkFactory @Inject constructor(
        derivationPath: Network.DerivationPath,
        canHandleTokens: Boolean,
        accountIndex: DerivationIndex? = null,
+        shouldCheckChia: Boolean = true,
    ): Network? {
        if (!blockchain.isBlockchainSupported()) return null
-        if (blockchain == Blockchain.Chia && accountIndex != DerivationIndex.Main) return null
+        if (shouldCheckChia && blockchain == Blockchain.Chia && accountIndex != DerivationIndex.Main) return null

        return runCatching {
            Network(
--- a/data/common/src/test/kotlin/com/tangem/data/common/currency/UserTokensResponseAddressesEnricherTest.kt
+++ b/data/common/src/test/kotlin/com/tangem/data/common/currency/UserTokensResponseAddressesEnricherTest.kt
@ -1,92 +1,68 @@
 package com.tangem.data.common.currency

 import com.google.common.truth.Truth.assertThat
+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchain.common.Wallet
+import com.tangem.blockchain.common.WalletManager
+import com.tangem.blockchain.common.address.Address
+import com.tangem.blockchain.common.address.AddressType
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
-import com.tangem.domain.models.StatusSource
-import com.tangem.domain.models.network.NetworkAddress
-import com.tangem.domain.models.network.NetworkStatus
 import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
+import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.repository.WalletsRepository
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
-import io.mockk.clearAllMocks
+import io.mockk.clearMocks
 import io.mockk.coEvery
 import io.mockk.every
 import io.mockk.mockk
-import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.test.runTest
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance

+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class UserTokensResponseAddressesEnricherTest {

-    private lateinit var walletsRepository: WalletsRepository
-    private val dispatchers: CoroutineDispatcherProvider = TestingCoroutineDispatcherProvider()
-    private lateinit var multiNetworkStatusSupplier: MultiNetworkStatusSupplier
-    private lateinit var enricher: UserTokensResponseAddressesEnricher
+    private val walletsRepository: WalletsRepository = mockk()
+    private val walletManagersFacade: WalletManagersFacade = mockk()
+    private val enricher: UserTokensResponseAddressesEnricher = UserTokensResponseAddressesEnricher(
+        walletsRepository = walletsRepository,
+        walletManagersFacade = walletManagersFacade,
+        dispatchers = TestingCoroutineDispatcherProvider(),
+    )

-    @Before
-    fun setup() {
-        walletsRepository = mockk()
-        multiNetworkStatusSupplier = mockk()
+    private val userWalletId = UserWalletId("1234567890abcdef")

-        enricher = UserTokensResponseAddressesEnricher(
-            walletsRepository = walletsRepository,
-            dispatchers = dispatchers,
-            multiNetworkStatusSupplier = multiNetworkStatusSupplier,
-        )
-    }
-
-    @After
+    @AfterEach
    fun tearDown() {
-        clearAllMocks()
-    }
-
-    @Test
-    fun `GIVEN notifications are disabled globally WHEN invoke THEN return original response`() = runTest {
-        // GIVEN
-        val userWalletId = UserWalletId("1234567890abcdef")
-        val token = createToken()
-        val response = createUserTokensResponse(tokens = listOf(token))
-
-        // WHEN
-        val result = enricher(userWalletId, response)
-
-        // THEN
-        assertThat(result).isEqualTo(response)
+        clearMocks(walletsRepository, walletManagersFacade)
    }

    @Test
    fun `GIVEN notifications are disabled for wallet WHEN invoke THEN return response with empty addresses`() =
        runTest {
            // GIVEN
-            val userWalletId = UserWalletId("1234567890abcdef")
            val token = createToken()
            val response = createUserTokensResponse(tokens = listOf(token))
+            val walletManager = mockk<WalletManager> {
+                val wallet = mockk<Wallet> {
+                    every { addresses } returns setOf(
+                        Address(value = "0x12345", type = AddressType.Default),
+                    )
+                }
+
+                every { this@mockk.wallet } returns wallet
+            }
+
            coEvery { walletsRepository.isNotificationsEnabled(userWalletId) } returns false
+
            coEvery {
-                multiNetworkStatusSupplier.invoke(any())
-            } returns flowOf(
-                setOf(
-                    NetworkStatus(
-                        network = mockk {
-                            every { backendId } returns "ethereum"
-                            every { derivationPath.value } returns "m/44'/60'/0'/0/0"
-                        },
-                        value = NetworkStatus.Verified(
-                            address = mockk {
-                                every { availableAddresses } returns emptySet()
-                            },
-                            amounts = emptyMap(),
-                            pendingTransactions = emptyMap(),
-                            yieldSupplyStatuses = emptyMap(),
-                            source = StatusSource.ACTUAL,
-                        ),
-                    ),
-                ),
-            )
+                walletManagersFacade.getOrCreateWalletManager(
+                    userWalletId = userWalletId,
+                    blockchain = Blockchain.Ethereum,
+                    derivationPath = token.derivationPath,
+                )
+            } returns walletManager

            // WHEN
            val result = enricher(userWalletId, response)
@ -100,75 +76,52 @@ class UserTokensResponseAddressesEnricherTest {
    fun `GIVEN notifications are enabled and addresses available WHEN invoke THEN return enriched response`() =
        runTest {
            // GIVEN
-            val userWalletId = UserWalletId("1234567890abcdef")
            val token = createToken()
            val response = createUserTokensResponse(tokens = listOf(token))
-            val addresses = listOf("0x123", "0x456")
+            val addresses = setOf(
+                Address(value = "0x123", type = AddressType.Default),
+                Address(value = "0x456", type = AddressType.Legacy),
+            )
+
+            val walletManager = mockk<WalletManager> {
+                val wallet = mockk<Wallet> {
+                    every { this@mockk.addresses } returns addresses
+                }
+
+                every { this@mockk.wallet } returns wallet
+            }

            coEvery { walletsRepository.isNotificationsEnabled(userWalletId) } returns true
            coEvery {
-                multiNetworkStatusSupplier.invoke(any())
-            } returns flowOf(
-                setOf(
-                    NetworkStatus(
-                        network = mockk {
-                            every { backendId } returns "ethereum"
-                            every { derivationPath.value } returns "m/44'/60'/0'/0/0"
-                        },
-                        value = NetworkStatus.Verified(
-                            address = mockk {
-                                every { availableAddresses } returns addresses.map { address ->
-                                    mockk<NetworkAddress.Address> {
-                                        every { value } returns address
-                                    }
-                                }.toSet()
-                            },
-                            amounts = emptyMap(),
-                            pendingTransactions = emptyMap(),
-                            yieldSupplyStatuses = emptyMap(),
-                            source = StatusSource.ACTUAL,
-                        ),
-                    ),
-                ),
-            )
+                walletManagersFacade.getOrCreateWalletManager(
+                    userWalletId = userWalletId,
+                    blockchain = Blockchain.Ethereum,
+                    derivationPath = token.derivationPath,
+                )
+            } returns walletManager

            // WHEN
            val result = enricher(userWalletId, response)

            // THEN
            assertThat(result.tokens).hasSize(1)
-            assertThat(result.tokens[0].addresses).containsExactlyElementsIn(addresses)
+            assertThat(result.tokens[0].addresses).containsExactlyElementsIn(addresses.map { it.value })
        }

    @Test
    fun `GIVEN notifications are enabled but no matching network WHEN invoke THEN return original token`() = runTest {
        // GIVEN
-        val userWalletId = UserWalletId("1234567890abcdef")
        val token = createToken()
        val response = createUserTokensResponse(tokens = listOf(token))

        coEvery { walletsRepository.isNotificationsEnabled(userWalletId) } returns true
        coEvery {
-            multiNetworkStatusSupplier.invoke(any())
-        } returns flowOf(
-            setOf(
-                NetworkStatus(
-                    network = mockk {
-                        every { backendId } returns "bitcoin"
-                        every { derivationPath.value } returns "m/44'/0'/0'/0/0"
-                    },
-                    value = NetworkStatus.Verified(
-                        address = mockk {
-                            every { availableAddresses } returns emptySet()
-                        },
-                        amounts = emptyMap(),
-                        pendingTransactions = emptyMap(),
-                        yieldSupplyStatuses = emptyMap(),
-                        source = StatusSource.ACTUAL,
-                    ),
-                ),
-            ),
-        )
+            walletManagersFacade.getOrCreateWalletManager(
+                userWalletId = userWalletId,
+                blockchain = Blockchain.Ethereum,
+                derivationPath = token.derivationPath,
+            )
+        } returns null

        // WHEN
        val result = enricher(userWalletId, response)
--- a/data/feedback/detekt-baseline-debug.xml
+++ b/data/feedback/detekt-baseline-debug.xml
@ -1,9 +0,0 @@
-<?xml version="1.0" ?>
-<SmellBaseline>
-  <ManuallySuppressedIssues/>
-  <CurrentIssues>
-    <ID>BooleanPropertyNaming:DefaultFeedbackRepository.kt$DefaultFeedbackRepository$private val useNewUserWalletsRepository: Boolean</ID>
-    <ID>MultilineLambdaItParameter:DefaultFeedbackRepository.kt$DefaultFeedbackRepository${ it.toMutableMap().apply { put(userWallet.walletId, error) } }</ID>
-    <ID>UseOrEmpty:BlockchainInfoConverter.kt$BlockchainInfoConverter$value.wallet.publicKey.derivationPath?.rawPath ?: ""</ID>
-  </CurrentIssues>
-</SmellBaseline>
--- a/data/feedback/src/main/java/com/tangem/data/feedback/DefaultFeedbackRepository.kt
+++ b/data/feedback/src/main/java/com/tangem/data/feedback/DefaultFeedbackRepository.kt
@ -26,7 +26,7 @@ import java.io.File
 *
 * @property appLogsStore           app logs store
 * @property userWalletsListManager user wallets list manager
- * @property useNewUserWalletsRepository flag to use new user wallets repository
+ * @property shouldUseNewUserWalletsRepository flag to use new user wallets repository
 * @property userWalletsListRepository   user wallets repository
 * @property walletManagersStore    wallet managers store
 * @property emailSender            email sender
@ -37,7 +37,7 @@ import java.io.File
@Suppress("LongParameterList")
 internal class DefaultFeedbackRepository(
    private val appLogsStore: AppLogsStore,
-    private val useNewUserWalletsRepository: Boolean,
+    private val shouldUseNewUserWalletsRepository: Boolean,
    private val userWalletsListRepository: UserWalletsListRepository,
    private val userWalletsListManager: UserWalletsListManager,
    private val walletManagersStore: WalletManagersStore,
@ -97,9 +97,9 @@ internal class DefaultFeedbackRepository(
    override fun saveBlockchainErrorInfo(error: BlockchainErrorInfo) {
        val userWallet = getSelectedWalletUseCase.sync().getOrNull() ?: error("UserWallet is not selected")

-        blockchainsErrors.update {
-            it.toMutableMap().apply {
-                put(userWallet.walletId, error)
+        blockchainsErrors.update { map ->
+            map.toMutableMap().apply {
+                this[userWallet.walletId] = error
            }
        }
    }
@ -126,7 +126,7 @@ internal class DefaultFeedbackRepository(
    }

    private suspend fun getUserWalletById(userWalletId: UserWalletId): UserWallet? {
-        return if (useNewUserWalletsRepository) {
+        return if (shouldUseNewUserWalletsRepository) {
            userWalletsListRepository.userWalletsSync().find { it.walletId == userWalletId }
        } else {
            userWalletsListManager.userWalletsSync.find { it.walletId == userWalletId }
@ -134,7 +134,7 @@ internal class DefaultFeedbackRepository(
    }

    private fun totalUserWallets(): Int {
-        return if (useNewUserWalletsRepository) {
+        return if (shouldUseNewUserWalletsRepository) {
            userWalletsListRepository.userWallets.value?.size ?: 0
        } else {
            userWalletsListManager.walletsCount
--- a/data/feedback/src/main/java/com/tangem/data/feedback/converters/BlockchainInfoConverter.kt
+++ b/data/feedback/src/main/java/com/tangem/data/feedback/converters/BlockchainInfoConverter.kt
@ -16,9 +16,11 @@ import com.tangem.domain.feedback.models.BlockchainInfo.Addresses as BlockchainA
 internal object BlockchainInfoConverter : Converter<WalletManager, BlockchainInfo> {

    override fun convert(value: WalletManager): BlockchainInfo {
+        val derivationPath = value.wallet.publicKey.derivationPath
+
        return BlockchainInfo(
            blockchain = value.wallet.blockchain.fullName,
-            derivationPath = value.wallet.publicKey.derivationPath?.rawPath ?: "",
+            derivationPath = derivationPath?.rawPath.orEmpty(),
            outputsCount = value.outputsCount?.toString(),
            host = value.currentHost,
            addresses = value.wallet.mapAddresses(Address::value),
--- a/data/feedback/src/main/java/com/tangem/data/feedback/di/FeedbackModule.kt
+++ b/data/feedback/src/main/java/com/tangem/data/feedback/di/FeedbackModule.kt
@ -42,7 +42,7 @@ internal object FeedbackModule {
            emailSender = emailSender,
            appVersionProvider = appVersionProvider,
            userWalletsListRepository = userWalletsListRepository,
-            useNewUserWalletsRepository = hotWalletFeatureToggles.isHotWalletEnabled,
+            shouldUseNewUserWalletsRepository = hotWalletFeatureToggles.isHotWalletEnabled,
            getSelectedWalletUseCase = getSelectedWalletUseCase,
        )
    }
--- a/data/manage-tokens/detekt-baseline-debug.xml
+++ b/data/manage-tokens/detekt-baseline-debug.xml
@ -3,15 +3,7 @@
  <ManuallySuppressedIssues/>
  <CurrentIssues>
    <ID>MultilineLambdaItParameter:DefaultCustomTokensRepository.kt$DefaultCustomTokensRepository${ // TODO: refactor https://tangem.atlassian.net/browse/AND-10006\ if (it.isTestnet() || it in excludedBlockchains || it in hotWalletExcludedBlockchains) { return@mapNotNull null } networkFactory.create( blockchain = it, extraDerivationPath = null, userWallet = userWallet, ) }</ID>
-    <ID>MultilineLambdaItParameter:DefaultManageTokensRepository.kt$DefaultManageTokensRepository${ it.contractAddress != null &amp;&amp; it.networkId == network.backendId &amp;&amp; it.derivationPath == network.derivationPath.value }</ID>
    <ID>MultilineLambdaItParameter:ManageTokensUpdateFetcher.kt$ManageTokensUpdateFetcher${ if (it.key == toUpdate[index].key) { Batch(it.key, updatedItems) } else { null } }</ID>
-    <ID>NamedArguments:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$create(coinsResponse, tokensResponse, userWallet, accountIndex)</ID>
-    <ID>NamedArguments:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$createToken(coin, tokensResponse, coinsResponse.imageHost, userWallet, accountIndex)</ID>
-    <ID>NamedArguments:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$findAddedInNetworks(coinResponse.id, tokensResponse, userWallet, accountIndex)</ID>
-    <ID>NamedArguments:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$findAddedInNetworks(testnetToken.id, tokensResponse, userWallet, accountIndex)</ID>
-    <ID>SuspendFunSwallowedCancellation:DefaultManageTokensRepository.kt$DefaultManageTokensRepository$runCatching</ID>
    <ID>UnsafeCallOnNullableType:DefaultCustomTokensRepository.kt$DefaultCustomTokensRepository$coinNetwork.decimalCount!!</ID>
-    <ID>UseOrEmpty:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$testnetToken.networks?.mapNotNull { network -&gt; createSource( networkId = network.id, contractAddress = network.address, decimals = network.decimalCount, userWallet = userWallet, accountIndex = accountIndex, ) } ?: emptyList()</ID>
-    <ID>UseOrEmpty:ManagedCryptoCurrencyFactory.kt$ManagedCryptoCurrencyFactory$tokensResponse ?.let { createCustomTokens(it, userWallet, accountIndex) } ?: emptyList()</ID>
  </CurrentIssues>
 </SmellBaseline>
--- a/data/manage-tokens/src/main/kotlin/com/tangem/data/managetokens/DefaultManageTokensRepository.kt
+++ b/data/manage-tokens/src/main/kotlin/com/tangem/data/managetokens/DefaultManageTokensRepository.kt
@ -41,6 +41,7 @@ import com.tangem.pagination.fetcher.LimitOffsetBatchFetcher
 import com.tangem.pagination.fetcher.LimitOffsetBatchFetcher.Request
 import com.tangem.pagination.toBatchFlow
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.coroutines.runSuspendCatching

@Suppress("LongParameterList", "LargeClass")
 internal class DefaultManageTokensRepository(
@ -176,7 +177,7 @@ internal class DefaultManageTokensRepository(
            val shouldFetch = loadUserTokensFromRemote && userWallet != null

            val fetchedResponse = if (shouldFetch) {
-                runCatching { walletAccountsFetcher.fetch(userWalletId = userWallet.walletId) }.getOrNull()
+                runSuspendCatching { walletAccountsFetcher.fetch(userWalletId = userWallet.walletId) }.getOrNull()
            } else {
                null
            }
@ -214,19 +215,22 @@ internal class DefaultManageTokensRepository(
            userWallet != null &&
            query == null

+        val accountIndex = accountDTO?.derivationIndex?.let(DerivationIndex::invoke)?.getOrNull()
+            ?: return emptyList()
+
        val items = if (isCreateWithCustom) {
            managedCryptoCurrencyFactory.createWithCustomTokens(
                coinsResponse = updatedCoinsResponse,
                tokensResponse = tokensResponse,
                userWallet = userWallet,
-                accountIndex = accountDTO?.derivationIndex?.let(DerivationIndex::invoke)?.getOrNull(),
+                accountIndex = accountIndex,
            )
        } else {
            managedCryptoCurrencyFactory.create(
                coinsResponse = updatedCoinsResponse,
                tokensResponse = tokensResponse,
                userWallet = userWallet,
-                accountIndex = accountDTO?.derivationIndex?.let(DerivationIndex::invoke)?.getOrNull(),
+                accountIndex = accountIndex,
            )
        }

@ -262,14 +266,14 @@ internal class DefaultManageTokensRepository(
                coinsResponse = updatedCoinsResponse,
                tokensResponse = tokensResponse,
                userWallet = userWallet,
-                accountIndex = null,
+                accountIndex = DerivationIndex.Main,
            )
        } else {
            managedCryptoCurrencyFactory.create(
                coinsResponse = updatedCoinsResponse,
                tokensResponse = tokensResponse,
                userWallet = userWallet,
-                accountIndex = null,
+                accountIndex = DerivationIndex.Main,
            )
        }
    }
@ -307,6 +311,13 @@ internal class DefaultManageTokensRepository(
            )
        }

+        val accountIndex = accountDTO?.derivationIndex?.let(DerivationIndex::invoke)?.getOrNull()
+            ?: return BatchFetchResult.Success(
+                data = emptyList(),
+                empty = true,
+                last = true,
+            )
+
        val items = managedCryptoCurrencyFactory.createTestnetWithCustomTokens(
            testnetTokensConfig = if (!searchText.isNullOrBlank()) {
                testnetTokensConfig.copy(
@ -320,7 +331,7 @@ internal class DefaultManageTokensRepository(
            },
            tokensResponse = tokensResponse,
            userWallet = userWallet,
-            accountIndex = accountDTO?.derivationIndex?.let(DerivationIndex::invoke)?.getOrNull(),
+            accountIndex = accountIndex,
        )

        return BatchFetchResult.Success(
@ -350,7 +361,7 @@ internal class DefaultManageTokensRepository(
            },
            tokensResponse = getSavedUserTokensResponseSync(userWallet.walletId),
            userWallet = userWallet,
-            accountIndex = null,
+            accountIndex = DerivationIndex.Main,
        )

        return BatchFetchResult.Success(
@ -392,10 +403,10 @@ internal class DefaultManageTokensRepository(
        )
        val newTokensList = storedTokens.tokens + addedTokens - removedTokens.toSet()

-        return newTokensList.any {
-            it.contractAddress != null &&
-                it.networkId == network.backendId &&
-                it.derivationPath == network.derivationPath.value
+        return newTokensList.any { token ->
+            token.contractAddress != null &&
+                token.networkId == network.backendId &&
+                token.derivationPath == network.derivationPath.value
        }
    }

--- a/data/manage-tokens/src/main/kotlin/com/tangem/data/managetokens/utils/ManagedCryptoCurrencyFactory.kt
+++ b/data/manage-tokens/src/main/kotlin/com/tangem/data/managetokens/utils/ManagedCryptoCurrencyFactory.kt
@ -35,10 +35,16 @@ internal class ManagedCryptoCurrencyFactory(
        coinsResponse: CoinsResponse,
        tokensResponse: UserTokensResponse?,
        userWallet: UserWallet?,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): List<ManagedCryptoCurrency> {
        return coinsResponse.coins.mapNotNull { coin ->
-            createToken(coin, tokensResponse, coinsResponse.imageHost, userWallet, accountIndex)
+            createToken(
+                coinResponse = coin,
+                tokensResponse = tokensResponse,
+                imageHost = coinsResponse.imageHost,
+                userWallet = userWallet,
+                accountIndex = accountIndex,
+            )
        }
    }

@ -46,10 +52,15 @@ internal class ManagedCryptoCurrencyFactory(
        coinsResponse: CoinsResponse,
        tokensResponse: UserTokensResponse,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): List<ManagedCryptoCurrency> {
        val customTokens = createCustomTokens(tokensResponse, userWallet, accountIndex)
-        val tokens = create(coinsResponse, tokensResponse, userWallet, accountIndex)
+        val tokens = create(
+            coinsResponse = coinsResponse,
+            tokensResponse = tokensResponse,
+            userWallet = userWallet,
+            accountIndex = accountIndex,
+        )

        return customTokens + tokens
    }
@ -58,11 +69,11 @@ internal class ManagedCryptoCurrencyFactory(
        testnetTokensConfig: TestnetTokensConfig,
        tokensResponse: UserTokensResponse?,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): List<ManagedCryptoCurrency> {
        val customTokens = tokensResponse
            ?.let { createCustomTokens(it, userWallet, accountIndex) }
-            ?: emptyList()
+            .orEmpty()
        val testnetTokens = testnetTokensConfig.tokens.map { testnetToken ->
            ManagedCryptoCurrency.Token(
                id = ManagedCryptoCurrency.ID(testnetToken.id),
@ -77,8 +88,13 @@ internal class ManagedCryptoCurrencyFactory(
                        userWallet = userWallet,
                        accountIndex = accountIndex,
                    )
-                } ?: emptyList(),
-                addedIn = findAddedInNetworks(testnetToken.id, tokensResponse, userWallet, accountIndex),
+                }.orEmpty(),
+                addedIn = findAddedInNetworks(
+                    currencyId = testnetToken.id,
+                    tokensResponse = tokensResponse,
+                    userWallet = userWallet,
+                    accountIndex = accountIndex,
+                ),
            )
        }

@ -88,7 +104,7 @@ internal class ManagedCryptoCurrencyFactory(
    private fun createCustomTokens(
        tokensResponse: UserTokensResponse,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): List<ManagedCryptoCurrency> = tokensResponse.tokens
        .mapNotNull { token ->
            maybeCreateCustomToken(token, userWallet, accountIndex)
@ -97,7 +113,7 @@ internal class ManagedCryptoCurrencyFactory(
    private fun maybeCreateCustomToken(
        token: UserTokensResponse.Token,
        userWallet: UserWallet,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): ManagedCryptoCurrency? {
        val blockchain = Blockchain.fromNetworkId(token.networkId)
            ?.takeUnless { it in excludedBlockchains }
@ -161,7 +177,7 @@ internal class ManagedCryptoCurrencyFactory(
        tokensResponse: UserTokensResponse?,
        imageHost: String?,
        userWallet: UserWallet?,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): ManagedCryptoCurrency? {
        if (coinResponse.networks.isEmpty() || !coinResponse.active) return null

@ -184,7 +200,12 @@ internal class ManagedCryptoCurrencyFactory(
            symbol = coinResponse.symbol,
            iconUrl = getIconUrl(coinResponse.id, imageHost),
            availableNetworks = availableNetworks,
-            addedIn = findAddedInNetworks(coinResponse.id, tokensResponse, userWallet, accountIndex),
+            addedIn = findAddedInNetworks(
+                currencyId = coinResponse.id,
+                tokensResponse = tokensResponse,
+                userWallet = userWallet,
+                accountIndex = accountIndex,
+            ),
        )
    }

@ -194,7 +215,7 @@ internal class ManagedCryptoCurrencyFactory(
        decimals: Int?,
        userWallet: UserWallet?,
        extraDerivationPath: String? = null,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): SourceNetwork? {
        val blockchain = Blockchain.fromNetworkId(networkId)
            ?.takeUnless { it in excludedBlockchains }
@ -235,7 +256,7 @@ internal class ManagedCryptoCurrencyFactory(
        currencyId: String,
        tokensResponse: UserTokensResponse?,
        userWallet: UserWallet?,
-        accountIndex: DerivationIndex?,
+        accountIndex: DerivationIndex,
    ): Set<Network> {
        if (tokensResponse == null) return emptySet()

--- a/data/nft/build.gradle.kts
+++ b/data/nft/build.gradle.kts
@ -12,6 +12,10 @@ android {
    namespace = "com.tangem.data.nft"
 }

+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}
+
 dependencies {

    /** Project - Data */
@ -53,4 +57,8 @@ dependencies {
    /** DI */
    implementation(deps.hilt.android)
    kapt(deps.hilt.kapt)
+
+    testImplementation(projects.test.core)
+    testImplementation(projects.common.test)
+    testRuntimeOnly(deps.test.junit5.engine)
 }
--- a/data/nft/src/main/kotlin/com/tangem/data/nft/DefaultNFTRepository.kt
+++ b/data/nft/src/main/kotlin/com/tangem/data/nft/DefaultNFTRepository.kt
@ -1,5 +1,6 @@
 package com.tangem.data.nft

+import android.content.Context
 import android.content.res.Resources
 import arrow.core.Either
 import com.tangem.blockchain.common.Blockchain
@ -26,15 +27,19 @@ import com.tangem.domain.nft.models.NFTCollection
 import com.tangem.domain.nft.models.NFTCollections
 import com.tangem.domain.nft.models.NFTSalePrice
 import com.tangem.domain.nft.repository.NFTRepository
+import com.tangem.domain.nft.utils.NFTCleaner
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.JobHolder
+import com.tangem.utils.coroutines.runSuspendCatching
 import com.tangem.utils.coroutines.saveIn
+import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import timber.log.Timber
 import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import com.tangem.blockchain.nft.models.NFTAsset as SdkNFTAsset
@ -49,9 +54,10 @@ internal class DefaultNFTRepository @Inject constructor(
    private val userWalletsStore: UserWalletsStore,
    private val networkFactory: NetworkFactory,
    private val excludedBlockchains: ExcludedBlockchains,
-    resources: Resources,
-) : NFTRepository {
+    @ApplicationContext private val context: Context,
+) : NFTRepository, NFTCleaner {

+    private val resources: Resources by lazy { context.resources }
    private val networkJobs = ConcurrentHashMap<Network, JobHolder>()
    private val collectionJobs = ConcurrentHashMap<NFTCollection.Identifier, JobHolder>()
    private val cryptoCurrencyFactory = CryptoCurrencyFactory(excludedBlockchains)
@ -218,10 +224,22 @@ internal class DefaultNFTRepository @Inject constructor(
            assetIdentifier = assetIdConverter.convertBack(assetIdentifier),
        )

-    override suspend fun clearCache(userWalletId: UserWalletId, networks: List<Network>) {
-        networks.forEach {
-            getNFTPersistenceStore(userWalletId, it).clear()
-            getNFTRuntimeStore(userWalletId, it).clear()
+    // NFTCleaner implementation
+    override suspend fun invoke(userWalletId: UserWalletId, networks: Set<Network>) {
+        if (networks.isEmpty()) {
+            Timber.d("No networks to clear for wallet: $userWalletId")
+            return
+        }
+
+        networks.forEach { network ->
+            runSuspendCatching {
+                getNFTPersistenceStore(userWalletId = userWalletId, network = network).clear()
+                // FIXME: nftRuntimeStore is created with only network, so clearing it may affect other wallets
+                //  nftRuntimeStoreFactory.provide(network = network).clear()
+            }
+                .onFailure { throwable ->
+                    Timber.e(throwable, "Failed to clear NFT data for network $network for wallet: $userWalletId")
+                }
        }
    }

--- a/data/nft/src/main/kotlin/com/tangem/data/nft/di/NFTDataModule.kt
+++ b/data/nft/src/main/kotlin/com/tangem/data/nft/di/NFTDataModule.kt
@ -1,45 +1,23 @@
 package com.tangem.data.nft.di

-import android.content.Context
-import com.tangem.blockchainsdk.utils.ExcludedBlockchains
-import com.tangem.data.common.network.NetworkFactory
 import com.tangem.data.nft.DefaultNFTRepository
-import com.tangem.datasource.local.nft.NFTPersistenceStoreFactory
-import com.tangem.datasource.local.nft.NFTRuntimeStoreFactory
-import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.nft.repository.NFTRepository
-import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.domain.nft.utils.NFTCleaner
+import dagger.Binds
 import dagger.Module
-import dagger.Provides
 import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton

@Module
@InstallIn(SingletonComponent::class)
-internal object NFTDataModule {
+internal interface NFTDataModule {

-    @Provides
+    @Binds
    @Singleton
-    fun provideNFTRepository(
-        @ApplicationContext context: Context,
-        nftPersistenceStoreFactory: NFTPersistenceStoreFactory,
-        nftRuntimeStoreFactory: NFTRuntimeStoreFactory,
-        walletManagersFacade: WalletManagersFacade,
-        dispatchers: CoroutineDispatcherProvider,
-        excludedBlockchains: ExcludedBlockchains,
-        userWalletsStore: UserWalletsStore,
-        networkFactory: NetworkFactory,
-    ): NFTRepository = DefaultNFTRepository(
-        nftPersistenceStoreFactory = nftPersistenceStoreFactory,
-        nftRuntimeStoreFactory = nftRuntimeStoreFactory,
-        walletManagersFacade = walletManagersFacade,
-        dispatchers = dispatchers,
-        excludedBlockchains = excludedBlockchains,
-        userWalletsStore = userWalletsStore,
-        networkFactory = networkFactory,
-        resources = context.resources,
-    )
+    fun bindNFTRepository(defaultNFTRepository: DefaultNFTRepository): NFTRepository
+
+    @Binds
+    @Singleton
+    fun bindNFTCleaner(defaultNFTRepository: DefaultNFTRepository): NFTCleaner
 }
--- a/data/nft/src/test/kotlin/com/tangem/data/nft/NFTCleanerTest.kt
+++ b/data/nft/src/test/kotlin/com/tangem/data/nft/NFTCleanerTest.kt
@ -0,0 +1,78 @@
+package com.tangem.data.nft
+
+import com.tangem.common.test.domain.token.MockCryptoCurrencyFactory
+import com.tangem.datasource.local.nft.NFTPersistenceStore
+import com.tangem.datasource.local.nft.NFTPersistenceStoreFactory
+import com.tangem.datasource.local.nft.NFTRuntimeStore
+import com.tangem.datasource.local.nft.NFTRuntimeStoreFactory
+import com.tangem.domain.models.currency.CryptoCurrency
+import com.tangem.domain.models.wallet.UserWalletId
+import io.mockk.*
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class NFTCleanerTest {
+
+    private val nftPersistenceStoreFactory: NFTPersistenceStoreFactory = mockk()
+    private val nftRuntimeStoreFactory: NFTRuntimeStoreFactory = mockk()
+
+    private val nftCleaner = DefaultNFTRepository(
+        nftPersistenceStoreFactory = nftPersistenceStoreFactory,
+        nftRuntimeStoreFactory = nftRuntimeStoreFactory,
+        walletManagersFacade = mockk(),
+        dispatchers = mockk(),
+        userWalletsStore = mockk(),
+        networkFactory = mockk(),
+        excludedBlockchains = mockk(),
+        context = mockk(),
+    )
+
+    private val userWalletId = UserWalletId("011")
+
+    @AfterEach
+    fun tearDown() {
+        clearMocks(nftPersistenceStoreFactory, nftRuntimeStoreFactory)
+    }
+
+    @Test
+    fun `should call invoke with multiple networks`() = runTest {
+        // Arrange
+        val mockCryptoCurrencyFactory = MockCryptoCurrencyFactory()
+        val networks = mockCryptoCurrencyFactory.ethereumAndStellar.map(CryptoCurrency.Coin::network)
+        val persistenceByNetwork = networks.associateWith { mockk<NFTPersistenceStore>(relaxUnitFun = true) }
+        val runtimeByNetwork = networks.associateWith { mockk<NFTRuntimeStore>(relaxUnitFun = true) }
+
+        networks.forEach { network ->
+            every { nftPersistenceStoreFactory.provide(userWalletId, network) } returns persistenceByNetwork[network]!!
+            every { nftRuntimeStoreFactory.provide(network) } returns runtimeByNetwork[network]!!
+        }
+
+        // Act
+        nftCleaner.invoke(userWalletId = userWalletId, networks = networks.toSet())
+
+        // Assert
+        coVerifyOrder {
+            networks.forEach { network ->
+                nftPersistenceStoreFactory.provide(userWalletId, network)
+                persistenceByNetwork[network]!!.clear()
+                // nftRuntimeStoreFactory.provide(network)
+                // runtimeByNetwork[network]!!.clear()
+            }
+        }
+    }
+
+    @Test
+    fun `should handle empty networks set`() = runTest {
+        // Act
+        nftCleaner.invoke(userWalletId, emptySet())
+
+        // Assert
+        coVerify(inverse = true) {
+            nftPersistenceStoreFactory.provide(userWalletId = any(), network = any())
+            nftRuntimeStoreFactory.provide(network = any())
+        }
+    }
+}
--- a/data/promo/detekt-baseline-debug.xml
+++ b/data/promo/detekt-baseline-debug.xml
@ -1,10 +0,0 @@
-<?xml version="1.0" ?>
-<SmellBaseline>
-  <ManuallySuppressedIssues/>
-  <CurrentIssues>
-    <ID>NullableBooleanCheck:DefaultPromoRepository.kt$DefaultPromoRepository$getSepaPromoBanner()?.isActive ?: false</ID>
-    <ID>NullableBooleanCheck:DefaultPromoRepository.kt$DefaultPromoRepository$getVisaPromoBanner()?.isActive ?: false</ID>
-    <ID>SuspendFunSwallowedCancellation:DefaultPromoRepository.kt$DefaultPromoRepository$runCatching</ID>
-    <ID>SuspendFunWithFlowReturnType:DefaultPromoRepository.kt$DefaultPromoRepository$suspend</ID>
-  </CurrentIssues>
-</SmellBaseline>
--- a/data/promo/src/main/java/com/tangem/data/promo/DefaultPromoRepository.kt
+++ b/data/promo/src/main/java/com/tangem/data/promo/DefaultPromoRepository.kt
@ -19,6 +19,7 @@ import com.tangem.domain.promo.models.StoryContent
 import com.tangem.feature.referral.domain.ReferralRepository
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.coroutines.runCatching
+import com.tangem.utils.coroutines.runSuspendCatching
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
@ -42,7 +43,7 @@ internal class DefaultPromoRepository(
            .distinctUntilChanged()
            .map { shouldShow ->
                when (promoId) {
-                    PromoId.Referral -> runCatching {
+                    PromoId.Referral -> runSuspendCatching {
                        !referralRepository.isReferralParticipant(userWalletId) && shouldShow
                    }.getOrDefault(false)
                    PromoId.Sepa -> {
@ -81,7 +82,7 @@ internal class DefaultPromoRepository(
        appPreferencesStore.store(PreferencesKeys.getShouldShowPromoKey(promoId = promoId.name), false)
    }

-    override suspend fun isMarketsStakingNotificationHideClicked(): Flow<Boolean> {
+    override fun isMarketsStakingNotificationHideClicked(): Flow<Boolean> {
        return appPreferencesStore.get(
            key = PreferencesKeys.MARKETS_STAKING_NOTIFICATION_HIDE_CLICKED_KEY,
            default = false,
@ -105,7 +106,7 @@ internal class DefaultPromoRepository(
        val storedPromo = promoStoriesStore.getSyncOrNull(storyId = id)
        // Get last stored promo by id if possible or get from network
        val story = if (storedPromo == null && refresh) {
-            val storyContent = runCatching {
+            val storyContent = runSuspendCatching {
                // Important to return
                withTimeoutOrNull(STORIES_LOAD_DELAY) {
                    tangemApi.getStoryById(storyId = id).getOrThrow()
--- a/data/staking/build.gradle.kts
+++ b/data/staking/build.gradle.kts
@ -51,6 +51,7 @@ dependencies {
    implementation(deps.androidx.datastore)
    implementation(deps.jodatime)
    implementation(deps.kotlin.coroutines)
+    implementation(deps.kotlin.datetime)
    implementation(deps.kotlin.immutable.collections)
    implementation(deps.moshi)
    implementation(deps.moshi.kotlin)
--- a/data/staking/src/main/java/com/tangem/data/staking/converters/ethpool/P2PYieldBalanceConverter.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/converters/ethpool/P2PYieldBalanceConverter.kt
@ -0,0 +1,92 @@
+package com.tangem.data.staking.converters.ethpool
+
+import com.tangem.domain.models.StatusSource
+import com.tangem.domain.models.staking.*
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolAccount
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolVault
+import java.math.BigDecimal
+
+/**
+ * tmp solution before facade implementation
+ */
+internal object P2PYieldBalanceConverter {
+
+    private const val ETH_DECIMALS = 18
+    private const val ETH_SYMBOL = "ETH"
+    private const val ETH_NAME = "Ethereum"
+    private const val ETH_COINGECKO_ID = "ethereum"
+
+    fun convert(
+        account: P2PEthPoolAccount,
+        vault: P2PEthPoolVault,
+        address: String,
+        source: StatusSource,
+    ): YieldBalance {
+        val integrationId = "p2p-ethereum-pooled"
+        val stakingId = StakingID(
+            integrationId = integrationId,
+            address = address,
+        )
+
+        val balanceItems = buildBalanceItems(account, vault)
+
+        return if (balanceItems.isEmpty()) {
+            YieldBalance.Empty(stakingId = stakingId, source = source)
+        } else {
+            YieldBalance.Data(
+                stakingId = stakingId,
+                source = source,
+                balance = YieldBalanceItem(
+                    items = balanceItems,
+                    integrationId = integrationId,
+                ),
+            )
+        }
+    }
+
+    private fun buildBalanceItems(account: P2PEthPoolAccount, vault: P2PEthPoolVault): List<BalanceItem> = buildList {
+        if (account.stake.assets > BigDecimal.ZERO) {
+            add(
+                createBalanceItem(
+                    groupId = "p2p-staked",
+                    amount = account.stake.assets,
+                    type = BalanceType.STAKED,
+                    validatorAddress = vault.vaultAddress,
+                ),
+            )
+        }
+    }
+
+    private fun createBalanceItem(
+        groupId: String,
+        amount: BigDecimal,
+        type: BalanceType,
+        validatorAddress: String,
+    ): BalanceItem {
+        return BalanceItem(
+            groupId = groupId,
+            token = createEthToken(),
+            type = type,
+            amount = amount,
+            rawCurrencyId = ETH_COINGECKO_ID,
+            validatorAddress = validatorAddress,
+            date = null,
+            pendingActions = emptyList(),
+            pendingActionsConstraints = emptyList(),
+            isPending = false,
+        )
+    }
+
+    private fun createEthToken(): YieldToken {
+        return YieldToken(
+            name = ETH_NAME,
+            network = NetworkType.ETHEREUM,
+            symbol = ETH_SYMBOL,
+            decimals = ETH_DECIMALS,
+            address = null,
+            coinGeckoId = ETH_COINGECKO_ID,
+            logoURI = null,
+            isPoints = false,
+        )
+    }
+}
--- a/data/staking/src/main/java/com/tangem/data/staking/di/YieldBalanceSupplierModule.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/di/YieldBalanceSupplierModule.kt
@ -1,15 +1,20 @@
 package com.tangem.data.staking.di

 import androidx.datastore.core.DataStore
+import com.tangem.data.staking.store.DefaultP2PBalancesStore
 import com.tangem.data.staking.store.DefaultYieldsBalancesStore
+import com.tangem.data.staking.store.P2PBalancesStore
 import com.tangem.data.staking.store.YieldsBalancesStore
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
 import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
 import com.tangem.datasource.local.datastore.RuntimeSharedStore
+import com.tangem.datasource.local.token.P2PEthPoolVaultsStore
 import com.tangem.domain.staking.multi.MultiYieldBalanceProducer
 import com.tangem.domain.staking.multi.MultiYieldBalanceSupplier
 import com.tangem.domain.staking.single.SingleYieldBalanceProducer
 import com.tangem.domain.staking.single.SingleYieldBalanceSupplier
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.coroutines.runSuspendCatching
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@ -33,6 +38,21 @@ internal object YieldBalanceSupplierModule {
        )
    }

+    @Provides
+    @Singleton
+    fun provideP2PBalancesStore(
+        persistenceStore: DataStore<Map<String, Set<P2PEthPoolAccountResponse>>>,
+        p2pVaultsStore: P2PEthPoolVaultsStore,
+        dispatchers: CoroutineDispatcherProvider,
+    ): P2PBalancesStore {
+        return DefaultP2PBalancesStore(
+            runtimeStore = RuntimeSharedStore(),
+            persistenceStore = persistenceStore,
+            vaultsProvider = { runSuspendCatching { p2pVaultsStore.getSync() }.getOrNull().orEmpty() },
+            dispatchers = dispatchers,
+        )
+    }
+
    @Provides
    @Singleton
    fun provideSingleYieldBalanceSupplier(factory: SingleYieldBalanceProducer.Factory): SingleYieldBalanceSupplier {
--- a/data/staking/src/main/java/com/tangem/data/staking/multi/DefaultMultiYieldBalanceFetcher.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/multi/DefaultMultiYieldBalanceFetcher.kt
@ -5,12 +5,17 @@ import arrow.core.left
 import arrow.core.right
 import arrow.core.toOption
 import com.tangem.data.common.api.safeApiCall
+import com.tangem.data.staking.store.P2PBalancesStore
 import com.tangem.data.staking.store.YieldsBalancesStore
 import com.tangem.data.staking.utils.YieldBalanceRequestBodyFactory
+import com.tangem.datasource.api.common.response.ApiResponse
+import com.tangem.datasource.api.ethpool.P2PEthPoolApi
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
 import com.tangem.datasource.api.stakekit.StakeKitApi
 import com.tangem.datasource.api.stakekit.models.request.YieldBalanceRequestBody
 import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
 import com.tangem.datasource.api.stakekit.models.response.model.YieldDTO
+import com.tangem.datasource.local.token.P2PEthPoolVaultsStore
 import com.tangem.datasource.local.token.StakingYieldsStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.core.utils.catchOn
@ -18,30 +23,43 @@ import com.tangem.domain.models.staking.StakingID
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.models.wallet.isMultiCurrency
+import com.tangem.domain.staking.model.StakingIntegrationID
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolNetwork
 import com.tangem.domain.staking.multi.MultiYieldBalanceFetcher
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.coroutines.runSuspendCatching
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject

 /**
 * Default implementation of [MultiYieldBalanceFetcher]
 *
- * @property userWalletsStore    user wallets store
- * @property stakingYieldsStore  staking yields store
- * @property yieldsBalancesStore yields balances store
- * @property stakeKitApi         stake kit API
- * @property dispatchers         dispatchers
+ * Supports both StakeKit and P2P staking providers.
+ *
+ * @property userWalletsStore      user wallets store
+ * @property stakingYieldsStore    staking yields store
+ * @property yieldsBalancesStore   yields balances store (StakeKit)
+ * @property p2pBalancesStore      P2P balances store
+ * @property stakeKitApi           stake kit API
+ * @property p2pApi                P2P ETH Pool API
+ * @property p2pVaultsStore        P2P vaults store
+ * @property dispatchers           dispatchers
 *
 [REDACTED_AUTHOR]
 */
+@Suppress("LongParameterList")
 internal class DefaultMultiYieldBalanceFetcher @Inject constructor(
    private val userWalletsStore: UserWalletsStore,
    private val stakingYieldsStore: StakingYieldsStore,
    private val yieldsBalancesStore: YieldsBalancesStore,
+    private val p2pBalancesStore: P2PBalancesStore,
    private val stakeKitApi: StakeKitApi,
+    private val p2pApi: P2PEthPoolApi,
+    private val p2pVaultsStore: P2PEthPoolVaultsStore,
    private val dispatchers: CoroutineDispatcherProvider,
 ) : MultiYieldBalanceFetcher {

@ -57,25 +75,150 @@ internal class DefaultMultiYieldBalanceFetcher @Inject constructor(
            return it.left()
        }

-        Timber.i("Staking IDs to fetch:\n${stakingIds.joinToString("\n")}")
+        val (stakeKitIds, p2pIds) = stakingIds.partition { stakingId ->
+            val stakingIntegrationID = StakingIntegrationID.entries.find {
+                it.value == stakingId.integrationId
+            }
+            stakingIntegrationID is StakingIntegrationID.StakeKit
+        }
+
+        Timber.i(
+            """
+                Staking IDs to fetch:
+                 - StakeKit: ${stakeKitIds.joinToString()}
+                 - P2P: ${p2pIds.joinToString()}
+            """.trimIndent(),
+        )

        return Either.catchOn(dispatchers.default) {
-            yieldsBalancesStore.refresh(userWalletId = params.userWalletId, stakingIds = stakingIds)
+            coroutineScope {
+                if (stakeKitIds.isNotEmpty()) {
+                    launch { fetchStakeKitBalances(params.userWalletId, stakeKitIds.toSet()) }
+                }

-            val availableStakingIds = getAvailableStakingIds(
-                userWalletId = params.userWalletId,
-                stakingIds = stakingIds,
-            )
-
-            fetch(userWalletId = params.userWalletId, stakingIds = availableStakingIds)
+                if (p2pIds.isNotEmpty()) {
+                    launch { fetchP2PBalances(params.userWalletId, p2pIds.toSet()) }
+                }
+            }
        }
            .onLeft { throwable ->
                Timber.e(throwable, "Unable to fetch yield balances $params")

-                yieldsBalancesStore.storeError(userWalletId = params.userWalletId, stakingIds = stakingIds)
+                if (stakeKitIds.isNotEmpty()) {
+                    yieldsBalancesStore.storeError(userWalletId = params.userWalletId, stakingIds = stakeKitIds.toSet())
+                }
+                if (p2pIds.isNotEmpty()) {
+                    p2pBalancesStore.storeError(userWalletId = params.userWalletId, stakingIds = p2pIds.toSet())
+                }
            }
    }

+    private suspend fun fetchStakeKitBalances(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        yieldsBalancesStore.refresh(userWalletId = userWalletId, stakingIds = stakingIds)
+
+        val availableStakingIds = getAvailableStakingIds(
+            userWalletId = userWalletId,
+            stakingIds = stakingIds,
+        )
+
+        fetchFromStakeKit(userWalletId = userWalletId, stakingIds = availableStakingIds)
+    }
+
+    private suspend fun fetchP2PBalances(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        p2pBalancesStore.refresh(userWalletId = userWalletId, stakingIds = stakingIds)
+
+        val vaults = runSuspendCatching { p2pVaultsStore.getSync() }.getOrNull().orEmpty()
+        if (vaults.isEmpty()) {
+            Timber.w("No P2P vaults available for $userWalletId")
+            p2pBalancesStore.storeError(userWalletId = userWalletId, stakingIds = stakingIds)
+            return
+        }
+
+        fetchFromP2P(userWalletId = userWalletId, stakingIds = stakingIds, vaults = vaults)
+    }
+
+    private suspend fun fetchFromP2P(
+        userWalletId: UserWalletId,
+        stakingIds: Set<StakingID>,
+        vaults: List<com.tangem.domain.staking.model.ethpool.P2PEthPoolVault>,
+    ) {
+        safeApiCall(
+            call = {
+                val addresses = stakingIds.map { it.address }.toSet()
+
+                val responses = mutableSetOf<P2PEthPoolAccountResponse>()
+
+                for (vault in vaults) {
+                    for (address in addresses) {
+                        runSuspendCatching {
+                            val response = p2pApi.getAccountInfo(
+                                network = P2PEthPoolNetwork.MAINNET.value,
+                                delegatorAddress = address,
+                                vaultAddress = vault.vaultAddress,
+                            )
+
+                            when (response) {
+                                is ApiResponse.Success -> {
+                                    val data = response.data
+                                    if (data.error != null) {
+                                        Timber.w(
+                                            "P2P API returned error for vault ${vault.vaultAddress}, " +
+                                                "address $address: ${data.error ?: "error"}",
+                                        )
+                                    } else {
+                                        val result = requireNotNull(data.result) {
+                                            "Result is null in successful response"
+                                        }
+                                        responses.add(result)
+                                    }
+                                }
+                                is ApiResponse.Error -> {
+                                    Timber.w(
+                                        response.cause,
+                                        "Failed to fetch P2P balance for vault ${vault.vaultAddress}, " +
+                                            "address $address",
+                                    )
+                                }
+                            }
+                        }.onFailure { error ->
+                            Timber.w(
+                                error,
+                                "Failed to fetch P2P balance for vault ${vault.vaultAddress}, address $address",
+                            )
+                        }
+                    }
+                }
+
+                Timber.i("Successfully fetched ${responses.size} P2P balances for $userWalletId")
+
+                if (responses.isNotEmpty()) {
+                    p2pBalancesStore.storeActual(userWalletId = userWalletId, values = responses)
+
+                    val missingStakingIds = stakingIds.filter { stakingId ->
+                        responses.none { response ->
+                            response.delegatorAddress.equals(stakingId.address, ignoreCase = true)
+                        }
+                    }
+
+                    if (missingStakingIds.isNotEmpty()) {
+                        Timber.i("Missing responses for ${missingStakingIds.size} staking IDs: $missingStakingIds")
+                        p2pBalancesStore.storeError(userWalletId = userWalletId, stakingIds = missingStakingIds.toSet())
+                    }
+                } else {
+                    Timber.i("No P2P responses received for $userWalletId")
+                    p2pBalancesStore.storeError(userWalletId = userWalletId, stakingIds = stakingIds)
+                }
+            },
+            onError = { throwable ->
+                Timber.e(throwable, "Unable to fetch P2P balances $userWalletId")
+
+                p2pBalancesStore.storeError(userWalletId = userWalletId, stakingIds = stakingIds)
+
+                throw throwable
+            },
+        )
+    }
+
    private inline fun checkIsSupportedByWalletOrElse(userWalletId: UserWalletId, ifNotSupported: (Throwable) -> Unit) {
        val maybeUserWallet = userWalletsStore.getSyncOrNull(key = userWalletId).toOption()

@ -139,7 +282,7 @@ internal class DefaultMultiYieldBalanceFetcher @Inject constructor(
        return yieldsIds
    }

-    private suspend fun fetch(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+    private suspend fun fetchFromStakeKit(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
        safeApiCall(
            call = {
                val requests = stakingIds.map(YieldBalanceRequestBodyFactory::create)
--- a/data/staking/src/main/java/com/tangem/data/staking/multi/DefaultMultiYieldBalanceProducer.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/multi/DefaultMultiYieldBalanceProducer.kt
@ -2,6 +2,7 @@ package com.tangem.data.staking.multi

 import arrow.core.Option
 import arrow.core.some
+import com.tangem.data.staking.store.P2PBalancesStore
 import com.tangem.data.staking.store.YieldsBalancesStore
 import com.tangem.domain.models.staking.YieldBalance
 import com.tangem.domain.staking.multi.MultiYieldBalanceProducer
@ -10,6 +11,7 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.onEmpty
@ -17,8 +19,11 @@ import kotlinx.coroutines.flow.onEmpty
 /**
 * Default implementation of [MultiYieldBalanceProducer]
 *
+ * Combines yield balances from both StakeKit and P2P providers.
+ *
 * @property params params
- * @property yieldsBalancesStore yields balances store
+ * @property yieldsBalancesStore StakeKit yields balances store
+ * @property p2pBalancesStore P2P balances store
 * @property dispatchers dispatchers
 *
 [REDACTED_AUTHOR]
@ -26,13 +31,19 @@ import kotlinx.coroutines.flow.onEmpty
 internal class DefaultMultiYieldBalanceProducer @AssistedInject constructor(
    @Assisted val params: MultiYieldBalanceProducer.Params,
    private val yieldsBalancesStore: YieldsBalancesStore,
+    private val p2pBalancesStore: P2PBalancesStore,
    private val dispatchers: CoroutineDispatcherProvider,
 ) : MultiYieldBalanceProducer {

    override val fallback: Option<Set<YieldBalance>> = emptySet<YieldBalance>().some()

    override fun produce(): Flow<Set<YieldBalance>> {
-        return yieldsBalancesStore.get(userWalletId = params.userWalletId)
+        val stakeKitFlow = yieldsBalancesStore.get(userWalletId = params.userWalletId)
+        val p2pFlow = p2pBalancesStore.get(userWalletId = params.userWalletId)
+
+        return combine(stakeKitFlow, p2pFlow) { stakeKitBalances, p2pBalances ->
+            stakeKitBalances + p2pBalances
+        }
            .distinctUntilChanged()
            .onEmpty { emit(value = hashSetOf()) }
            .flowOn(dispatchers.default)
--- a/data/staking/src/main/java/com/tangem/data/staking/store/DefaultP2PBalancesStore.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/store/DefaultP2PBalancesStore.kt
@ -0,0 +1,213 @@
+package com.tangem.data.staking.store
+
+import androidx.datastore.core.DataStore
+import com.tangem.data.staking.converters.ethpool.P2PEthPoolAccountConverter
+import com.tangem.data.staking.converters.ethpool.P2PYieldBalanceConverter
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
+import com.tangem.datasource.local.datastore.RuntimeSharedStore
+import com.tangem.domain.models.StatusSource
+import com.tangem.domain.models.staking.StakingID
+import com.tangem.domain.models.staking.YieldBalance
+import com.tangem.domain.models.wallet.UserWalletId
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolVault
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.extensions.addOrReplace
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+internal typealias WalletIdWithP2PBalances = Map<UserWalletId, Set<YieldBalance>>
+internal typealias WalletIdWithP2PResponses = Map<String, Set<P2PEthPoolAccountResponse>>
+
+/**
+ * Default implementation of [P2PBalancesStore]
+ *
+ * Stores P2P ETH Pool staking balances with persistence support.
+ *
+ * @property runtimeStore runtime store
+ * @property persistenceStore persistence store
+ * @property vaultsProvider provider for vaults
+ * @param dispatchers coroutine dispatchers
+ */
+internal class DefaultP2PBalancesStore(
+    private val runtimeStore: RuntimeSharedStore<WalletIdWithP2PBalances>,
+    private val persistenceStore: DataStore<WalletIdWithP2PResponses>,
+    private val vaultsProvider: suspend () -> List<P2PEthPoolVault>,
+    dispatchers: CoroutineDispatcherProvider,
+) : P2PBalancesStore {
+
+    private val scope = CoroutineScope(context = SupervisorJob() + dispatchers.io)
+
+    init {
+        scope.launch {
+            val cachedData = persistenceStore.data.firstOrNull() ?: return@launch
+            val vaults = vaultsProvider()
+
+            runtimeStore.store(
+                value = cachedData.map { (stringWalletId, responses) ->
+                    val key = UserWalletId(stringWalletId)
+                    val value = responses.mapNotNull { response ->
+                        val vault = vaults.firstOrNull { it.vaultAddress == response.vaultAddress }
+                            ?: return@mapNotNull null
+                        val account = P2PEthPoolAccountConverter.convert(response)
+                        P2PYieldBalanceConverter.convert(
+                            account = account,
+                            vault = vault,
+                            address = account.delegatorAddress,
+                            source = StatusSource.CACHE,
+                        )
+                    }.toSet()
+
+                    key to value
+                }.toMap(),
+            )
+        }
+    }
+
+    override fun get(userWalletId: UserWalletId): Flow<Set<YieldBalance>> {
+        return runtimeStore.get().map { it[userWalletId].orEmpty() }
+    }
+
+    override suspend fun getSyncOrNull(userWalletId: UserWalletId, stakingId: StakingID): YieldBalance? {
+        return runtimeStore.getSyncOrNull()
+            ?.get(userWalletId)
+            ?.firstOrNull { it.stakingId == stakingId }
+    }
+
+    override suspend fun getAllSyncOrNull(userWalletId: UserWalletId): Set<YieldBalance>? {
+        return runtimeStore.getSyncOrNull()?.get(userWalletId)
+    }
+
+    override suspend fun refresh(userWalletId: UserWalletId, stakingId: StakingID) {
+        refresh(userWalletId = userWalletId, stakingIds = setOf(stakingId))
+    }
+
+    override suspend fun refresh(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        updateInRuntime(userWalletId = userWalletId, stakingIds = stakingIds) {
+            it.copySealed(source = StatusSource.CACHE)
+        }
+    }
+
+    override suspend fun storeActual(userWalletId: UserWalletId, values: Set<P2PEthPoolAccountResponse>) {
+        coroutineScope {
+            launch { storeInRuntime(userWalletId = userWalletId, values = values) }
+            launch { storeInPersistence(userWalletId = userWalletId, values = values) }
+        }
+    }
+
+    override suspend fun storeError(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        updateInRuntime(
+            userWalletId = userWalletId,
+            stakingIds = stakingIds,
+            ifNotFound = ::createErrorYieldBalance,
+            update = { it.copySealed(source = StatusSource.ONLY_CACHE) },
+        )
+    }
+
+    override suspend fun clear(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        coroutineScope {
+            launch { clearInRuntime(userWalletId = userWalletId, stakingIds = stakingIds) }
+            launch { clearInPersistence(userWalletId = userWalletId, stakingIds = stakingIds) }
+        }
+    }
+
+    private suspend fun storeInRuntime(userWalletId: UserWalletId, values: Set<P2PEthPoolAccountResponse>) {
+        val vaults = vaultsProvider()
+
+        val newBalances = values.mapNotNull { response ->
+            val vault = vaults.firstOrNull { it.vaultAddress == response.vaultAddress }
+            if (vault == null) {
+                Timber.w("Vault not found for ${response.vaultAddress}")
+                return@mapNotNull null
+            }
+
+            val account = P2PEthPoolAccountConverter.convert(response)
+            P2PYieldBalanceConverter.convert(
+                account = account,
+                vault = vault,
+                address = account.delegatorAddress,
+                source = StatusSource.ACTUAL,
+            )
+        }.toSet()
+
+        runtimeStore.update(default = emptyMap()) { saved ->
+            saved.toMutableMap().apply {
+                this[userWalletId] = saved[userWalletId]
+                    ?.addOrReplace(newBalances) { old, new -> old.stakingId == new.stakingId }
+                    ?: newBalances
+            }
+        }
+    }
+
+    private suspend fun storeInPersistence(userWalletId: UserWalletId, values: Set<P2PEthPoolAccountResponse>) {
+        persistenceStore.updateData { current ->
+            current.toMutableMap().apply {
+                this[userWalletId.stringValue] = this[userWalletId.stringValue]
+                    ?.addOrReplace(values) { old, new ->
+                        old.delegatorAddress == new.delegatorAddress && old.vaultAddress == new.vaultAddress
+                    }
+                    ?: values
+            }
+        }
+    }
+
+    private suspend fun clearInRuntime(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        runtimeStore.update(default = emptyMap()) { stored ->
+            stored.toMutableMap().apply {
+                this[userWalletId] = this[userWalletId].orEmpty()
+                    .filterNot { it.stakingId in stakingIds }
+                    .toSet()
+            }
+        }
+    }
+
+    private suspend fun clearInPersistence(userWalletId: UserWalletId, stakingIds: Set<StakingID>) {
+        val integrationIds = stakingIds.map { it.integrationId }.toSet()
+
+        persistenceStore.updateData { current ->
+            current.toMutableMap().apply {
+                this[userWalletId.stringValue] = this[userWalletId.stringValue].orEmpty()
+                    .filterNot { response ->
+                        val responseIntegrationId = "p2p-ethereum-pooled:${response.vaultAddress}"
+                        responseIntegrationId in integrationIds
+                    }
+                    .toSet()
+            }
+        }
+    }
+
+    private suspend fun updateInRuntime(
+        userWalletId: UserWalletId,
+        stakingIds: Set<StakingID>,
+        ifNotFound: (StakingID) -> YieldBalance? = { null },
+        update: (YieldBalance) -> YieldBalance,
+    ) {
+        runtimeStore.update(default = emptyMap()) { stored ->
+            stored.toMutableMap().apply {
+                val portfolioBalances = stored[userWalletId].orEmpty()
+
+                val balances = stakingIds.mapNotNullTo(hashSetOf()) { stakingId ->
+                    val balance = portfolioBalances
+                        .firstOrNull { it.stakingId == stakingId }
+                        ?: ifNotFound(stakingId)
+                        ?: return@mapNotNullTo null
+
+                    update(balance)
+                }
+
+                val updatedBalances = portfolioBalances.addOrReplace(items = balances) { old, new ->
+                    old.stakingId == new.stakingId
+                }
+
+                put(key = userWalletId, value = updatedBalances)
+            }
+        }
+    }
+
+    private fun createErrorYieldBalance(id: StakingID): YieldBalance = YieldBalance.Error(stakingId = id)
+}
--- a/data/staking/src/main/java/com/tangem/data/staking/store/P2PBalancesStore.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/store/P2PBalancesStore.kt
@ -0,0 +1,29 @@
+package com.tangem.data.staking.store
+
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
+import com.tangem.domain.models.staking.StakingID
+import com.tangem.domain.models.staking.YieldBalance
+import com.tangem.domain.models.wallet.UserWalletId
+import kotlinx.coroutines.flow.Flow
+
+/**
+ * Store for P2P ETH Pool staking balances
+ */
+interface P2PBalancesStore {
+
+    fun get(userWalletId: UserWalletId): Flow<Set<YieldBalance>>
+
+    suspend fun getSyncOrNull(userWalletId: UserWalletId, stakingId: StakingID): YieldBalance?
+
+    suspend fun getAllSyncOrNull(userWalletId: UserWalletId): Set<YieldBalance>?
+
+    suspend fun refresh(userWalletId: UserWalletId, stakingId: StakingID)
+
+    suspend fun refresh(userWalletId: UserWalletId, stakingIds: Set<StakingID>)
+
+    suspend fun storeActual(userWalletId: UserWalletId, values: Set<P2PEthPoolAccountResponse>)
+
+    suspend fun storeError(userWalletId: UserWalletId, stakingIds: Set<StakingID>)
+
+    suspend fun clear(userWalletId: UserWalletId, stakingIds: Set<StakingID>)
+}
--- a/data/staking/src/test/kotlin/com/tangem/data/staking/StakingBalanceExt.kt
+++ b/data/staking/src/test/kotlin/com/tangem/data/staking/StakingBalanceExt.kt
@ -0,0 +1,28 @@
+package com.tangem.data.staking
+
+import com.tangem.common.test.data.staking.MockP2PEthPoolAccountResponseFactory
+import com.tangem.data.staking.converters.ethpool.P2PEthPoolAccountConverter
+import com.tangem.data.staking.converters.ethpool.P2PYieldBalanceConverter
+import com.tangem.datasource.api.ethpool.models.response.P2PEthPoolAccountResponse
+import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
+import com.tangem.datasource.local.token.converter.YieldBalanceConverter
+import com.tangem.domain.models.StatusSource
+import com.tangem.domain.models.staking.YieldBalance
+import com.tangem.domain.staking.model.ethpool.P2PEthPoolVault
+
+internal fun YieldBalanceWrapperDTO.toDomain(source: StatusSource = StatusSource.CACHE): YieldBalance {
+    return YieldBalanceConverter(source = source).convert(this)!!
+}
+
+internal fun P2PEthPoolAccountResponse.toDomain(
+    vault: P2PEthPoolVault = MockP2PEthPoolAccountResponseFactory.createMockVault(vaultAddress = vaultAddress),
+    source: StatusSource = StatusSource.CACHE,
+): YieldBalance {
+    val account = P2PEthPoolAccountConverter.convert(this)
+    return P2PYieldBalanceConverter.convert(
+        account = account,
+        vault = vault,
+        address = account.delegatorAddress,
+        source = source,
+    )
+}
--- a/data/staking/src/test/kotlin/com/tangem/data/staking/YieldBalanceExt.kt
+++ b/data/staking/src/test/kotlin/com/tangem/data/staking/YieldBalanceExt.kt
@ -1,10 +0,0 @@
-package com.tangem.data.staking
-
-import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
-import com.tangem.datasource.local.token.converter.YieldBalanceConverter
-import com.tangem.domain.models.StatusSource
-import com.tangem.domain.models.staking.YieldBalance
-
-internal fun YieldBalanceWrapperDTO.toDomain(source: StatusSource = StatusSource.CACHE): YieldBalance {
-    return YieldBalanceConverter(source = source).convert(this)!!
-}
--- a/data/staking/src/test/kotlin/com/tangem/data/staking/multi/DefaultMultiYieldBalanceFetcherTest.kt
+++ b/data/staking/src/test/kotlin/com/tangem/data/staking/multi/DefaultMultiYieldBalanceFetcherTest.kt
@ -4,12 +4,15 @@ import arrow.core.toOption
 import com.tangem.common.test.data.staking.MockYieldBalanceWrapperDTOFactory
 import com.tangem.common.test.data.staking.MockYieldDTOFactory
 import com.tangem.common.test.domain.wallet.MockUserWalletFactory
+import com.tangem.data.staking.store.P2PBalancesStore
 import com.tangem.data.staking.store.YieldsBalancesStore
 import com.tangem.data.staking.utils.YieldBalanceRequestBodyFactory
 import com.tangem.datasource.api.common.response.ApiResponse
 import com.tangem.datasource.api.common.response.ApiResponseError
+import com.tangem.datasource.api.ethpool.P2PEthPoolApi
 import com.tangem.datasource.api.stakekit.StakeKitApi
 import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
+import com.tangem.datasource.local.token.P2PEthPoolVaultsStore
 import com.tangem.datasource.local.token.StakingYieldsStore
 import com.tangem.datasource.local.userwallet.UserWalletsStore
 import com.tangem.domain.models.staking.StakingID
@ -33,13 +36,19 @@ internal class DefaultMultiYieldBalanceFetcherTest {
    private val userWalletsStore: UserWalletsStore = mockk()
    private val stakingYieldsStore: StakingYieldsStore = mockk()
    private val yieldsBalancesStore: YieldsBalancesStore = mockk(relaxUnitFun = true)
+    private val p2pBalancesStore: P2PBalancesStore = mockk(relaxUnitFun = true)
    private val stakeKitApi: StakeKitApi = mockk()
+    private val p2pApi: P2PEthPoolApi = mockk()
+    private val p2pVaultsStore: P2PEthPoolVaultsStore = mockk()

    private val fetcher = DefaultMultiYieldBalanceFetcher(
        userWalletsStore = userWalletsStore,
        stakingYieldsStore = stakingYieldsStore,
        yieldsBalancesStore = yieldsBalancesStore,
+        p2pBalancesStore = p2pBalancesStore,
        stakeKitApi = stakeKitApi,
+        p2pApi = p2pApi,
+        p2pVaultsStore = p2pVaultsStore,
        dispatchers = TestingCoroutineDispatcherProvider(),
    )

--- a/data/staking/src/test/kotlin/com/tangem/data/staking/multi/DefaultMultiYieldBalanceProducerTest.kt
+++ b/data/staking/src/test/kotlin/com/tangem/data/staking/multi/DefaultMultiYieldBalanceProducerTest.kt
@ -2,10 +2,12 @@ package com.tangem.data.staking.multi

 import com.google.common.truth.Truth
 import com.tangem.common.test.data.staking.MockYieldBalanceWrapperDTOFactory
+import com.tangem.common.test.data.staking.MockP2PEthPoolAccountResponseFactory
+import com.tangem.data.staking.store.P2PBalancesStore
 import com.tangem.data.staking.store.YieldsBalancesStore
 import com.tangem.data.staking.toDomain
-import com.tangem.domain.models.staking.StakingID
-import com.tangem.domain.models.staking.YieldBalance
+import com.tangem.domain.models.StatusSource
+import com.tangem.domain.models.staking.*
 import com.tangem.domain.models.wallet.UserWalletId
 import com.tangem.domain.staking.multi.MultiYieldBalanceProducer
 import com.tangem.test.core.getEmittedValues
@ -25,11 +27,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
    private val params = MultiYieldBalanceProducer.Params(userWalletId = UserWalletId("011"))

    private val yieldsBalancesStore = mockk<YieldsBalancesStore>()
+    private val p2pBalancesStore = mockk<P2PBalancesStore>()
    private val dispatchers = TestingCoroutineDispatcherProvider()

    private val producer = DefaultMultiYieldBalanceProducer(
        params = params,
        yieldsBalancesStore = yieldsBalancesStore,
+        p2pBalancesStore = p2pBalancesStore,
        dispatchers = dispatchers,
    )

@ -43,11 +47,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
        val networksStatusesFlow = flowOf(balances)

        every { yieldsBalancesStore.get(params.userWalletId) } returns networksStatusesFlow
+        every { p2pBalancesStore.get(params.userWalletId) } returns flowOf(emptySet())

        val actual = producer.produce()

        // check after producer.produce()
        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }

        val values = getEmittedValues(flow = actual)

@ -60,11 +66,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
        val networksStatusesFlow = MutableSharedFlow<Set<YieldBalance>>(replay = 2)

        every { yieldsBalancesStore.get(params.userWalletId) } returns networksStatusesFlow
+        every { p2pBalancesStore.get(params.userWalletId) } returns flowOf(emptySet())

        val actual = producer.produce()

        // check after producer.produce()
        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }

        // first emit
        val balances = setOf(
@ -99,11 +107,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
        val networksStatusesFlow = MutableSharedFlow<Set<YieldBalance>>(replay = 2)

        every { yieldsBalancesStore.get(params.userWalletId) } returns networksStatusesFlow
+        every { p2pBalancesStore.get(params.userWalletId) } returns flowOf(emptySet())

        val actual = producer.produce()

        // check after producer.produce()
        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }

        // first emit
        val wrappers = setOf(
@ -146,11 +156,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
            .buffer(capacity = 5)

        every { yieldsBalancesStore.get(params.userWalletId) } returns networksStatusesFlow
+        every { p2pBalancesStore.get(params.userWalletId) } returns flowOf(emptySet())

        val actual = producer.produceWithFallback()

        // check after producer.produce()
        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }

        val values1 = getEmittedValues(flow = actual)

@ -168,11 +180,13 @@ internal class DefaultMultiYieldBalanceProducerTest {
    @Test
    fun `test that flow is empty`() = runTest {
        every { yieldsBalancesStore.get(params.userWalletId) } returns emptyFlow()
+        every { p2pBalancesStore.get(params.userWalletId) } returns emptyFlow()

        val actual = producer.produce()

        // check after producer.produce()
        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }

        val values = getEmittedValues(flow = actual)

@ -180,6 +194,58 @@ internal class DefaultMultiYieldBalanceProducerTest {
        Truth.assertThat(values).isEqualTo(listOf(emptySet<YieldBalance>()))
    }

+    @Test
+    fun `test that StakeKit and P2P balances are combined`() = runTest {
+        val stakeKitBalances = createStakeKitBalances()
+        val p2pBalances = createP2PBalances()
+
+        every { yieldsBalancesStore.get(params.userWalletId) } returns flowOf(stakeKitBalances)
+        every { p2pBalancesStore.get(params.userWalletId) } returns flowOf(p2pBalances)
+
+        val actual = producer.produce()
+
+        // check after producer.produce()
+        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }
+
+        val values = getEmittedValues(flow = actual)
+
+        Truth.assertThat(values.size).isEqualTo(1)
+        Truth.assertThat(values.first()).isEqualTo(stakeKitBalances + p2pBalances)
+    }
+
+    @Test
+    fun `test that P2P balances are updated independently from StakeKit`() = runTest {
+        val stakeKitBalances = createStakeKitBalancesWithTonOnly()
+        val p2pFlow = MutableSharedFlow<Set<YieldBalance>>(replay = 2)
+
+        every { yieldsBalancesStore.get(params.userWalletId) } returns flowOf(stakeKitBalances)
+        every { p2pBalancesStore.get(params.userWalletId) } returns p2pFlow
+
+        val actual = producer.produce()
+
+        // check after producer.produce()
+        verify { yieldsBalancesStore.get(params.userWalletId) }
+        verify { p2pBalancesStore.get(params.userWalletId) }
+
+        // first emit - empty P2P
+        p2pFlow.emit(emptySet())
+
+        val values1 = getEmittedValues(flow = actual)
+
+        Truth.assertThat(values1.size).isEqualTo(1)
+        Truth.assertThat(values1.first()).isEqualTo(stakeKitBalances)
+
+        // second emit - with P2P balance
+        val p2pBalances = createP2PBalances()
+        p2pFlow.emit(p2pBalances)
+
+        val values2 = getEmittedValues(flow = actual)
+
+        Truth.assertThat(values2.size).isEqualTo(2)
+        Truth.assertThat(values2.last()).isEqualTo(stakeKitBalances + p2pBalances)
+    }
+
    private companion object {

        val tonId = MockYieldBalanceWrapperDTOFactory.defaultStakingId
@ -187,5 +253,30 @@ internal class DefaultMultiYieldBalanceProducerTest {
            integrationId = "solana-sol-native-multivalidator-staking",
            address = "0x1",
        )
+        val p2pEthereumId = StakingID(
+            integrationId = "p2p-ethereum-pooled",
+            address = "0x5aa711F440Eb6d4361148bBD89d03464628ace84",
+        )
+
+        fun createStakeKitBalances(): Set<YieldBalance> {
+            return setOf(
+                MockYieldBalanceWrapperDTOFactory.createWithBalance(tonId).toDomain(),
+                MockYieldBalanceWrapperDTOFactory.createWithBalance(solanaId).toDomain(),
+            )
+        }
+
+        fun createStakeKitBalancesWithTonOnly(): Set<YieldBalance> {
+            return setOf(
+                MockYieldBalanceWrapperDTOFactory.createWithBalance(tonId).toDomain(),
+            )
+        }
+
+        fun createP2PBalances(): Set<YieldBalance> {
+            return setOf(
+                MockP2PEthPoolAccountResponseFactory.createWithBalance(stakingId = p2pEthereumId).toDomain(
+                    source = StatusSource.ACTUAL,
+                ),
+            )
+        }
    }
 }
--- a/data/swap/build.gradle.kts
+++ b/data/swap/build.gradle.kts
@ -44,6 +44,7 @@ dependencies {

    /** Libs */
    implementation(projects.libs.blockchainSdk)
+    implementation(projects.libs.crypto)

    /** Other */
    implementation(deps.androidx.datastore)
--- a/data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionConverter.kt
+++ b/data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionConverter.kt
@ -1,12 +1,16 @@
 package com.tangem.data.swap.converter.transaction

+import com.tangem.blockchain.common.Blockchain
+import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.data.common.currency.ResponseCryptoCurrenciesFactory
 import com.tangem.data.swap.models.SwapStatusDTO
 import com.tangem.data.swap.models.SwapTransactionDTO
 import com.tangem.data.swap.models.SwapTxTypeDTO
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.wallet.UserWallet
 import com.tangem.domain.swap.models.SwapTransactionModel
 import com.tangem.domain.swap.models.SwapTxType
+import com.tangem.lib.crypto.derivation.AccountNodeRecognizer
 import com.tangem.utils.converter.TwoWayConverter

 internal class SavedSwapTransactionConverter(
@ -48,9 +52,23 @@ internal class SavedSwapTransactionConverter(
    ): SwapTransactionModel {
        val status = txStatuses[value.txId]
        val refundCurrency = status?.refundTokensResponse?.let { id ->
+            val blockchain = Blockchain.fromNetworkId(id.networkId) ?: return@let null
+            val derivationPath = id.derivationPath ?: return@let null
+
+            val accountIndex = if (blockchain == Blockchain.Chia) {
+                DerivationIndex.Main
+            } else {
+                val recognizer = AccountNodeRecognizer(blockchain = blockchain)
+                val index = recognizer.recognize(derivationPathValue = derivationPath)?.toInt()
+                    ?: return@let null
+
+                DerivationIndex(index).getOrNull() ?: return@let null
+            }
+
            responseCryptoCurrenciesFactory.createCurrency(
                responseToken = id,
                userWallet = userWallet,
+                accountIndex = accountIndex,
            )
        }
        val statusWithRefundCurrency = status?.copy(refundCurrency = refundCurrency)
--- a/data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionListConverter.kt
+++ b/data/swap/src/main/java/com/tangem/data/swap/converter/transaction/SavedSwapTransactionListConverter.kt
@ -72,7 +72,11 @@ internal class SavedSwapTransactionListConverter(

            return SwapTransactionListModel(
                transactions = value.transactions.map { tx ->
-                    savedSwapTransactionConverter.convertBack(tx, userWallet, txStatuses)
+                    savedSwapTransactionConverter.convertBack(
+                        value = tx,
+                        userWallet = userWallet,
+                        txStatuses = txStatuses,
+                    )
                },
                userWalletId = value.userWalletId,
                fromCryptoCurrencyId = value.fromCryptoCurrencyId,
--- a/data/tokens/detekt-baseline-debug.xml
+++ b/data/tokens/detekt-baseline-debug.xml
@ -3,11 +3,8 @@
  <ManuallySuppressedIssues/>
  <CurrentIssues>
    <ID>MultilineLambdaItParameter:CustomTokensMerger.kt$CustomTokensMerger${ Timber.e(it, "Unable to fetch token:\n$token") null }</ID>
-    <ID>MultilineLambdaItParameter:DefaultCurrenciesRepository.kt$DefaultCurrenciesRepository${ it.networkId == blockchainNetworkId &amp;&amp; compareIdWithMigrations(it, coinId) &amp;&amp; it.derivationPath == derivationPath.value }</ID>
    <ID>NullableToStringCall:AccountListCryptoCurrenciesFetcher.kt$AccountListCryptoCurrenciesFetcher$${this::class.simpleName}</ID>
    <ID>NullableToStringCall:DefaultMultiWalletCryptoCurrenciesFetcher.kt$DefaultMultiWalletCryptoCurrenciesFetcher$${this::class.simpleName}</ID>
-    <ID>SuspendFunSwallowedCancellation:DefaultCurrenciesRepository.kt$DefaultCurrenciesRepository$runCatching</ID>
-    <ID>SuspendFunWithFlowReturnType:DefaultCurrenciesRepository.kt$DefaultCurrenciesRepository$suspend</ID>
    <ID>UseOrEmpty:DefaultYieldSupplyWarningsViewedRepository.kt$DefaultYieldSupplyWarningsViewedRepository$appPreferencesStore.getObjectSet&lt;String&gt;(PreferencesKeys.YIELD_SUPPLY_WARNINGS_STATES_KEY).firstOrNull() ?: emptySet()</ID>
  </CurrentIssues>
 </SmellBaseline>
--- a/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultCurrenciesRepository.kt
+++ b/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultCurrenciesRepository.kt
@ -21,6 +21,7 @@ import com.tangem.domain.core.error.DataError
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.express.ExpressServiceFetcher
 import com.tangem.domain.express.models.ExpressAsset
+import com.tangem.domain.models.account.DerivationIndex
 import com.tangem.domain.models.currency.CryptoCurrency
 import com.tangem.domain.models.currency.CryptoCurrencyStatus
 import com.tangem.domain.models.network.Network
@ -31,6 +32,7 @@ import com.tangem.domain.tokens.model.FeePaidCurrency
 import com.tangem.domain.tokens.repository.CurrenciesRepository
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import com.tangem.utils.coroutines.runSuspendCatching
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import timber.log.Timber
@ -301,8 +303,9 @@ internal class DefaultCurrenciesRepository(
        )

        responseCryptoCurrenciesFactory.createCurrencies(
-            storedTokens,
+            response = storedTokens,
            userWallet = userWallet,
+            accountIndex = DerivationIndex.Main,
        )
    }

@ -357,15 +360,16 @@ internal class DefaultCurrenciesRepository(
            val coinId = blockchain.toCoinId()

            val storedCoin = storedTokens.tokens
-                .find {
-                    it.networkId == blockchainNetworkId &&
-                        compareIdWithMigrations(it, coinId) &&
-                        it.derivationPath == derivationPath.value
+                .find { token ->
+                    token.networkId == blockchainNetworkId &&
+                        compareIdWithMigrations(token, coinId) &&
+                        token.derivationPath == derivationPath.value
                } ?: error("Coin in this network $networkId not found")

            val coin = responseCryptoCurrenciesFactory.createCurrency(
                responseToken = storedCoin,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )

            coin as? CryptoCurrency.Coin ?: error("Unable to create currency")
@ -525,6 +529,7 @@ internal class DefaultCurrenciesRepository(
        }
    }

+    @Suppress("SuspendFunWithFlowReturnType")
    private suspend fun getCurrenciesForWallet(
        userWallet: UserWallet,
        currencyRawId: CryptoCurrency.RawID,
@ -539,6 +544,7 @@ internal class DefaultCurrenciesRepository(
                    responseCryptoCurrenciesFactory.createCurrencies(
                        response = storedTokens.copy(tokens = filterResponse),
                        userWallet = userWallet,
+                        accountIndex = DerivationIndex.Main,
                    )
                }
            }
@ -570,7 +576,7 @@ internal class DefaultCurrenciesRepository(
    }

    override suspend fun syncTokens(userWalletId: UserWalletId) {
-        runCatching {
+        runSuspendCatching {
            val savedCurrencies = requireNotNull(
                value = getSavedUserTokensResponseSync(key = userWalletId),
                lazyMessage = { "Saved tokens empty. Can not perform add currencies action" },
@ -591,6 +597,7 @@ internal class DefaultCurrenciesRepository(
            responseCryptoCurrenciesFactory.createCurrencies(
                response = storedTokens,
                userWallet = userWallet,
+                accountIndex = DerivationIndex.Main,
            )
        }
    }
--- a/data/transaction/detekt-baseline-debug.xml
+++ b/data/transaction/detekt-baseline-debug.xml
@ -1,11 +0,0 @@
-<?xml version="1.0" ?>
-<SmellBaseline>
-  <ManuallySuppressedIssues/>
-  <CurrentIssues>
-    <ID>CastNullableToNonNullableType:DefaultTransactionRepository.kt$DefaultTransactionRepository$as</ID>
-    <ID>NoNameShadowing:DefaultTransactionRepository.kt$DefaultTransactionRepository$amount</ID>
-    <ID>NoNameShadowing:DefaultTransactionRepository.kt$DefaultTransactionRepository$destination</ID>
-    <ID>NullableBooleanCheck:DefaultWalletAddressServiceRepository.kt$DefaultWalletAddressServiceRepository$(walletManager as? NearWalletManager)?.validateAddress(address) ?: false</ID>
-    <ID>NullableToStringCall:DefaultTransactionRepository.kt$DefaultTransactionRepository$${walletManager?.wallet?.blockchain}</ID>
-  </CurrentIssues>
-</SmellBaseline>
--- a/data/transaction/src/main/java/com/tangem/data/transaction/DefaultTransactionRepository.kt
+++ b/data/transaction/src/main/java/com/tangem/data/transaction/DefaultTransactionRepository.kt
@ -38,7 +38,7 @@ import timber.log.Timber
 import java.math.BigDecimal
 import java.math.BigInteger

-@Suppress("LargeClass")
+@Suppress("LargeClass", "NullableToStringCall")
 internal class DefaultTransactionRepository(
    private val tangemTechApi: TangemTechApi,
    private val walletManagersFacade: WalletManagersFacade,
@ -64,12 +64,12 @@ internal class DefaultTransactionRepository(

        val extras = txExtras ?: getMemoExtras(networkId = network.rawId, memo)

-        val destination = if (amount.type is AmountType.TokenYieldSupply) {
+        val patchedDestination = if (amount.type is AmountType.TokenYieldSupply) {
            walletManager.getYieldModuleAddress()
        } else {
            destination
        }
-        val amount = if (amount.type is AmountType.TokenYieldSupply) {
+        val patchedAmount = if (amount.type is AmountType.TokenYieldSupply) {
            amount.copy(value = BigDecimal.ZERO)
        } else {
            amount
@ -77,17 +77,17 @@ internal class DefaultTransactionRepository(

        return@withContext if (fee != null) {
            walletManager.createTransaction(
-                amount = amount,
+                amount = patchedAmount,
                fee = fee,
-                destination = destination,
+                destination = patchedDestination,
            ).copy(
                extras = extras,
            )
        } else {
            TransactionData.Uncompiled(
-                amount = amount,
+                amount = patchedAmount,
                sourceAddress = walletManager.wallet.address,
-                destinationAddress = destination,
+                destinationAddress = patchedDestination,
                extras = extras,
                fee = null,
            )
@ -288,7 +288,7 @@ internal class DefaultTransactionRepository(
            blockchain = blockchain,
            derivationPath = network.derivationPath.value,
        )
-        (walletManager as TransactionSender).send(txData, signer)
+        (requireNotNull(walletManager) as TransactionSender).send(txData, signer)
    }

    override suspend fun sendMultipleTransactions(
@ -304,7 +304,7 @@ internal class DefaultTransactionRepository(
            blockchain = blockchain,
            derivationPath = network.derivationPath.value,
        )
-        (walletManager as TransactionSender).sendMultiple(txsData, signer, sendMode)
+        (requireNotNull(walletManager) as TransactionSender).sendMultiple(txsData, signer, sendMode)
    }

    override fun createTransactionDataExtras(
--- a/data/transaction/src/main/java/com/tangem/data/transaction/DefaultWalletAddressServiceRepository.kt
+++ b/data/transaction/src/main/java/com/tangem/data/transaction/DefaultWalletAddressServiceRepository.kt
@ -89,7 +89,7 @@ class DefaultWalletAddressServiceRepository(
                    blockchain = blockchain,
                    derivationPath = network.derivationPath.value,
                ) ?: return@withContext false
-                (walletManager as? NearWalletManager)?.validateAddress(address) ?: false
+                (walletManager as? NearWalletManager)?.validateAddress(address) == true
            } else {
                blockchain.validateAddress(address)
            }
--- a/data/visa/detekt-baseline-debug.xml
+++ b/data/visa/detekt-baseline-debug.xml
@ -17,7 +17,6 @@
    <ID>NullableToStringCall:TangemPayRequestPerformer.kt$TangemPayRequestPerformer$${error.message}</ID>
    <ID>RedundantSuspendModifier:DefaultVisaRepository.kt$DefaultVisaRepository$suspend</ID>
    <ID>SuspendFunSwallowedCancellation:DefaultVisaRepository.kt$DefaultVisaRepository$runCatching</ID>
-    <ID>SuspendFunSwallowedCancellation:TangemPayRequestPerformer.kt$TangemPayRequestPerformer$runCatching</ID>
    <ID>SuspendFunSwallowedCancellation:VisaApiRequestMaker.kt$VisaApiRequestMaker$runCatching</ID>
    <ID>UnreachableCode:VisaApiRequestMaker.kt$VisaApiRequestMaker$if (status is VisaCardActivationStatus.RefreshTokenExpired) { throw RefreshTokenExpiredException() }</ID>
    <ID>UnreachableCode:VisaApiRequestMaker.kt$VisaApiRequestMaker$return (status as? VisaCardActivationStatus.Activated)?.visaAuthTokens ?: error("Visa card is not activated")</ID>
--- a/data/visa/src/main/kotlin/com/tangem/data/pay/repository/DefaultTangemPayCardDetailsRepository.kt
+++ b/data/visa/src/main/kotlin/com/tangem/data/pay/repository/DefaultTangemPayCardDetailsRepository.kt
@ -271,6 +271,7 @@ internal class DefaultTangemPayCardDetailsRepository @Inject constructor(
            ApiEnvironment.DEV_2,
            ApiEnvironment.DEV_3,
            ApiEnvironment.STAGE,
+            ApiEnvironment.STAGE_2,
            ApiEnvironment.MOCK,
            -> visaLibLoader.getOrCreateConfig().rainRSAPublicKey.dev
            ApiEnvironment.PROD -> visaLibLoader.getOrCreateConfig().rainRSAPublicKey.prod
--- a/data/visa/src/main/kotlin/com/tangem/data/visa/DefaultVisaActivationRepository.kt
+++ b/data/visa/src/main/kotlin/com/tangem/data/visa/DefaultVisaActivationRepository.kt
@ -171,6 +171,7 @@ internal class DefaultVisaActivationRepository @AssistedInject constructor(
            ApiEnvironment.DEV_2,
            ApiEnvironment.DEV_3,
            ApiEnvironment.STAGE,
+            ApiEnvironment.STAGE_2,
            ApiEnvironment.MOCK,
            -> rsaPublicKey.dev
            ApiEnvironment.PROD -> rsaPublicKey.prod
--- a/data/wallet-manager/detekt-baseline-debug.xml
+++ b/data/wallet-manager/detekt-baseline-debug.xml
@ -2,10 +2,7 @@
 <SmellBaseline>
  <ManuallySuppressedIssues/>
  <CurrentIssues>
-    <ID>MultilineLambdaItParameter:DefaultWalletManagersFacade.kt$DefaultWalletManagersFacade${ Token( name = it.name, symbol = it.symbol, contractAddress = it.contractAddress, decimals = it.decimals, id = it.id, ) }</ID>
    <ID>MultilineLambdaItParameter:UpdateWalletManagerResultFactory.kt$UpdateWalletManagerResultFactory${ createCurrencyTransaction( txHistoryItemConverter = txHistoryItemConverter, data = it, ) }</ID>
-    <ID>NamedArguments:DefaultWalletManagersFacade.kt$DefaultWalletManagersFacade$getAndUpdateWalletManager(userWallet, blockchain, derivationPath, extraTokens)</ID>
-    <ID>UnnecessaryLet:DefaultWalletManagersFacade.kt$DefaultWalletManagersFacade$let(txHistoryStateConverter::convert)</ID>
    <ID>UnsafeCallOnNullableType:WalletManagerFactory.kt$blockchain.getTestnetVersion()!!</ID>
    <ID>UnsafeCallOnNullableType:WalletManagerFactory.kt$scanResponse.secondTwinPublicKey!!</ID>
  </CurrentIssues>
--- a/data/wallet-manager/src/main/java/com/tangem/data/walletmanager/DefaultWalletManagersFacade.kt
+++ b/data/wallet-manager/src/main/java/com/tangem/data/walletmanager/DefaultWalletManagersFacade.kt
@ -85,7 +85,12 @@ internal class DefaultWalletManagersFacade @Inject constructor(
        val blockchain = network.toBlockchain()
        val derivationPath = network.derivationPath.value

-        return getAndUpdateWalletManager(userWallet, blockchain, derivationPath, extraTokens)
+        return getAndUpdateWalletManager(
+            userWallet = userWallet,
+            blockchain = blockchain,
+            derivationPath = derivationPath,
+            extraTokens = extraTokens,
+        )
    }

    override suspend fun remove(userWalletId: UserWalletId, networks: Set<Network>) {
@ -123,18 +128,18 @@ internal class DefaultWalletManagersFacade @Inject constructor(
        if (tokenInfos.isEmpty()) return

        tokenInfos
-            .groupBy { it.network }
+            .groupBy(TokenInfo::network)
            .forEach { (network, tokenInfoList) ->
                removeTokens(
                    userWalletId = userWalletId,
                    network = network,
-                    networkTokens = tokenInfoList.map {
+                    networkTokens = tokenInfoList.map { tokenInfo ->
                        Token(
-                            name = it.name,
-                            symbol = it.symbol,
-                            contractAddress = it.contractAddress,
-                            decimals = it.decimals,
-                            id = it.id,
+                            name = tokenInfo.name,
+                            symbol = tokenInfo.symbol,
+                            contractAddress = tokenInfo.contractAddress,
+                            decimals = tokenInfo.decimals,
+                            id = tokenInfo.id,
                        )
                    },
                )
@ -215,24 +220,24 @@ internal class DefaultWalletManagersFacade @Inject constructor(
            "Unable to get a wallet manager for blockchain: ${currency.network}"
        }

-        return walletManager
-            .getTransactionHistoryState(
-                address = walletManager.wallet.address,
-                filterType = when (currency) {
-                    is CryptoCurrency.Coin -> TransactionHistoryRequest.FilterType.Coin
-                    is CryptoCurrency.Token -> {
-                        val blockchainToken = Token(
-                            name = currency.name,
-                            symbol = currency.symbol,
-                            contractAddress = currency.contractAddress,
-                            decimals = currency.decimals,
-                            id = currency.id.rawCurrencyId?.value,
-                        )
-                        TransactionHistoryRequest.FilterType.Contract(blockchainToken)
-                    }
-                },
-            )
-            .let(txHistoryStateConverter::convert)
+        val transactionHistoryState = walletManager.getTransactionHistoryState(
+            address = walletManager.wallet.address,
+            filterType = when (currency) {
+                is CryptoCurrency.Coin -> TransactionHistoryRequest.FilterType.Coin
+                is CryptoCurrency.Token -> {
+                    val blockchainToken = Token(
+                        name = currency.name,
+                        symbol = currency.symbol,
+                        contractAddress = currency.contractAddress,
+                        decimals = currency.decimals,
+                        id = currency.id.rawCurrencyId?.value,
+                    )
+                    TransactionHistoryRequest.FilterType.Contract(blockchainToken)
+                }
+            },
+        )
+
+        return txHistoryStateConverter.convert(transactionHistoryState)
    }

    override suspend fun getTxHistoryItems(
@ -366,7 +371,7 @@ internal class DefaultWalletManagersFacade @Inject constructor(
        blockchain: Blockchain,
        derivationPath: String?,
    ): WalletManager? {
-        getWmInitializationMutex(blockchain, derivationPath).withLock {
+        getWmInitializationMutex(userWalletId, blockchain, derivationPath).withLock {
            val userWallet = getUserWallet(userWalletId)

            var walletManager = walletManagersStore.getSyncOrNull(
@ -738,15 +743,24 @@ internal class DefaultWalletManagersFacade @Inject constructor(
        return initializableAccountWalletManger.accountInitializationState == InitializableAccount.State.INITIALIZED
    }

-    private fun getWmInitializationMutex(blockchain: Blockchain, derivationPath: String?): Mutex {
-        val key = createMutexMapKey(blockchain, derivationPath)
+    private fun getWmInitializationMutex(
+        userWalletId: UserWalletId,
+        blockchain: Blockchain,
+        derivationPath: String?,
+    ): Mutex {
+        val key = createMutexMapKey(userWalletId, blockchain, derivationPath)
        return wmInitializationMutexes.computeIfAbsent(key) {
            Mutex()
        }
    }

-    private fun createMutexMapKey(blockchain: Blockchain, derivationPath: String?): String {
-        return blockchain.toNetworkId() + "|" + derivationPath
+    private fun createMutexMapKey(userWalletId: UserWalletId, blockchain: Blockchain, derivationPath: String?): String {
+        return listOf(
+            userWalletId.stringValue,
+            blockchain.toNetworkId(),
+            derivationPath,
+        )
+            .joinToString(separator = "|")
    }

    private fun updateWalletManagerTokensIfNeeded(walletManager: WalletManager, tokens: Set<CryptoCurrency.Token>) {
--- a/data/wallets/detekt-baseline-debug.xml
+++ b/data/wallets/detekt-baseline-debug.xml
@ -3,8 +3,6 @@
  <ManuallySuppressedIssues/>
  <CurrentIssues>
    <ID>MultilineLambdaItParameter:DefaultColdMapDerivationsRepository.kt$DefaultColdMapDerivationsRepository${ networkFactory.create( blockchain = Blockchain.fromNetworkId(it.value) ?: return@mapNotNull null, extraDerivationPath = null, userWallet = userWallet, ) }</ID>
-    <ID>MultilineLambdaItParameter:DefaultDerivationsRepository.kt$DefaultDerivationsRepository${ userWallet.update(it.first) it.second }</ID>
-    <ID>MultilineLambdaItParameter:DefaultHotMapDerivationsRepository.kt$DefaultHotMapDerivationsRepository${ networkFactory.create( blockchain = Blockchain.fromNetworkId(it.value) ?: return@mapNotNull null, extraDerivationPath = null, userWallet = userWallet, ) }</ID>
    <ID>MultilineLambdaItParameter:DefaultHotWalletAccessCodeAttemptsRepository.kt$DefaultHotWalletAccessCodeAttemptsRepository${ AttemptsPersistentData( attempts = it[PreferencesKeys.getHotWalletUnlockAttemptsKey(id.attemptIdKey())] ?: 0, bootCount = it[PreferencesKeys.getHotWalletUnlockBootKey(id.attemptIdKey())] ?: 0, deadline = it[PreferencesKeys.getHotWalletUnlockDeadlineKey(id.attemptIdKey())] ?: 0L, ) }</ID>
    <ID>MultilineLambdaItParameter:DefaultHotWalletAccessCodeAttemptsRepository.kt$DefaultHotWalletAccessCodeAttemptsRepository${ it.remove(PreferencesKeys.getHotWalletUnlockAttemptsKey(authAttemptId.attemptIdKey())) it.remove(PreferencesKeys.getHotWalletUnlockAttemptsKey(noAuthAttemptId.attemptIdKey())) it.remove(PreferencesKeys.getHotWalletUnlockBootKey(authAttemptId.attemptIdKey())) it.remove(PreferencesKeys.getHotWalletUnlockBootKey(noAuthAttemptId.attemptIdKey())) it.remove(PreferencesKeys.getHotWalletUnlockDeadlineKey(authAttemptId.attemptIdKey())) it.remove(PreferencesKeys.getHotWalletUnlockDeadlineKey(noAuthAttemptId.attemptIdKey())) }</ID>
    <ID>MultilineLambdaItParameter:DefaultHotWalletAccessCodeAttemptsRepository.kt$DefaultHotWalletAccessCodeAttemptsRepository${ while (true) { emit(toState(id, it.attempts, it.deadline, it.bootCount)) val remaining = remainingSeconds(it.deadline, it.bootCount) if (remaining &lt;= 0) break delay(timeMillis = 1000) } }</ID>
@ -13,12 +11,9 @@
    <ID>MultilineLambdaItParameter:TangemHotWalletSigner.kt$TangemHotWalletSigner${ Timber.e(it) return if (it is TangemSdkError) { CompletionResult.Failure(it) } else { CompletionResult.Failure(TangemSdkError.ExceptionError(it)) } }</ID>
    <ID>NamedArguments:DefaultHotWalletAccessCodeAttemptsRepository.kt$DefaultHotWalletAccessCodeAttemptsRepository$toState(id, count, deadline, boot)</ID>
    <ID>NamedArguments:DefaultHotWalletAccessCodeAttemptsRepository.kt$DefaultHotWalletAccessCodeAttemptsRepository$toState(id, it.attempts, it.deadline, it.bootCount)</ID>
-    <ID>SuspendFunSwallowedCancellation:DefaultHotWalletAccessor.kt$DefaultHotWalletAccessor$runCatching</ID>
    <ID>SuspendFunSwallowedCancellation:TangemHotWalletSigner.kt$TangemHotWalletSigner$runCatching</ID>
    <ID>UnnecessaryLet:MissedDerivationsFinder.kt$MissedDerivationsFinder$let(::findByNetworks)</ID>
-    <ID>UnusedImports:DefaultDerivationsRepository.kt$import com.tangem.common.map</ID>
    <ID>UseOrEmpty:DefaultColdMapDerivationsRepository.kt$DefaultColdMapDerivationsRepository$oldKeys[walletKey] ?: emptyMap()</ID>
-    <ID>UseOrEmpty:DefaultHotMapDerivationsRepository.kt$DefaultHotMapDerivationsRepository$oldKeys[walletKey] ?: emptyMap()</ID>
    <ID>VarCouldBeVal:DefaultHotWalletAccessor.kt$DefaultHotWalletAccessor$private var contextualUnlockHotWallet: ConcurrentHashMap&lt;HotWalletId, UnlockHotWallet?&gt; = ConcurrentHashMap()</ID>
  </CurrentIssues>
 </SmellBaseline>
--- a/data/wallets/src/main/java/com/tangem/data/wallets/DefaultWalletsRepository.kt
+++ b/data/wallets/src/main/java/com/tangem/data/wallets/DefaultWalletsRepository.kt
@ -344,18 +344,27 @@ internal class DefaultWalletsRepository(
        upgradeWalletNotificationDisabled.update { it.plus(userWalletId) }
    }

-    override suspend fun setWalletName(walletId: String, walletName: String) = withContext(dispatchers.io) {
-        val userWallet = userWalletsStore.getSyncOrNull(key = UserWalletId(walletId))
+    override suspend fun setWalletName(walletId: UserWalletId, walletName: String) = withContext(dispatchers.io) {
+        val userWallet = userWalletsStore.getSyncOrNull(key = walletId)

        tangemTechApi.updateWallet(
-            walletId = walletId,
+            walletId = walletId.stringValue,
            body = WalletBody(name = walletName, type = WalletType.from(userWallet)),
        ).getOrThrow()
    }

-    override suspend fun getWalletInfo(walletId: String): UserWalletRemoteInfo = withContext(dispatchers.io) {
+    override suspend fun upgradeWallet(walletId: UserWalletId) = withContext(dispatchers.io) {
+        val userWallet = userWalletsStore.getSyncStrict(key = walletId)
+
+        tangemTechApi.updateWallet(
+            walletId = walletId.stringValue,
+            body = WalletBody(name = userWallet.name, type = WalletType.from(userWallet)),
+        ).getOrThrow()
+    }
+
+    override suspend fun getWalletInfo(walletId: UserWalletId): UserWalletRemoteInfo = withContext(dispatchers.io) {
        UserWalletRemoteInfoConverter.convert(
-            value = tangemTechApi.getWalletById(walletId).getOrThrow(),
+            value = tangemTechApi.getWalletById(walletId.stringValue).getOrThrow(),
        )
    }

--- a/Show more
+++ b/Show more