diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 4102dcfb14..b36d773b95 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -108,6 +108,7 @@ dependencies {
     implementation(projects.domain.onramp)
     implementation(projects.domain.promo)
     implementation(projects.domain.promo.models)
+    implementation(projects.domain.networks)
 
     implementation(projects.common)
     implementation(projects.common.routing)
@@ -150,6 +151,7 @@ dependencies {
     implementation(projects.data.manageTokens)
     implementation(projects.data.nft)
     implementation(projects.data.onramp)
+    implementation(projects.data.networks)
 
     /** Features */
     implementation(projects.features.onboarding)
diff --git a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
index 248192b95d..fc92ca427e 100644
--- a/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/domain/TokensDomainModule.kt
@@ -2,6 +2,8 @@ package com.tangem.tap.di.domain
 
 import com.tangem.core.configtoggle.feature.FeatureTogglesManager
 import com.tangem.domain.exchange.RampStateManager
+import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
+import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
 import com.tangem.domain.promo.PromoRepository
 import com.tangem.domain.staking.repositories.StakingRepository
 import com.tangem.domain.tokens.*
@@ -47,7 +49,12 @@ internal object TokensDomainModule {
         networksRepository: NetworksRepository,
         stakingRepository: StakingRepository,
     ): FetchTokenListUseCase {
-        return FetchTokenListUseCase(currenciesRepository, networksRepository, quotesRepository, stakingRepository)
+        return FetchTokenListUseCase(
+            currenciesRepository = currenciesRepository,
+            networksRepository = networksRepository,
+            quotesRepository = quotesRepository,
+            stakingRepository = stakingRepository,
+        )
     }
 
     @Provides
@@ -151,7 +158,12 @@ internal object TokensDomainModule {
         networksRepository: NetworksRepository,
         stakingRepository: StakingRepository,
     ): FetchCurrencyStatusUseCase {
-        return FetchCurrencyStatusUseCase(currenciesRepository, networksRepository, quotesRepository, stakingRepository)
+        return FetchCurrencyStatusUseCase(
+            currenciesRepository,
+            networksRepository,
+            quotesRepository,
+            stakingRepository,
+        )
     }
 
     @Provides
@@ -349,12 +361,16 @@ internal object TokensDomainModule {
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
         stakingRepository: StakingRepository,
+        singleNetworkStatusSupplier: SingleNetworkStatusSupplier,
+        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
     ): BaseCurrenciesStatusesOperations {
         return CachedCurrenciesStatusesOperations(
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,
             stakingRepository = stakingRepository,
+            singleNetworkStatusSupplier = singleNetworkStatusSupplier,
+            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
             tokensFeatureToggles = tokensFeatureToggles,
         )
     }
@@ -367,12 +383,16 @@ internal object TokensDomainModule {
         quotesRepository: QuotesRepository,
         networksRepository: NetworksRepository,
         stakingRepository: StakingRepository,
+        singleNetworkStatusSupplier: SingleNetworkStatusSupplier,
+        multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
     ): BaseCurrencyStatusOperations {
         return CachedCurrenciesStatusesOperations(
             currenciesRepository = currenciesRepository,
             quotesRepository = quotesRepository,
             networksRepository = networksRepository,
             stakingRepository = stakingRepository,
+            singleNetworkStatusSupplier = singleNetworkStatusSupplier,
+            multiNetworkStatusFetcher = multiNetworkStatusFetcher,
             tokensFeatureToggles = tokensFeatureToggles,
         )
     }
diff --git a/core/config-toggles/src/main/assets/configs/feature_toggles_config.json b/core/config-toggles/src/main/assets/configs/feature_toggles_config.json
index 046b05e60e..34b5b0126e 100644
--- a/core/config-toggles/src/main/assets/configs/feature_toggles_config.json
+++ b/core/config-toggles/src/main/assets/configs/feature_toggles_config.json
@@ -45,7 +45,7 @@
     },
     {
         "name": "NEW_ATTESTATION_ENABLED",
-        "version": "undefined"
+        "version": "5.23.0"
     },
     {
         "name": "TWIN_REFACTORING_ENABLED",
@@ -61,6 +61,6 @@
     },
     {
         "name": "NETWORKS_LOADING_REFACTORING_ENABLED",
-        "version": "undefined"
+        "version": "5.23.0"
     }
 ]
diff --git a/core/datasource/src/main/java/com/tangem/datasource/di/NetworksStatusesStoreModule.kt b/core/datasource/src/main/java/com/tangem/datasource/di/NetworksStatusesStoreModule.kt
index 62010f5c24..b258b16a24 100644
--- a/core/datasource/src/main/java/com/tangem/datasource/di/NetworksStatusesStoreModule.kt
+++ b/core/datasource/src/main/java/com/tangem/datasource/di/NetworksStatusesStoreModule.kt
@@ -1,6 +1,7 @@
 package com.tangem.datasource.di
 
 import android.content.Context
+import androidx.datastore.core.DataStore
 import androidx.datastore.core.DataStoreFactory
 import androidx.datastore.dataStoreFile
 import com.squareup.moshi.Moshi
@@ -25,22 +26,29 @@ import kotlinx.coroutines.SupervisorJob
 internal object NetworksStatusesStoreModule {
 
     @Provides
-    fun provideNetworksStatusesStore(
+    fun providePersistenceNetworksStatusesStore(
         @NetworkMoshi moshi: Moshi,
         @ApplicationContext context: Context,
         dispatchers: CoroutineDispatcherProvider,
+    ): DataStore<Map<String, Set<NetworkStatusDM>>> {
+        return DataStoreFactory.create(
+            serializer = MoshiDataStoreSerializer(
+                moshi = moshi,
+                types = mapWithStringKeyTypes(valueTypes = setTypes<NetworkStatusDM>()),
+                defaultValue = emptyMap(),
+            ),
+            produceFile = { context.dataStoreFile(fileName = "networks_statuses") },
+            scope = CoroutineScope(context = dispatchers.io + SupervisorJob()),
+        )
+    }
+
+    @Provides
+    fun provideNetworksStatusesStore(
+        persistenceNetworksStatusesStore: DataStore<Map<String, Set<NetworkStatusDM>>>,
     ): NetworksStatusesStore {
         return DefaultNetworksStatusesStore(
             runtimeDataStore = RuntimeDataStore(),
-            persistenceDataStore = DataStoreFactory.create(
-                serializer = MoshiDataStoreSerializer(
-                    moshi = moshi,
-                    types = mapWithStringKeyTypes(valueTypes = setTypes<NetworkStatusDM>()),
-                    defaultValue = emptyMap(),
-                ),
-                produceFile = { context.dataStoreFile(fileName = "networks_statuses") },
-                scope = CoroutineScope(context = dispatchers.io + SupervisorJob()),
-            ),
+            persistenceDataStore = persistenceNetworksStatusesStore,
         )
     }
 }
\ No newline at end of file
diff --git a/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusFetcherModule.kt b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusFetcherModule.kt
new file mode 100644
index 0000000000..85eb5b2848
--- /dev/null
+++ b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusFetcherModule.kt
@@ -0,0 +1,24 @@
+package com.tangem.data.networks.di
+
+import com.tangem.data.networks.multi.DefaultMultiNetworkStatusFetcher
+import com.tangem.data.networks.single.DefaultSingleNetworkStatusFetcher
+import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
+import com.tangem.domain.networks.single.SingleNetworkStatusFetcher
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface NetworkStatusFetcherModule {
+
+    @Binds
+    @Singleton
+    fun bindSingleNetworkStatusFetcher(impl: DefaultSingleNetworkStatusFetcher): SingleNetworkStatusFetcher
+
+    @Binds
+    @Singleton
+    fun bindMultiNetworkStatusFetcher(impl: DefaultMultiNetworkStatusFetcher): MultiNetworkStatusFetcher
+}
\ No newline at end of file
diff --git a/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusProducerFactoryModule.kt b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusProducerFactoryModule.kt
new file mode 100644
index 0000000000..e029ba4c86
--- /dev/null
+++ b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusProducerFactoryModule.kt
@@ -0,0 +1,28 @@
+package com.tangem.data.networks.di
+
+import com.tangem.data.networks.multi.DefaultMultiNetworkStatusProducer
+import com.tangem.data.networks.single.DefaultSingleNetworkStatusProducer
+import com.tangem.domain.networks.multi.MultiNetworkStatusProducer
+import com.tangem.domain.networks.single.SingleNetworkStatusProducer
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal interface NetworkStatusProducerFactoryModule {
+
+    @Binds
+    @Singleton
+    fun bindSingleNetworkStatusProducerFactory(
+        impl: DefaultSingleNetworkStatusProducer.Factory,
+    ): SingleNetworkStatusProducer.Factory
+
+    @Binds
+    @Singleton
+    fun bindMultiNetworkStatusProducerFactory(
+        impl: DefaultMultiNetworkStatusProducer.Factory,
+    ): MultiNetworkStatusProducer.Factory
+}
\ No newline at end of file
diff --git a/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusSupplierModule.kt b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusSupplierModule.kt
new file mode 100644
index 0000000000..aea068fa04
--- /dev/null
+++ b/data/networks/src/main/java/com/tangem/data/networks/di/NetworkStatusSupplierModule.kt
@@ -0,0 +1,56 @@
+package com.tangem.data.networks.di
+
+import androidx.datastore.core.DataStore
+import com.tangem.data.networks.store.DefaultNetworksStatusesStoreV2
+import com.tangem.data.networks.store.NetworksStatusesStoreV2
+import com.tangem.datasource.local.datastore.RuntimeSharedStore
+import com.tangem.datasource.local.network.entity.NetworkStatusDM
+import com.tangem.domain.networks.multi.MultiNetworkStatusProducer
+import com.tangem.domain.networks.multi.MultiNetworkStatusSupplier
+import com.tangem.domain.networks.single.SingleNetworkStatusProducer
+import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object NetworkStatusSupplierModule {
+
+    @Provides
+    @Singleton
+    fun provideNetworksStatusesStoreV2(
+        persistenceNetworksStatusesStore: DataStore<Map<String, Set<NetworkStatusDM>>>,
+        dispatchers: CoroutineDispatcherProvider,
+    ): NetworksStatusesStoreV2 {
+        return DefaultNetworksStatusesStoreV2(
+            runtimeStore = RuntimeSharedStore(),
+            persistenceDataStore = persistenceNetworksStatusesStore,
+            dispatchers = dispatchers,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideSingleNetworkStatusSupplier(factory: SingleNetworkStatusProducer.Factory): SingleNetworkStatusSupplier {
+        return object : SingleNetworkStatusSupplier(
+            factory = factory,
+            keyCreator = {
+                "single_network_status_${it.userWalletId.stringValue}_${it.network.id.value}_" +
+                    it.network.derivationPath.value
+            },
+        ) {}
+    }
+
+    @Provides
+    @Singleton
+    fun provideMultiNetworkStatusSupplier(factory: MultiNetworkStatusProducer.Factory): MultiNetworkStatusSupplier {
+        return object : MultiNetworkStatusSupplier(
+            factory = factory,
+            keyCreator = { "multi_networks_statuses_${it.userWalletId.stringValue}" },
+        ) {}
+    }
+}
\ No newline at end of file
diff --git a/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultNetworksRepository.kt b/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultNetworksRepository.kt
index 85fce53032..b85018c34b 100644
--- a/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultNetworksRepository.kt
+++ b/data/tokens/src/main/kotlin/com/tangem/data/tokens/repository/DefaultNetworksRepository.kt
@@ -26,7 +26,9 @@ import com.tangem.domain.walletmanager.model.UpdateWalletManagerResult
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flowOn
 import timber.log.Timber
 
 @Suppress("LongParameterList")
@@ -60,19 +62,6 @@ internal class DefaultNetworksRepository(
         }
     }
 
-    override fun getNetworkStatusesUpdatesLegacy(
-        userWalletId: UserWalletId,
-        networks: Set<Network>,
-    ): Flow<Set<NetworkStatus>> = channelFlow {
-        networksStatusesStore.get(userWalletId)
-            .onEach(::send)
-            .launchIn(scope = this + dispatchers.io)
-
-        withContext(dispatchers.io) {
-            fetchNetworksStatusesIfCacheExpired(userWalletId, networks, refresh = false)
-        }
-    }
-
     override suspend fun fetchNetworkPendingTransactions(userWalletId: UserWalletId, networks: Set<Network>) {
         val currencies = getCurrencies(userWalletId, networks)
         withContext(dispatchers.io) {
diff --git a/domain/tokens/build.gradle.kts b/domain/tokens/build.gradle.kts
index 9382289ad6..6ba910ceae 100644
--- a/domain/tokens/build.gradle.kts
+++ b/domain/tokens/build.gradle.kts
@@ -27,6 +27,7 @@ dependencies {
     implementation(projects.features.swap.domain.models)
     implementation(projects.domain.promo.models)
     implementation(projects.domain.promo)
+    implementation(projects.domain.networks)
 
     /** Project - Api */
     implementation(projects.features.send.api)
@@ -50,6 +51,7 @@ dependencies {
     /** Tests */
     testImplementation(deps.test.junit)
     testImplementation(deps.test.coroutine)
+    testImplementation(deps.test.mockk)
     testImplementation(tangemDeps.blockchain) {
         exclude(module = "joda-time")
     }
diff --git a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/operations/CachedCurrenciesStatusesOperations.kt b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/operations/CachedCurrenciesStatusesOperations.kt
index cab4aff110..b4cf9ec8c4 100644
--- a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/operations/CachedCurrenciesStatusesOperations.kt
+++ b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/operations/CachedCurrenciesStatusesOperations.kt
@@ -1,6 +1,7 @@
 package com.tangem.domain.tokens.operations
 
 import arrow.core.*
+import arrow.core.raise.either
 import arrow.core.raise.recover
 import com.tangem.domain.core.lce.Lce
 import com.tangem.domain.core.lce.LceFlow
@@ -9,6 +10,9 @@ import com.tangem.domain.core.lce.lceFlow
 import com.tangem.domain.core.utils.EitherFlow
 import com.tangem.domain.core.utils.lceContent
 import com.tangem.domain.core.utils.lceError
+import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher
+import com.tangem.domain.networks.single.SingleNetworkStatusProducer
+import com.tangem.domain.networks.single.SingleNetworkStatusSupplier
 import com.tangem.domain.staking.model.stakekit.YieldBalance
 import com.tangem.domain.staking.model.stakekit.YieldBalanceList
 import com.tangem.domain.staking.repositories.StakingRepository
@@ -21,15 +25,19 @@ import com.tangem.domain.tokens.repository.NetworksRepository
 import com.tangem.domain.tokens.repository.QuotesRepository
 import com.tangem.domain.tokens.utils.extractAddress
 import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.utils.extensions.addOrReplace
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
+@Suppress("LongParameterList")
 class CachedCurrenciesStatusesOperations(
     private val currenciesRepository: CurrenciesRepository,
     private val quotesRepository: QuotesRepository,
     private val networksRepository: NetworksRepository,
     private val stakingRepository: StakingRepository,
-    @Suppress("UnusedPrivateMember") private val tokensFeatureToggles: TokensFeatureToggles,
+    private val singleNetworkStatusSupplier: SingleNetworkStatusSupplier,
+    private val multiNetworkStatusFetcher: MultiNetworkStatusFetcher,
+    private val tokensFeatureToggles: TokensFeatureToggles,
 ) : BaseCurrenciesStatusesOperations,
     BaseCurrencyStatusOperations(currenciesRepository, quotesRepository, networksRepository, stakingRepository) {
 
@@ -145,20 +153,26 @@ class CachedCurrenciesStatusesOperations(
         networks: Set<Network>,
         currenciesIds: Set<CryptoCurrency.ID>,
         currencies: List<CryptoCurrency>,
-    ): Either<Throwable, Unit> {
-        return coroutineScope {
-            Either.catch {
-                awaitAll(
-                    async { networksRepository.fetchNetworkStatuses(userWalletId, networks) },
-                    async {
-                        val rawCurrenciesIds = currenciesIds.mapNotNullTo(mutableSetOf()) { it.rawCurrencyId }
-                        quotesRepository.fetchQuotes(rawCurrenciesIds)
-                    },
-                    async { stakingRepository.fetchMultiYieldBalance(userWalletId, currencies) },
-                )
-            }
-                .map { }
+    ): Either<Throwable, Unit> = either {
+        coroutineScope {
+            awaitAll(
+                async {
+                    if (tokensFeatureToggles.isNetworksLoadingRefactoringEnabled) {
+                        multiNetworkStatusFetcher(
+                            params = MultiNetworkStatusFetcher.Params(userWalletId, networks),
+                        )
+                    } else {
+                        networksRepository.fetchNetworkStatuses(userWalletId, networks)
+                    }
+                },
+                async {
+                    val rawCurrenciesIds = currenciesIds.mapNotNullTo(mutableSetOf()) { it.rawCurrencyId }
+                    quotesRepository.fetchQuotes(rawCurrenciesIds)
+                },
+                async { stakingRepository.fetchMultiYieldBalance(userWalletId, currencies) },
+            )
         }
+            .map { }
     }
 
     private fun createCurrenciesStatuses(
@@ -251,31 +265,44 @@ class CachedCurrenciesStatusesOperations(
         userWalletId: UserWalletId,
         network: Network,
     ): EitherFlow<Error, Set<NetworkStatus>> {
-        return networksRepository.getNetworkStatusesUpdates(userWalletId, setOf(network))
-            .map<Set<NetworkStatus>, Either<Error, Set<NetworkStatus>>> { it.right() }
-            .retryWhen { cause, _ ->
-                emit(Error.DataError(cause).left())
-                // adding delay before retry to avoid spam when flow restarted
-                delay(RETRY_DELAY)
-                true
-            }
-            .distinctUntilChanged()
-            .onEmpty { emit(Error.EmptyNetworksStatuses.left()) }
+        return if (tokensFeatureToggles.isNetworksLoadingRefactoringEnabled) {
+            singleNetworkStatusSupplier(
+                params = SingleNetworkStatusProducer.Params(userWalletId = userWalletId, network = network),
+            )
+                .map<NetworkStatus, Either<Error, Set<NetworkStatus>>> { setOf(it).right() }
+                .distinctUntilChanged()
+                .onEmpty { emit(Error.EmptyNetworksStatuses.left()) }
+        } else {
+            networksRepository.getNetworkStatusesUpdates(userWalletId, setOf(network))
+                .map<Set<NetworkStatus>, Either<Error, Set<NetworkStatus>>> { it.right() }
+                .retryWhen { cause, _ ->
+                    emit(Error.DataError(cause).left())
+                    // adding delay before retry to avoid spam when flow restarted
+                    delay(RETRY_DELAY)
+                    true
+                }
+                .distinctUntilChanged()
+                .onEmpty { emit(Error.EmptyNetworksStatuses.left()) }
+        }
     }
 
     private fun getNetworksStatuses(
         userWalletId: UserWalletId,
         networks: NonEmptySet<Network>,
     ): EitherFlow<TokenListError, Set<NetworkStatus>> {
-        return networksRepository.getNetworkStatusesUpdates(userWalletId, networks)
-            .map<Set<NetworkStatus>, Either<TokenListError, Set<NetworkStatus>>> { it.right() }
-            .retryWhen { cause, _ ->
-                emit(TokenListError.DataError(cause).left())
-                // adding delay before retry to avoid spam when flow restarted
-                delay(RETRY_DELAY)
-                true
-            }
-            .distinctUntilChanged()
+        return if (tokensFeatureToggles.isNetworksLoadingRefactoringEnabled) {
+            getNetworkStatusesUpdates(userWalletId, networks)
+        } else {
+            networksRepository.getNetworkStatusesUpdates(userWalletId, networks)
+                .map<Set<NetworkStatus>, Either<TokenListError, Set<NetworkStatus>>> { it.right() }
+                .retryWhen { cause, _ ->
+                    emit(TokenListError.DataError(cause).left())
+                    // adding delay before retry to avoid spam when flow restarted
+                    delay(RETRY_DELAY)
+                    true
+                }
+                .distinctUntilChanged()
+        }
     }
 
     private fun getYieldBalances(
@@ -293,6 +320,36 @@ class CachedCurrenciesStatusesOperations(
             .distinctUntilChanged()
     }
 
+    // temporary code because token list is built using networks list
+    private fun getNetworkStatusesUpdates(
+        userWalletId: UserWalletId,
+        networks: NonEmptySet<Network>,
+    ): EitherFlow<TokenListError, Set<NetworkStatus>> {
+        return channelFlow {
+            val state = MutableStateFlow(emptySet<NetworkStatus>())
+
+            networks.onEach {
+                launch {
+                    singleNetworkStatusSupplier(
+                        params = SingleNetworkStatusProducer.Params(userWalletId = userWalletId, network = it),
+                    )
+                        .onEach { status ->
+                            state.update { loadedStatuses ->
+                                loadedStatuses.addOrReplace(status) { it.network == status.network }
+                            }
+                        }
+                        .launchIn(scope = this)
+                }
+            }
+
+            state
+                .onEach(::send)
+                .launchIn(scope = this)
+        }
+            .map<Set<NetworkStatus>, Either<TokenListError, Set<NetworkStatus>>> { it.right() }
+            .distinctUntilChanged()
+    }
+
     companion object {
         internal const val RETRY_DELAY = 2000L
     }
diff --git a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/NetworksRepository.kt b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/NetworksRepository.kt
index 7b799da0f0..1b66ccde06 100644
--- a/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/NetworksRepository.kt
+++ b/domain/tokens/src/main/kotlin/com/tangem/domain/tokens/repository/NetworksRepository.kt
@@ -35,17 +35,6 @@ interface NetworksRepository {
      * */
     suspend fun fetchNetworkStatuses(userWalletId: UserWalletId, networks: Set<Network>, refresh: Boolean = false)
 
-    /**
-     * Retrieves updates of network statuses of specified blockchain networks for a specific user wallet.
-     *
-     * Loads remote network statuses if they have expired.
-     *
-     * @param userWalletId The unique identifier of the user wallet.
-     * @param networks A set of network which statuses are to be retrieved.
-     * @return A [Flow] emitting a set of [NetworkStatus] objects corresponding to the specified networks.
-     */
-    fun getNetworkStatusesUpdatesLegacy(userWalletId: UserWalletId, networks: Set<Network>): Flow<Set<NetworkStatus>>
-
     /**
      * Fetches pending transactions for given network
      *
diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetPrimaryCurrencyStatusUpdatesUseCaseTest.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetPrimaryCurrencyStatusUpdatesUseCaseTest.kt
index d86abc8442..975da996c8 100644
--- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetPrimaryCurrencyStatusUpdatesUseCaseTest.kt
+++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/GetPrimaryCurrencyStatusUpdatesUseCaseTest.kt
@@ -17,6 +17,7 @@ import com.tangem.domain.tokens.repository.MockQuotesRepository
 import com.tangem.domain.tokens.repository.MockStakingRepository
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider
+import io.mockk.mockk
 import junit.framework.TestCase.assertEquals
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
@@ -176,9 +177,12 @@ internal class GetPrimaryCurrencyStatusUpdatesUseCaseTest {
             quotesRepository = MockQuotesRepository(quotes),
             networksRepository = MockNetworksRepository(statuses),
             stakingRepository = MockStakingRepository(),
+
             tokensFeatureToggles = object : TokensFeatureToggles {
                 override val isNetworksLoadingRefactoringEnabled: Boolean = false
             },
+            singleNetworkStatusSupplier = mockk(),
+            multiNetworkStatusFetcher = mockk(),
         ),
         dispatchers = dispatchers,
     )
diff --git a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockNetworksRepository.kt b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockNetworksRepository.kt
index 956bfa3dac..c7866234bf 100644
--- a/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockNetworksRepository.kt
+++ b/domain/tokens/src/test/kotlin/com/tangem/domain/tokens/repository/MockNetworksRepository.kt
@@ -26,13 +26,6 @@ internal class MockNetworksRepository(
         /* no-op */
     }
 
-    override fun getNetworkStatusesUpdatesLegacy(
-        userWalletId: UserWalletId,
-        networks: Set<Network>,
-    ): Flow<Set<NetworkStatus>> {
-        return statuses.map { it.getOrElse { e -> throw e } }
-    }
-
     override suspend fun fetchNetworkPendingTransactions(userWalletId: UserWalletId, networks: Set<Network>) {
         // no-op
     }
@@ -42,7 +35,7 @@ internal class MockNetworksRepository(
         networks: Set<Network>,
         refresh: Boolean,
     ): Set<NetworkStatus> {
-        return getNetworkStatusesUpdatesLegacy(userWalletId, networks).first()
+        return statuses.map { it.getOrElse { e -> throw e } }.first()
     }
 
     override fun isNeedToCreateAccountWithoutReserve(network: Network) = false