Updated on 2026-08-14

2023-03-10 15:57:02 +03:00 · 2023-03-10 15:57:02 +03:00 · 89462afb99
commit 89462afb99
parent fee3bdf257 17ba4a88e3
75 changed files with 1176 additions and 346 deletions
--- a/app/src/main/java/com/tangem/tap/MainActivity.kt
+++ b/app/src/main/java/com/tangem/tap/MainActivity.kt
@ -10,6 +10,7 @@ import androidx.core.view.WindowInsetsControllerCompat
 import by.kirich1409.viewbindingdelegate.viewBinding
 import com.google.android.material.snackbar.Snackbar
 import com.tangem.TangemSdk
+import com.tangem.features.tester.api.TesterRouter
 import com.tangem.operations.backup.BackupService
 import com.tangem.tangem_sdk_new.extensions.init
 import com.tangem.tangem_sdk_new.extensions.initWithBiometrics
@ -33,6 +34,7 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
 import com.tangem.tap.features.shop.redux.ShopAction
 import com.tangem.tap.features.welcome.redux.WelcomeAction
 import com.tangem.tap.proxy.AppStateHolder
+import com.tangem.tap.proxy.redux.DaggerGraphAction
 import com.tangem.utils.coroutines.FeatureCoroutineExceptionHandler
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.ActivityMainBinding
@ -71,6 +73,10 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
    @Inject
    lateinit var appStateHolder: AppStateHolder

+    /** Router for opening tester menu */
+    @Inject
+    lateinit var testerRouter: TesterRouter
+
    private var snackbar: Snackbar? = null
    private val dialogManager = DialogManager()
    private val binding: ActivityMainBinding by viewBinding(ActivityMainBinding::bind)
@ -97,6 +103,8 @@ class MainActivity : AppCompatActivity(), SnackbarHandler, ActivityResultCallbac
                GooglePayService(createPaymentsClient(this), this),
            ),
        )
+
+        store.dispatch(DaggerGraphAction.SetActivityDependencies(testerRouter))
    }

    private fun initUserWalletsListManager() {
--- a/app/src/main/java/com/tangem/tap/TapApplication.kt
+++ b/app/src/main/java/com/tangem/tap/TapApplication.kt
@ -11,12 +11,13 @@ import com.tangem.blockchain.common.BlockchainSdkConfig
 import com.tangem.blockchain.common.WalletManagerFactory
 import com.tangem.blockchain.network.BlockchainSdkRetrofitBuilder
 import com.tangem.core.analytics.Analytics
+import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
 import com.tangem.datasource.api.common.MoshiConverter
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.datasource.config.ConfigManager
 import com.tangem.datasource.config.FeaturesLocalLoader
 import com.tangem.datasource.config.models.Config
-import com.tangem.datasource.utils.AndroidAssetReader
-import com.tangem.datasource.utils.AssetReader
+import com.tangem.datasource.connection.NetworkConnectionManager
 import com.tangem.domain.DomainLayer
 import com.tangem.domain.common.LogConfig
 import com.tangem.tap.common.IntentHandler
@ -49,11 +50,12 @@ import com.tangem.tap.domain.walletStores.repository.WalletManagersRepository
 import com.tangem.tap.domain.walletStores.repository.WalletStoresRepository
 import com.tangem.tap.domain.walletStores.repository.di.provideDefaultImplementation
 import com.tangem.tap.domain.walletconnect.WalletConnectRepository
-import com.tangem.tap.network.NetworkConnectivity
 import com.tangem.tap.persistence.PreferencesStorage
 import com.tangem.tap.proxy.AppStateHolder
+import com.tangem.tap.proxy.redux.DaggerGraphAction
 import com.tangem.wallet.BuildConfig
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.launch
 import okhttp3.logging.HttpLoggingInterceptor
 import org.rekotlin.Store
 import timber.log.Timber
@ -66,7 +68,6 @@ lateinit var activityResultCaller: ActivityResultCaller
 lateinit var preferencesStorage: PreferencesStorage
 lateinit var walletConnectRepository: WalletConnectRepository
 lateinit var shopService: TangemShopService
-lateinit var assetReader: AssetReader
 lateinit var userTokensRepository: UserTokensRepository

 private val walletStoresRepository by lazy { WalletStoresRepository.provideDefaultImplementation() }
@ -117,6 +118,15 @@ class TapApplication : Application(), ImageLoaderFactory {
    @Inject
    lateinit var configManager: ConfigManager

+    @Inject
+    lateinit var assetReader: AssetReader
+
+    @Inject
+    lateinit var featureTogglesManager: FeatureTogglesManager
+
+    @Inject
+    lateinit var networkConnectionManager: NetworkConnectionManager
+
    override fun onCreate() {
        super.onCreate()

@ -137,11 +147,9 @@ class TapApplication : Application(), ImageLoaderFactory {
        registerActivityLifecycleCallbacks(foregroundActivityObserver.callbacks)

        DomainLayer.init()
-        NetworkConnectivity.createInstance(store, this)
        preferencesStorage = PreferencesStorage(this)
        walletConnectRepository = WalletConnectRepository(this)

-        assetReader = AndroidAssetReader(this)
        val configLoader = FeaturesLocalLoader(assetReader, MoshiConverter.sdkMoshi, BuildConfig.ENVIRONMENT)
        initConfigManager(configLoader, ::initWithConfigDependency)
        initWarningMessagesManager()
@ -155,10 +163,22 @@ class TapApplication : Application(), ImageLoaderFactory {
        userTokensRepository = UserTokensRepository.init(
            context = this,
            tangemTechService = store.state.domainNetworks.tangemTechService,
+            networkConnectionManager = networkConnectionManager,
        )
        appStateHolder.mainStore = store
        appStateHolder.userTokensRepository = userTokensRepository
        appStateHolder.walletStoresManager = walletStoresManager
+
+        store.dispatch(
+            action = DaggerGraphAction.SetApplicationDependencies(
+                assetReader = assetReader,
+                networkConnectionManager = networkConnectionManager,
+            ),
+        )
+
+        scope.launch {
+            featureTogglesManager.init()
+        }
    }

    override fun newImageLoader(): ImageLoader {
@ -208,6 +228,7 @@ class TapApplication : Application(), ImageLoaderFactory {
    ) {
        fun initAdditionalFeedbackInfo(context: Context): AdditionalFeedbackInfo = AdditionalFeedbackInfo().apply {
            appVersion = try {
+                // TODO don't use deprecated method
                val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
                pInfo.versionName
            } catch (e: PackageManager.NameNotFoundException) {
--- a/app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/extensions/WalletManager.kt
@ -16,8 +16,8 @@ import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.redux.AddressData
 import com.tangem.tap.features.wallet.redux.reducers.createAddressesData
-import com.tangem.tap.network.NetworkConnectivity
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.store
 import kotlinx.coroutines.delay
 import timber.log.Timber
@ -47,7 +47,8 @@ suspend fun WalletManager.safeUpdate(): Result<Wallet> = try {
 } catch (exception: Exception) {
    Timber.e(exception)

-    if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+    val networkConnectionManager = store.state.daggerGraphState.get(DaggerGraphState::networkConnectionManager)
+    if (!networkConnectionManager.isOnline) {
        Result.Failure(TapError.NoInternetConnection)
    } else {
        val blockchain = wallet.blockchain
@ -87,8 +88,6 @@ fun WalletManager?.getAddressData(): AddressData? {
    return if (addressDataList.isEmpty()) null else addressDataList[0]
 }

-fun WalletManager.getTxHistory(currency: Currency): List<TransactionData> = wallet.getTxHistory(currency)
-
 fun WalletManager.getBlockchainTxHistory(): List<TransactionData> = wallet.getBlockchainTxHistory()

 fun WalletManager.getTokenTxHistory(token: Token): List<TransactionData> = wallet.getTokenTxHistory(token)
--- a/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt
@ -19,6 +19,7 @@ import com.tangem.tap.features.wallet.redux.reducers.WalletReducer
 import com.tangem.tap.features.walletSelector.redux.WalletSelectorReducer
 import com.tangem.tap.features.welcome.redux.WelcomeReducer
 import com.tangem.tap.proxy.AppStateHolder
+import com.tangem.tap.proxy.redux.DaggerGraphReducer
 import org.rekotlin.Action

 fun appReducer(action: Action, state: AppState?, appStateHolder: AppStateHolder): AppState {
@ -44,6 +45,7 @@ fun appReducer(action: Action, state: AppState?, appStateHolder: AppStateHolder)
        saveWalletState = SaveWalletReducer.reduce(action, state),
        walletSelectorState = WalletSelectorReducer.reduce(action, state),
        sprinklrState = SprinklrReducer.reduce(action, state),
+        daggerGraphState = DaggerGraphReducer.reduce(action, state),
    )
 }

--- a/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
+++ b/app/src/main/java/com/tangem/tap/common/redux/AppState.kt
@ -41,6 +41,8 @@ import com.tangem.tap.features.walletSelector.redux.WalletSelectorMiddleware
 import com.tangem.tap.features.walletSelector.redux.WalletSelectorState
 import com.tangem.tap.features.welcome.redux.WelcomeMiddleware
 import com.tangem.tap.features.welcome.redux.WelcomeState
+import com.tangem.tap.proxy.redux.DaggerGraphMiddleware
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
 import org.rekotlin.Middleware
 import org.rekotlin.StateType
@ -64,6 +66,7 @@ data class AppState(
    val saveWalletState: SaveWalletState = SaveWalletState(),
    val walletSelectorState: WalletSelectorState = WalletSelectorState(),
    val sprinklrState: SprinklrState = SprinklrState(),
+    val daggerGraphState: DaggerGraphState = DaggerGraphState(),
 ) : StateType {

    val domainState: DomainState
@ -105,6 +108,7 @@ data class AppState(
                LockUserWalletsTimerMiddleware().middleware,
                AccessCodeRequestPolicyMiddleware().middleware,
                SprinklrMiddleware().middleware,
+                DaggerGraphMiddleware.daggerGraphMiddleware,
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tokens/LoadAvailableCoinsService.kt
@ -6,8 +6,8 @@ import com.tangem.common.services.Result
 import com.tangem.datasource.api.common.MoshiConverter
 import com.tangem.datasource.api.tangemTech.TangemTechApi
 import com.tangem.datasource.api.tangemTech.models.CoinsResponse
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.domain.common.extensions.toNetworkId
-import com.tangem.datasource.utils.AssetReader
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.withContext

@ -74,8 +74,8 @@ class LoadAvailableCoinsService(
        }
    }

-    fun getTestnetCoins(): List<Currency> {
-        val json = assetReader.readAssetAsString(FILE_NAME_TESTNET_COINS)
+    private fun getTestnetCoins(): List<Currency> {
+        val json = assetReader.readJson(FILE_NAME_TESTNET_COINS)
        return currenciesAdapter.fromJson(json)!!.coins
            .map { Currency.fromJsonObject(it) }
    }
--- a/app/src/main/java/com/tangem/tap/domain/tokens/UserTokensRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tokens/UserTokensRepository.kt
@ -6,6 +6,7 @@ import com.tangem.common.core.TangemSdkError
 import com.tangem.datasource.api.tangemTech.TangemTechApi
 import com.tangem.datasource.api.tangemTech.TangemTechService
 import com.tangem.datasource.api.tangemTech.models.UserTokensResponse
+import com.tangem.datasource.connection.NetworkConnectionManager
 import com.tangem.domain.common.CardDTO
 import com.tangem.tap.common.AndroidFileReader
 import com.tangem.tap.domain.model.builders.UserWalletIdBuilder
@ -15,7 +16,6 @@ import com.tangem.tap.features.demo.DemoHelper
 import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.toBlockchainNetworks
 import com.tangem.tap.features.wallet.models.toCurrencies
-import com.tangem.tap.network.NetworkConnectivity
 import com.tangem.utils.coroutines.AppCoroutineDispatcherProvider
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.withContext
@ -25,6 +25,7 @@ class UserTokensRepository(
    private val storageService: UserTokensStorageService,
    private val tangemTechApi: TangemTechApi,
    private val dispatchers: CoroutineDispatcherProvider,
+    private val networkConnectionManager: NetworkConnectionManager,
 ) {

    // TODO("After adding DI") replace with CoroutineDispatcherProvider
@ -34,7 +35,7 @@ class UserTokensRepository(
            return@withContext loadTokensOffline(card, userId).ifEmpty(::loadDemoCurrencies)
        }

-        if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+        if (!networkConnectionManager.isOnline) {
            return@withContext loadTokensOffline(card, userId)
        }

@ -131,7 +132,11 @@ class UserTokensRepository(
        private const val NOT_FOUND_HTTP_CODE = "404"

        // TODO("After adding DI") get dependencies by DI
-        fun init(context: Context, tangemTechService: TangemTechService): UserTokensRepository {
+        fun init(
+            context: Context,
+            tangemTechService: TangemTechService,
+            networkConnectionManager: NetworkConnectionManager,
+        ): UserTokensRepository {
            val fileReader = AndroidFileReader(context)
            val dispatchers = AppCoroutineDispatcherProvider()

@ -149,6 +154,7 @@ class UserTokensRepository(
                storageService = storageService,
                tangemTechApi = tangemTechService.api,
                dispatchers = dispatchers,
+                networkConnectionManager = networkConnectionManager,
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/domain/twins/TwinCardsManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/twins/TwinCardsManager.kt
@ -9,10 +9,10 @@ import com.tangem.common.KeyPair
 import com.tangem.common.extensions.hexToBytes
 import com.tangem.common.extensions.toHexString
 import com.tangem.datasource.api.common.MoshiConverter
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.domain.common.CardDTO
 import com.tangem.domain.common.ScanResponse
 import com.tangem.operations.wallet.CreateWalletResponse
-import com.tangem.datasource.utils.AssetReader
 import com.tangem.tap.tangemSdkManager

 class TwinCardsManager(
@ -89,7 +89,7 @@ class TwinCardsManager(
        }

        private fun getIssuers(reader: AssetReader): List<Issuer> {
-            val file = reader.readAssetAsString("tangem-app-config/issuers")
+            val file = reader.readJson(fileName = "tangem-app-config/issuers")
            return getAdapter().fromJson(file)!!
        }
    }
--- a/app/src/main/java/com/tangem/tap/domain/walletStores/repository/implementation/DefaultWalletAmountsRepository.kt
+++ b/app/src/main/java/com/tangem/tap/domain/walletStores/repository/implementation/DefaultWalletAmountsRepository.kt
@ -44,7 +44,8 @@ import com.tangem.tap.features.wallet.models.Currency
 import com.tangem.tap.features.wallet.models.PendingTransactionType
 import com.tangem.tap.features.wallet.models.filterByCoin
 import com.tangem.tap.features.wallet.models.getPendingTransactions
-import com.tangem.tap.network.NetworkConnectivity
+import com.tangem.tap.proxy.redux.DaggerGraphState
+import com.tangem.tap.store
 import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
@ -62,8 +63,6 @@ internal class DefaultWalletAmountsRepository(
    private val tangemTechApi: TangemTechApi,
    private val dispatchers: CoroutineDispatcherProvider,
 ) : WalletAmountsRepository {
-    private val walletStoresStorage = WalletStoresStorage
-    private val walletManagersStorage = WalletManagerStorage

    override suspend fun updateAmountsForUserWallets(
        userWallets: List<UserWallet>,
@ -76,8 +75,7 @@ internal class DefaultWalletAmountsRepository(
                awaitAll(
                    async { fetchAmountsForUserWallets(userWallets) },
                    async { fetchFiatRates(userWallets, walletStores = null, fiatCurrency) },
-                )
-                    .fold()
+                ).fold()
            }
        }
    }
@ -104,8 +102,7 @@ internal class DefaultWalletAmountsRepository(
                awaitAll(
                    async { fetchAmountForWalletStores(userWalletId, scanResponse, walletStores) },
                    async { fetchFiatRates(listOf(userWallet), walletStores, fiatCurrency) },
-                )
-                    .fold()
+                ).fold()
            }
        }
    }
@ -123,41 +120,41 @@ internal class DefaultWalletAmountsRepository(
        walletStores: List<WalletStoreModel>?,
        fiatCurrency: FiatCurrency,
    ): CompletionResult<Unit> {
-        // FIXME: Use NetworkConnectionManager when it is added to DI
-        if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+        val networkConnectionManager = store.state.daggerGraphState.get(DaggerGraphState::networkConnectionManager)
+        if (!networkConnectionManager.isOnline) {
            return CompletionResult.Failure(WalletStoresError.NoInternetConnection)
        }

        val walletStoresInternal = walletStores ?: getWalletStores(userWallets)
-        val currencies = walletStoresInternal
-            .asSequence()
-            .flatMap { it.walletsData }
-            .map { it.currency }
+        val currencies = walletStoresInternal.asSequence().flatMap { it.walletsData }.map { it.currency }

        val coinsIds = currencies.mapNotNull { it.coinId }.distinct().toList()

        return withContext(dispatchers.io) {
-            runCatching { tangemTechApi.getRates(fiatCurrency.code.lowercase(), coinsIds.joinToString(",")) }
-                .onSuccess {
-                    updateWalletStoresWithFiatRates(walletStores = walletStoresInternal, fiatRates = it.rates)
-                    return@withContext CompletionResult.Success(Unit)
-                }
-                .onFailure {
-                    val error = WalletStoresError.FetchFiatRatesError(
-                        currencies = currencies.map(Currency::currencySymbol).toList(),
-                        cause = it,
-                    )
+            runCatching {
+                tangemTechApi.getRates(
+                    fiatCurrency.code.lowercase(),
+                    coinsIds.joinToString(","),
+                )
+            }.onSuccess {
+                updateWalletStoresWithFiatRates(walletStores = walletStoresInternal, fiatRates = it.rates)
+                return@withContext CompletionResult.Success(Unit)
+            }.onFailure {
+                val error = WalletStoresError.FetchFiatRatesError(
+                    currencies = currencies.map(Currency::currencySymbol).toList(),
+                    cause = it,
+                )

-                    Timber.e(
-                        error,
-                        """
+                Timber.e(
+                    error,
+                    """
                            Unable to fetch fiat rates
                            |- Coins ids: $coinsIds
-                        """.trimIndent(),
-                    )
+                    """.trimIndent(),
+                )

-                    return@withContext CompletionResult.Failure(error)
-                }
+                return@withContext CompletionResult.Failure(error)
+            }

            error("Unreachable code because runCatching must return result")
        }
@ -166,9 +163,7 @@ internal class DefaultWalletAmountsRepository(
    private suspend fun fetchAmountsForUserWallets(
        userWallets: List<UserWallet>,
    ): CompletionResult<Unit> = withContext(Dispatchers.Default) {
-        userWallets.map { async { fetchAmountsForUserWallet(it) } }
-            .awaitAll()
-            .fold()
+        userWallets.map { async { fetchAmountsForUserWallet(it) } }.awaitAll().fold()
    }

    private suspend fun fetchAmountsForUserWallet(
@ -186,8 +181,8 @@ internal class DefaultWalletAmountsRepository(
        scanResponse: ScanResponse,
        walletStores: List<WalletStoreModel>,
    ): CompletionResult<Unit> = coroutineScope {
-        // FIXME: Use NetworkConnectionManager when it is added to DI
-        if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+        val networkConnectionManager = store.state.daggerGraphState.get(DaggerGraphState::networkConnectionManager)
+        if (!networkConnectionManager.isOnline) {
            walletStores.forEach {
                updateWalletStoreWithUnreachable(it)
            }
@ -200,9 +195,7 @@ internal class DefaultWalletAmountsRepository(
                val walletManager = walletStore.walletManager
                fetchAmountsForWalletStore(userWalletId, scanResponse, walletStore, walletManager)
            }
-        }
-            .awaitAll()
-            .fold()
+        }.awaitAll().fold()
    }

    private suspend fun fetchAmountsForWalletStore(
@ -223,24 +216,25 @@ internal class DefaultWalletAmountsRepository(
                updateWalletStoreWithUnreachable(walletStore)
            }
            else -> {
-                updateWalletManager(scanResponse, walletManager)
-                    .map { updateWalletManagerInStorage(userWalletId, walletManager) }
-                    .flatMap {
-                        updateWalletStoreWithAmounts(
-                            walletStore = walletStore,
-                            updatedWallet = walletManager.wallet,
-                            // FIXME: move DemoHelper to Demo core module maybe
-                            isDemo = DemoHelper.isDemoCardId(scanResponse.card.cardId),
-                        )
-                    }
-                    .flatMap { fetchWalletStoreRentIfNeeded(walletStore, walletManager) }
-                    .flatMapOnFailure { error ->
-                        updateWalletStoreWithError(
-                            walletStore = walletStore,
-                            wallet = walletManager.wallet,
-                            error = error,
-                        )
-                    }
+                updateWalletManager(scanResponse, walletManager).map {
+                    updateWalletManagerInStorage(
+                        userWalletId,
+                        walletManager,
+                    )
+                }.flatMap {
+                    updateWalletStoreWithAmounts(
+                        walletStore = walletStore,
+                        updatedWallet = walletManager.wallet,
+                        // FIXME: move DemoHelper to Demo core module maybe
+                        isDemo = DemoHelper.isDemoCardId(scanResponse.card.cardId),
+                    )
+                }.flatMap { fetchWalletStoreRentIfNeeded(walletStore, walletManager) }.flatMapOnFailure { error ->
+                    updateWalletStoreWithError(
+                        walletStore = walletStore,
+                        wallet = walletManager.wallet,
+                        error = error,
+                    )
+                }
            }
        }
    }
@ -267,8 +261,7 @@ internal class DefaultWalletAmountsRepository(
        walletStore: WalletStoreModel,
        walletManager: WalletManager,
    ): CompletionResult<Unit> {
-        val rentProvider = walletManager as? RentProvider
-            ?: return CompletionResult.Success(Unit)
+        val rentProvider = walletManager as? RentProvider ?: return CompletionResult.Success(Unit)

        when (val result = rentProvider.minimalBalanceForRentExemption()) {
            is Success -> {
@ -318,7 +311,7 @@ internal class DefaultWalletAmountsRepository(
        )

        if (error is BlockchainSdkError) {
-            walletStoresStorage.update { prevState ->
+            WalletStoresStorage.update { prevState ->
                prevState.replaceWalletStore(
                    walletStoreToUpdate = walletStore,
                    update = {
@ -350,7 +343,7 @@ internal class DefaultWalletAmountsRepository(
            """.trimIndent(),
        )

-        walletStoresStorage.update { prevState ->
+        WalletStoresStorage.update { prevState ->
            prevState.replaceWalletStore(
                walletStoreToUpdate = walletStore,
                update = {
@ -378,7 +371,7 @@ internal class DefaultWalletAmountsRepository(
            """.trimIndent(),
        )

-        walletStoresStorage.update { prevState ->
+        WalletStoresStorage.update { prevState ->
            prevState.replaceWalletStore(
                walletStoreToUpdate = walletStore,
                update = {
@ -402,7 +395,7 @@ internal class DefaultWalletAmountsRepository(
            """.trimIndent(),
        )

-        walletStoresStorage.update { prevState ->
+        WalletStoresStorage.update { prevState ->
            prevState.replaceWalletStore(
                walletStoreToUpdate = walletStore,
                update = {
@ -425,7 +418,7 @@ internal class DefaultWalletAmountsRepository(
            """.trimIndent(),
        )

-        walletStoresStorage.update { prevState ->
+        WalletStoresStorage.update { prevState ->
            prevState.replaceWalletStores(
                walletStoresToUpdate = walletStores,
                update = {
@ -450,7 +443,7 @@ internal class DefaultWalletAmountsRepository(
        )

        if (rent != walletStore.walletRent) {
-            walletStoresStorage.update { prevState ->
+            WalletStoresStorage.update { prevState ->
                prevState.replaceWalletStore(
                    walletStoreToUpdate = walletStore,
                    update = {
@ -465,14 +458,12 @@ internal class DefaultWalletAmountsRepository(
        userWalletId: UserWalletId,
        walletManager: WalletManager,
    ) = withContext(Dispatchers.Default) {
-        walletManagersStorage.update { prevManagers ->
-            val newManagersForUserWallet = prevManagers[userWalletId].orEmpty()
-                .toMutableList()
-                .apply {
-                    replaceByOrAdd(walletManager) {
-                        it.wallet.blockchain == walletManager.wallet.blockchain
-                    }
+        WalletManagerStorage.update { prevManagers ->
+            val newManagersForUserWallet = prevManagers[userWalletId].orEmpty().toMutableList().apply {
+                replaceByOrAdd(walletManager) {
+                    it.wallet.blockchain == walletManager.wallet.blockchain
                }
+            }

            prevManagers.apply {
                set(userWalletId, newManagersForUserWallet)
@ -481,13 +472,8 @@ internal class DefaultWalletAmountsRepository(
    }

    private suspend fun getWalletStores(userWallets: List<UserWallet>): List<WalletStoreModel> {
-        return userWallets
-            .map { it.walletId }
-            .flatMap { userWalletId ->
-                walletStoresStorage.getAll()
-                    .firstOrNull()
-                    ?.get(userWalletId)
-                    .orEmpty()
-            }
+        return userWallets.map { it.walletId }.flatMap { userWalletId ->
+            WalletStoresStorage.getAll().firstOrNull()?.get(userWalletId).orEmpty()
+        }
    }
 }
--- a/app/src/main/java/com/tangem/tap/features/details/ui/details/DetailsScreenState.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/details/DetailsScreenState.kt
@ -29,7 +29,8 @@ enum class SettingsElement(
    AppSettings(R.drawable.ic_settings, R.string.app_settings_title),
    LinkMoreCards(R.drawable.ic_more_cards, R.string.details_row_title_create_backup),
    TermsOfService(R.drawable.ic_text, R.string.disclaimer_title), // General Terms of Service of the App
-    PrivacyPolicy(R.drawable.ic_lock_24, R.string.details_row_privacy_policy);
+    PrivacyPolicy(R.drawable.ic_lock_24, R.string.details_row_privacy_policy),
+    TesterMenu(R.drawable.ic_alert_24, R.string.tester_menu)
 }

@Immutable
--- a/app/src/main/java/com/tangem/tap/features/details/ui/details/DetailsViewModel.kt
+++ b/app/src/main/java/com/tangem/tap/features/details/ui/details/DetailsViewModel.kt
@ -39,6 +39,7 @@ class DetailsViewModel(private val store: Store<AppState>) {
                SettingsElement.AppSettings -> if (state.appSettingsState.isBiometricsAvailable) it else null
                SettingsElement.AppCurrency -> if (cardTypesResolver?.isMultiwalletAllowed() != true) it else null
                SettingsElement.ReferralProgram -> if (cardTypesResolver?.isTangemWallet() == true) it else null
+                SettingsElement.TesterMenu -> if (BuildConfig.TESTER_MENU_ENABLED) it else null
                else -> it
            }
        }
@ -96,6 +97,9 @@ class DetailsViewModel(private val store: Store<AppState>) {
            SettingsElement.ReferralProgram -> {
                store.dispatch(NavigationAction.NavigateTo(AppScreen.ReferralProgram))
            }
+            SettingsElement.TesterMenu -> {
+                store.state.daggerGraphState.testerRouter?.startTesterScreen()
+            }
        }
    }

--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/redux/TwinCardsAction.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/redux/TwinCardsAction.kt
@ -3,7 +3,7 @@ package com.tangem.tap.features.onboarding.products.twins.redux
 import com.tangem.Message
 import com.tangem.blockchain.common.WalletManager
 import com.tangem.common.extensions.VoidCallback
-import com.tangem.datasource.utils.AssetReader
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.domain.common.ScanResponse
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.twins.TwinCardsManager
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/ui/TwinsCardsFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/twins/ui/TwinsCardsFragment.kt
@ -15,7 +15,7 @@ import com.tangem.blockchain.common.Blockchain
 import com.tangem.common.extensions.VoidCallback
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.ui.fragments.setStatusBarColor
-import com.tangem.datasource.utils.AndroidAssetReader
+import com.tangem.datasource.asset.AssetReader
 import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.TwinCardNumber
 import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapfrogWidget
@ -39,10 +39,16 @@ import com.tangem.tap.features.wallet.redux.Artwork
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import com.tangem.wallet.databinding.LayoutOnboardingContainerTopBinding
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject

@Suppress("LargeClass")
+@AndroidEntryPoint
 class TwinsCardsFragment : BaseOnboardingFragment<TwinCardsState>() {

+    @Inject
+    lateinit var assetReader: AssetReader
+
    private val mainBinding by lazy { binding.vMain }
    private var previousStep: TwinCardsStep = TwinCardsStep.None

@ -253,8 +259,8 @@ class TwinsCardsFragment : BaseOnboardingFragment<TwinCardsState>() {
            Analytics.send(Onboarding.CreateWallet.ButtonCreateWallet())
            store.dispatch(
                TwinCardsAction.Wallet.LaunchFirstStep(
-                    Message(getString(R.string.twins_recreate_title_format, twinIndexNumber)),
-                    AndroidAssetReader(requireContext()),
+                    initialMessage = Message(getString(R.string.twins_recreate_title_format, twinIndexNumber)),
+                    reader = assetReader,
                ),
            )
        }
--- a/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/tokens/redux/TokensMiddleware.kt
@ -21,7 +21,6 @@ import com.tangem.domain.features.addCustomToken.redux.AddCustomTokenAction
 import com.tangem.domain.redux.domainStore
 import com.tangem.operations.derivation.ExtendedPublicKeysMap
 import com.tangem.tap.DELAY_SDK_DIALOG_CLOSE
-import com.tangem.tap.assetReader
 import com.tangem.tap.common.analytics.events.ManageTokens
 import com.tangem.tap.common.extensions.dispatchDebugErrorNotification
 import com.tangem.tap.common.extensions.dispatchOnMain
@ -32,6 +31,7 @@ import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.domain.TapError
 import com.tangem.tap.domain.tokens.LoadAvailableCoinsService
 import com.tangem.tap.features.wallet.models.Currency
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
@ -85,7 +85,7 @@ class TokensMiddleware {
        val loadCoinsService = LoadAvailableCoinsService(
            tangemTechApi = store.state.domainNetworks.tangemTechService.api,
            dispatchers = AppCoroutineDispatcherProvider(),
-            assetReader = assetReader,
+            assetReader = store.state.daggerGraphState.get(DaggerGraphState::assetReader),
        )

        scope.launch {
@ -264,14 +264,10 @@ class TokensMiddleware {
        val toDerive = bothCandidates.filterNot { alreadyDerivedPaths.contains(it) }
        if (toDerive.isEmpty()) return null

-        return DerivationData(
-            derivations = mapKeyOfWalletPublicKey to toDerive,
-        )
+        return DerivationData(derivations = mapKeyOfWalletPublicKey to toDerive)
    }

-    private class DerivationData(
-        val derivations: Pair<ByteArrayKey, List<DerivationPath>>,
-    )
+    private class DerivationData(val derivations: Pair<ByteArrayKey, List<DerivationPath>>)

    private fun submitAdd(scanResponse: ScanResponse, currencyList: List<Currency>) {
        val selectedUserWallet = userWalletsListManager.selectedUserWalletSync.guard {
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WalletMiddleware.kt
@ -6,6 +6,7 @@ import com.tangem.blockchain.common.AmountType
 import com.tangem.common.CompletionResult
 import com.tangem.common.extensions.guard
 import com.tangem.core.analytics.Analytics
+import com.tangem.datasource.connection.NetworkConnectionManager
 import com.tangem.tap.common.analytics.converters.BasicEventsPreChecker
 import com.tangem.tap.common.analytics.converters.BasicEventsSourceData
 import com.tangem.tap.common.analytics.events.AnalyticsParam
@ -37,15 +38,13 @@ import com.tangem.tap.features.wallet.redux.WalletData
 import com.tangem.tap.features.wallet.redux.WalletState
 import com.tangem.tap.features.wallet.redux.WalletStore
 import com.tangem.tap.features.wallet.redux.reducers.findSelectedCurrency
-import com.tangem.tap.network.NetworkConnectivity
-import com.tangem.tap.network.NetworkStateChanged
 import com.tangem.tap.preferencesStorage
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.tap.tangemSdkManager
 import com.tangem.tap.totalFiatBalanceCalculator
 import com.tangem.tap.userWalletsListManager
-import com.tangem.tap.userWalletsListManagerSafe
 import com.tangem.tap.walletStoresManager
 import com.tangem.wallet.R
 import kotlinx.coroutines.Dispatchers
@ -72,6 +71,9 @@ class WalletMiddleware {
        )
    }

+    private val networkConnectionManager: NetworkConnectionManager
+        get() = store.state.daggerGraphState.get(DaggerGraphState::networkConnectionManager)
+
    val walletMiddleware: Middleware<AppState> = { _, state ->
        { next ->
            { action ->
@ -135,16 +137,6 @@ class WalletMiddleware {
                    )
                }
            }
-            is NetworkStateChanged -> {
-                store.dispatch(WalletAction.Warnings.CheckHashesCount.CheckHashesCountOnline)
-                if (!action.isOnline) return
-
-                val selectedUserWallet = userWalletsListManagerSafe?.selectedUserWalletSync.guard {
-                    Timber.e("Unable to proceed with changed network state, no user wallet selected")
-                    return
-                }
-                scope.launch { globalState.tapWalletManager.loadData(selectedUserWallet, refresh = true) }
-            }
            is WalletAction.CopyAddress -> {
                Analytics.send(Token.Receive.ButtonCopyAddress())
                action.context.copyToClipboard(action.address)
@ -159,7 +151,7 @@ class WalletMiddleware {
                store.dispatchOpenUrl(action.exploreUrl)
            }
            is WalletAction.Send -> {
-                if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) {
+                if (!networkConnectionManager.isOnline) {
                    store.dispatchErrorNotification(TapError.NoInternetConnection)
                    return
                }
--- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WarningsMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/WarningsMiddleware.kt
@ -2,29 +2,26 @@ package com.tangem.tap.features.wallet.redux.middlewares

 import com.tangem.blockchain.common.BlockchainSdkError
 import com.tangem.blockchain.common.SignatureCountValidator
-import com.tangem.blockchain.common.Wallet
 import com.tangem.blockchain.extensions.SimpleResult
 import com.tangem.common.card.FirmwareVersion
 import com.tangem.domain.common.CardDTO
 import com.tangem.domain.common.ScanResponse
 import com.tangem.domain.common.TapWorkarounds.isTestCard
 import com.tangem.tap.common.extensions.dispatchOnMain
-import com.tangem.tap.common.extensions.isGreaterThan
 import com.tangem.tap.common.redux.global.GlobalState
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessage
 import com.tangem.tap.domain.configurable.warningMessage.WarningMessagesManager
 import com.tangem.tap.domain.extensions.hasSignedHashes
 import com.tangem.tap.features.demo.isDemoCard
 import com.tangem.tap.features.wallet.redux.WalletAction
-import com.tangem.tap.network.NetworkConnectivity
 import com.tangem.tap.preferencesStorage
+import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.wallet.R
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.math.BigDecimal

 class WarningsMiddleware {
    fun handle(action: WalletAction.Warnings, globalState: GlobalState?) {
@ -75,13 +72,6 @@ class WarningsMiddleware {
        }
    }

-    fun tryToShowAppRatingWarning(wallet: Wallet) {
-        val nonZeroWalletsCount = wallet.amounts.filter {
-            it.value.value?.isGreaterThan(BigDecimal.ZERO) ?: false
-        }.size
-        tryToShowAppRatingWarning(hasNonZeroWallets = nonZeroWalletsCount > 0)
-    }
-
    private fun showCardWarningsIfNeeded(globalState: GlobalState?) {
        globalState?.scanResponse?.let { scanResponse ->
            val card = scanResponse.card
@ -147,7 +137,9 @@ class WarningsMiddleware {

    private fun checkHashesCountOnline() {
        if (store.state.walletState.hashesCountVerified != false) return
-        if (!NetworkConnectivity.getInstance().isOnlineOrConnecting()) return
+
+        val networkConnectionManager = store.state.daggerGraphState.get(DaggerGraphState::networkConnectionManager)
+        if (!networkConnectionManager.isOnline) return

        val scanResponse = store.state.globalState.scanResponse
        val card = scanResponse?.card
--- a/app/src/main/java/com/tangem/tap/network/NetworkConnectivity.kt
+++ b/app/src/main/java/com/tangem/tap/network/NetworkConnectivity.kt
@ -1,71 +0,0 @@
-package com.tangem.tap.network
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import android.os.Build
-import org.rekotlin.Action
-import org.rekotlin.Store
-import java.lang.ref.WeakReference
-
-/**
-[REDACTED_AUTHOR]
- */
-@Deprecated("Use com.tangem.datasource.connection.NetworkConnectionManager")
-class NetworkConnectivity(
-    private val store: Store<*>,
-    context: Context,
-) {
-
-    private val wContext: WeakReference<Context> = WeakReference(context)
-
-    private val receiver = object : BroadcastReceiver() {
-        override fun onReceive(c: Context?, intent: Intent?) {
-            store.dispatch(NetworkStateChanged(isOnlineOrConnecting()))
-        }
-    }
-
-    init {
-        val intentFilter = IntentFilter()
-        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION)
-        wContext.get()?.registerReceiver(receiver, intentFilter)
-        store.dispatch(NetworkStateChanged(isOnlineOrConnecting()))
-    }
-
-    fun isOnlineOrConnecting(): Boolean {
-        val connectivityManager = getConnectivityManager() ?: return false
-
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
-            capabilities != null &&
-                (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) ||
-                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
-                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN) ||
-                    capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET))
-        } else {
-            val networkInfo = connectivityManager.activeNetworkInfo
-            networkInfo != null && networkInfo.isConnectedOrConnecting
-        }
-    }
-
-    private fun getConnectivityManager(): ConnectivityManager? {
-        return wContext.get()?.applicationContext
-            ?.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
-    }
-
-    companion object {
-        private lateinit var instance: NetworkConnectivity
-
-        fun createInstance(store: Store<*>, context: Context): NetworkConnectivity {
-            instance = NetworkConnectivity(store, context)
-            return instance
-        }
-
-        fun getInstance(): NetworkConnectivity = instance
-    }
-}
-
-data class NetworkStateChanged(val isOnline: Boolean) : Action
--- a/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphAction.kt
+++ b/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphAction.kt
@ -0,0 +1,16 @@
+package com.tangem.tap.proxy.redux
+
+import com.tangem.datasource.asset.AssetReader
+import com.tangem.datasource.connection.NetworkConnectionManager
+import com.tangem.features.tester.api.TesterRouter
+import org.rekotlin.Action
+
+sealed interface DaggerGraphAction : Action {
+
+    data class SetApplicationDependencies(
+        val assetReader: AssetReader,
+        val networkConnectionManager: NetworkConnectionManager,
+    ) : DaggerGraphAction
+
+    data class SetActivityDependencies(val testerRouter: TesterRouter) : DaggerGraphAction
+}
--- a/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphMiddleware.kt
@ -0,0 +1,12 @@
+package com.tangem.tap.proxy.redux
+
+import com.tangem.tap.common.redux.AppState
+import org.rekotlin.Middleware
+
+object DaggerGraphMiddleware {
+    val daggerGraphMiddleware: Middleware<AppState> = { _, _ ->
+        { next ->
+            { action -> next(action) }
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphReducer.kt
+++ b/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphReducer.kt
@ -0,0 +1,24 @@
+package com.tangem.tap.proxy.redux
+
+import com.tangem.tap.common.redux.AppState
+import org.rekotlin.Action
+
+object DaggerGraphReducer {
+    fun reduce(action: Action, state: AppState): DaggerGraphState {
+        if (action !is DaggerGraphAction) return state.daggerGraphState
+
+        return internalReduce(action, state)
+    }
+
+    private fun internalReduce(action: DaggerGraphAction, state: AppState): DaggerGraphState {
+        return when (action) {
+            is DaggerGraphAction.SetApplicationDependencies -> state.daggerGraphState.copy(
+                assetReader = action.assetReader,
+                networkConnectionManager = action.networkConnectionManager,
+            )
+            is DaggerGraphAction.SetActivityDependencies -> state.daggerGraphState.copy(
+                testerRouter = action.testerRouter,
+            )
+        }
+    }
+}
--- a/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphState.kt
+++ b/app/src/main/java/com/tangem/tap/proxy/redux/DaggerGraphState.kt
@ -0,0 +1,19 @@
+package com.tangem.tap.proxy.redux
+
+import com.tangem.datasource.asset.AssetReader
+import com.tangem.datasource.connection.NetworkConnectionManager
+import com.tangem.features.tester.api.TesterRouter
+import org.rekotlin.StateType
+
+data class DaggerGraphState(
+    val assetReader: AssetReader? = null,
+    val testerRouter: TesterRouter? = null,
+    val networkConnectionManager: NetworkConnectionManager? = null,
+) : StateType {
+
+    inline fun <reified T> get(getDependency: DaggerGraphState.() -> T?): T {
+        return requireNotNull(getDependency()) {
+            "${T::class.simpleName} isn't initialized "
+        }
+    }
+}