Updated on 2026-08-14

app/src/main/java/com/tangem/tap/common/analytics/api/AnalyticsHandlerBuilder.kt

@@ -3,15 +3,15 @@ package com.tangem.tap.common.analytics.api
 import android.app.Application
 import com.tangem.common.json.MoshiJsonConverter
 import com.tangem.core.analytics.api.AnalyticsHandler
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.domain.common.AnalyticsHandlersLogConfig
-import com.tangem.datasource.config.models.Config
 
 interface AnalyticsHandlerBuilder {
     fun build(data: Data): AnalyticsHandler?
 
     data class Data(
         val application: Application,
-        val config: Config,
+        val config: EnvironmentConfig,
         val isDebug: Boolean,
         val logConfig: AnalyticsHandlersLogConfig,
         val jsonConverter: MoshiJsonConverter,

app/src/main/java/com/tangem/tap/common/analytics/events/ManageTokens.kt

@@ -1,91 +0,0 @@
-package com.tangem.tap.common.analytics.events
-
-import com.tangem.blockchainsdk.utils.toNetworkId
-import com.tangem.core.analytics.models.AnalyticsEvent
-import com.tangem.domain.features.addCustomToken.CustomCurrency
-import com.tangem.tap.common.extensions.filterNotNull
-
-/**
-[REDACTED_AUTHOR]
- */
-sealed class ManageTokens(
-    event: String,
-    params: Map<String, String> = mapOf(),
-) : AnalyticsEvent("Manage Tokens", event, params) {
-
-    class ScreenOpened : ManageTokens("Manage Tokens Screen Opened")
-    class TokenSearched : ManageTokens("Token Searched")
-
-    class TokenSwitcherChanged(
-        type: AnalyticsParam.CurrencyType,
-        state: AnalyticsParam.OnOffState,
-    ) : ManageTokens(
-        "Token Switcher Changed",
-        params = mapOf(
-            "Token" to type.value,
-            "State" to state.value,
-        ),
-    )
-
-    class ButtonSaveChanges : ManageTokens("Button - Save Changes")
-    class ButtonCustomToken : ManageTokens("Button - Custom Token")
-
-    sealed class CustomToken(
-        event: String,
-        params: Map<String, String> = mapOf(),
-    ) : ManageTokens(event, params) {
-
-        object ScreenOpened : ManageTokens(event = "Custom Token Screen Opened")
-
-        // TODO("Get rid of strong binding (CustomCurrency)
-        open class TokenWasAdded(customCurrency: CustomCurrency) : ManageTokens(
-            event = "Custom Token Was Added",
-            params = convertToParam(customCurrency),
-        ) {
-
-            data class Token(
-                val symbol: String,
-                val derivationPath: String?,
-                val blockchain: com.tangem.blockchain.common.Blockchain,
-                val contractAddress: String,
-            ) : ManageTokens(
-                event = "Custom Token Was Added",
-                params = mapOf(
-                    "Token" to symbol,
-                    "Derivation Path" to derivationPath,
-                    "Network Id" to blockchain.currency,
-                    "Contract Address" to contractAddress,
-                ).filterNotNull(),
-            )
-
-            data class Blockchain(
-                val derivationPath: String?,
-                val blockchain: com.tangem.blockchain.common.Blockchain,
-            ) : ManageTokens(
-                event = "Custom Token Was Added",
-                params = mapOf(
-                    "Token" to blockchain.currency,
-                    "Derivation Path" to derivationPath,
-                ).filterNotNull(),
-            )
-
-            companion object {
-                private fun convertToParam(customCurrency: CustomCurrency): Map<String, String> = with(customCurrency) {
-                    return when (this) {
-                        is CustomCurrency.CustomBlockchain -> mapOf(
-                            "Token" to network.currency,
-                            "Derivation Path" to derivationPath?.rawPath,
-                        ).filterNotNull()
-
-                        is CustomCurrency.CustomToken -> mapOf(
-                            "Token" to token.symbol,
-                            "Derivation Path" to derivationPath?.rawPath,
-                            "Network Id" to network.toNetworkId(),
-                            "Contract Address" to token.contractAddress,
-                        ).filterNotNull()
-                    }
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/tangem/tap/common/analytics/events/Settings.kt

@@ -1,7 +1,6 @@
 package com.tangem.tap.common.analytics.events
 
 import com.tangem.core.analytics.models.AnalyticsEvent
-import com.tangem.tap.features.details.ui.details.SocialNetwork
 
 /**
 [REDACTED_AUTHOR]
@@ -14,20 +13,8 @@ sealed class Settings(
 ) : AnalyticsEvent(category, event, params, error) {
 
     class ScreenOpened : Settings(event = "Settings Screen Opened")
-    class ButtonChat : Settings(event = "Button - Chat")
-    class ButtonSendFeedback : Settings(event = "Button - Send Feedback")
     class ButtonStartWalletConnectSession : Settings(event = "Button - Start Wallet Connect Session")
     class ButtonStopWalletConnectSession : Settings(event = "Button - Stop Wallet Connect Session")
-    class ButtonCardSettings : Settings(event = "Button - Card Settings")
-    class ButtonAppSettings : Settings(event = "Button - App Settings")
-    class ButtonCreateBackup : Settings(event = "Button - Create Backup")
-    class ButtonWalletConnect : Settings(event = "Button - Wallet Connect")
-    object ScanNewCard : Settings(event = "Button - Scan New Card")
-
-    class ButtonSocialNetwork(network: SocialNetwork) : Settings(
-        event = "Button - Social Network",
-        params = mapOf("Network" to network.id),
-    )
 
     sealed class CardSettings(
         event: String,
@@ -63,8 +50,6 @@ sealed class Settings(
             error = error,
         )
 
-        class AccessCodeRecoveryButton : CardSettings("Button - Access Code Recovery")
-
         class AccessCodeRecoveryChanged(status: AnalyticsParam.AccessCodeRecoveryStatus) : CardSettings(
             event = "Access Code Recovery Changed",
             params = mapOf(status.key to status.value),

app/src/main/java/com/tangem/tap/common/extensions/Specific.kt

@@ -20,8 +20,4 @@ fun BigDecimal.toFormattedString(
     df.isGroupingUsed = true
     df.roundingMode = roundingMode
     return df.format(this)
-}
-
-fun BigDecimal.stripZeroPlainString(): String = this.stripTrailingZeros().toPlainString()
-
-fun BigDecimal.isPositive(): Boolean = this.signum() == 1
+}

app/src/main/java/com/tangem/tap/common/feedback/AdditionalFeedbackInfo.kt

@@ -1,147 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import android.os.Build
-import com.tangem.blockchain.common.*
-import com.tangem.blockchain.common.address.Address
-import com.tangem.crypto.NetworkType
-import com.tangem.domain.models.scan.CardDTO
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.wallets.builder.UserWalletIdBuilder
-import com.tangem.tap.common.extensions.stripZeroPlainString
-import java.util.concurrent.CopyOnWriteArrayList
-
-class AdditionalFeedbackInfo {
-
-    class EmailWalletInfo(
-        val blockchain: Blockchain = Blockchain.Unknown,
-        val derivationPath: String = "",
-        val outputsCount: String? = null,
-        val host: String = "",
-        val addresses: String = "",
-        val explorerLink: String = "",
-        val tokens: List<EmailTokenInfo> = emptyList(),
-    )
-
-    class EmailTokenInfo(
-        val id: String?,
-        val name: String,
-        val contractAddress: String,
-    )
-
-    var appVersion: String = ""
-
-    // card
-    var cardId: String = ""
-    var cardFirmwareVersion: String = ""
-    var cardIssuer: String = ""
-    var cardBlockchain: String = ""
-    var userWalletId: String = ""
-    var extendedPublicKey: String = ""
-
-    // wallets
-    val walletsInfo = CopyOnWriteArrayList<EmailWalletInfo>()
-    var onSendErrorWalletInfo: EmailWalletInfo? = null
-        private set
-    var signedHashesCount: String = ""
-        private set
-
-    // device
-    var phoneModel: String = Build.MODEL
-        private set
-    var osVersion: String = Build.VERSION.SDK_INT.toString()
-        private set
-
-    // send error
-    var destinationAddress: String = ""
-        private set
-    var amount: String = ""
-        private set
-    var fee: String = ""
-        private set
-    var token: String = ""
-        private set
-
-    private val Address.name: String
-        get() = type.javaClass.simpleName
-
-    @Deprecated("Don't use it directly")
-    fun setCardInfo(data: ScanResponse) {
-        cardId = data.card.cardId
-        cardBlockchain = data.walletData?.blockchain ?: ""
-        cardFirmwareVersion = data.card.firmwareVersion.stringValue
-        cardIssuer = data.card.issuer.name
-        signedHashesCount = formatSignedHashes(data.card.wallets)
-        userWalletId = UserWalletIdBuilder.scanResponse(data).build()?.stringValue ?: ""
-        extendedPublicKey = runCatching {
-            data.card.wallets.firstOrNull { it.extendedPublicKey != null }
-                ?.extendedPublicKey
-                ?.serialize(networkType = NetworkType.Mainnet).orEmpty()
-        }.getOrDefault("couldn't retrieve extended public key")
-    }
-
-    @Deprecated("Don't use it directly")
-    fun setWalletsInfo(walletManagers: List<WalletManager>) {
-        synchronized(walletsInfo) {
-            walletsInfo.clear()
-            walletsInfo.addAll(elements = walletManagers.map(::createEmailWalletInfo))
-        }
-    }
-
-    fun updateOnSendError(
-        walletManager: WalletManager,
-        amountToSend: Amount?,
-        feeAmount: Amount?,
-        destinationAddress: String?,
-    ) {
-        onSendErrorWalletInfo = createEmailWalletInfo(walletManager)
-        this.destinationAddress = destinationAddress ?: "0"
-        amount = amountToSend?.value?.stripZeroPlainString() ?: "0"
-        fee = if (feeAmount != null) {
-            feeAmount.value?.stripZeroPlainString() ?: "0"
-        } else {
-            "Unable to receive"
-        }
-        token = if (amountToSend?.type is AmountType.Token) amountToSend.currencySymbol else ""
-    }
-
-    private fun createEmailWalletInfo(walletManager: WalletManager): EmailWalletInfo {
-        return EmailWalletInfo(
-            blockchain = walletManager.wallet.blockchain,
-            derivationPath = walletManager.wallet.publicKey.derivationPath?.rawPath ?: "",
-            outputsCount = walletManager.outputsCount?.toString(),
-            host = walletManager.currentHost,
-            addresses = formatAddresses(walletManager.wallet),
-            explorerLink = formatExploreUrls(walletManager.wallet),
-            tokens = walletManager.cardTokens.map { token ->
-                EmailTokenInfo(token.id, token.name, token.contractAddress)
-            },
-        )
-    }
-
-    private fun formatSignedHashes(wallets: List<CardDTO.Wallet>): String {
-        return wallets.joinToString("\n") { "Signed hashes: ${it.curve.curve} - ${it.totalSignedHashes}" }
-    }
-
-    private fun formatAddresses(wallet: Wallet): String {
-        return wallet.formatAddressWith("Multiple address:") {
-            "${it.name} - ${it.value}"
-        }
-    }
-
-    private fun formatExploreUrls(wallet: Wallet): String {
-        return wallet.formatAddressWith("Multiple explorers links:") {
-            "${it.name} - ${wallet.getExploreUrl(it.value)}"
-        }
-    }
-
-    @Suppress("MagicNumber")
-    private fun Wallet.formatAddressWith(with: String, mapAddress: (Address) -> String): String {
-        return if (addresses.size == 1) {
-            getExploreUrl(address)
-        } else {
-            addresses.map { mapAddress(it) }.toMutableList()
-                .apply { add(0, with) }
-                .joinToString("\n")
-        }
-    }
-}

app/src/main/java/com/tangem/tap/common/feedback/DefaultFeedbackManagerFeatureToggles.kt

@@ -1,12 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import com.tangem.core.featuretoggle.manager.FeatureTogglesManager
-import com.tangem.domain.feedback.FeedbackManagerFeatureToggles
-
-internal class DefaultFeedbackManagerFeatureToggles(
-    private val featureTogglesManager: FeatureTogglesManager,
-) : FeedbackManagerFeatureToggles {
-
-    override val isLocalLogsEnabled: Boolean
-        get() = featureTogglesManager.isFeatureEnabled(name = "LOCAL_USER_LOGS_ENABLED")
-}

app/src/main/java/com/tangem/tap/common/feedback/FeedbackData.kt

@@ -1,105 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import android.content.Context
-import com.tangem.domain.common.TapWorkarounds
-import com.tangem.tap.common.extensions.breakLine
-import com.tangem.wallet.R
-
-interface FeedbackData {
-    val subjectResId: Int
-    val mainMessageResId: Int
-
-    fun getDataCollectionMessageResId(): Int = R.string.feedback_data_collection_message
-
-    fun prepare(infoHolder: AdditionalFeedbackInfo) {}
-
-    fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String
-
-    @Suppress("MagicNumber")
-    fun joinTogether(context: Context, infoHolder: AdditionalFeedbackInfo): String {
-        return StringBuilder().apply {
-            append(context.getString(mainMessageResId))
-            breakLine(3)
-            append(context.getString(getDataCollectionMessageResId()))
-            breakLine()
-            append(createOptionalMessage(infoHolder))
-        }.toString()
-    }
-}
-
-class RateCanBeBetterEmail : FeedbackData {
-    override val subjectResId: Int = R.string.feedback_subject_rate_negative
-    override val mainMessageResId: Int = R.string.feedback_preface_rate_negative
-
-    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
-        .appendCardInfo()
-        .breakLine()
-        .appendPhoneInfo()
-        .build()
-}
-
-class ScanFailsEmail : FeedbackData {
-
-    override val subjectResId: Int = R.string.feedback_subject_scan_failed
-    override val mainMessageResId: Int = R.string.feedback_preface_scan_failed
-
-    @Suppress("MagicNumber")
-    override fun joinTogether(context: Context, infoHolder: AdditionalFeedbackInfo): String = StringBuilder().apply {
-        append(context.getString(mainMessageResId))
-        breakLine(4)
-        append(createOptionalMessage(infoHolder))
-    }.toString()
-
-    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
-        .appendPhoneInfo()
-        .build()
-}
-
-class SendTransactionFailedEmail(
-    val error: String,
-) : FeedbackData {
-
-    override val subjectResId: Int = R.string.feedback_subject_tx_failed
-    override val mainMessageResId: Int = R.string.feedback_preface_tx_failed
-
-    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
-        .appendCardInfo()
-        .appendDelimiter()
-        .appendTxFailedBlockchainInfo(error)
-        .breakLine()
-        .appendPhoneInfo()
-        .build()
-}
-
-class FeedbackEmail : FeedbackData {
-    override val subjectResId: Int
-        get() = if (isS2CCard) R.string.feedback_subject_support else R.string.feedback_subject_support_tangem
-
-    override val mainMessageResId: Int = R.string.feedback_preface_support
-
-    private var isS2CCard = false
-
-    override fun prepare(infoHolder: AdditionalFeedbackInfo) {
-        isS2CCard = TapWorkarounds.isStart2CoinIssuer(infoHolder.cardIssuer)
-    }
-
-    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String = FeedbackDataBuilder(infoHolder)
-        .appendCardInfo()
-        .appendWalletsInfo()
-        .breakLine()
-        .appendPhoneInfo()
-        .build()
-}
-
-class SupportInfo : FeedbackData {
-    override val subjectResId: Int = R.string.details_chat
-    override val mainMessageResId: Int = R.string.details_chat
-
-    override fun createOptionalMessage(infoHolder: AdditionalFeedbackInfo): String {
-        return FeedbackDataBuilder(infoHolder)
-            .appendCardInfo()
-            .appendDelimiter()
-            .appendPhoneInfo()
-            .build()
-    }
-}

app/src/main/java/com/tangem/tap/common/feedback/FeedbackDataBuilder.kt

@@ -1,85 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import com.tangem.tap.common.extensions.breakLine
-
-class FeedbackDataBuilder(
-    private val infoHolder: AdditionalFeedbackInfo,
-) {
-    val builder = StringBuilder()
-
-    fun appendDelimiter(): FeedbackDataBuilder {
-        builder.appendDelimiter()
-        return this
-    }
-
-    fun breakLine(count: Int = 1): FeedbackDataBuilder {
-        builder.breakLine(count)
-        return this
-    }
-
-    fun appendCardInfo(): FeedbackDataBuilder {
-        builder.appendKeyValue("Card ID", infoHolder.cardId)
-        builder.appendKeyValue("Firmware version", infoHolder.cardFirmwareVersion)
-        builder.appendKeyValue("Card Blockchain", infoHolder.cardBlockchain)
-        builder.appendKeyValue("", infoHolder.signedHashesCount)
-        builder.appendKeyValue("User Wallet ID", infoHolder.userWalletId)
-        return this
-    }
-
-    fun appendWalletsInfo(): FeedbackDataBuilder {
-        infoHolder.walletsInfo.forEach { walletInfo ->
-            builder.appendDelimiter()
-            builder.appendKeyValue("Blockchain", walletInfo.blockchain.fullName)
-            builder.appendKeyValue("Derivation path", walletInfo.derivationPath)
-            builder.appendKeyValue("Outputs count", walletInfo.outputsCount)
-
-            if (walletInfo.tokens.isNotEmpty()) {
-                builder.append("Tokens:")
-                breakLine()
-                walletInfo.tokens.forEach { token ->
-                    builder.appendKeyValue("ID", token.id ?: "[custom token]")
-                    builder.appendKeyValue("Name", token.name)
-                    builder.appendKeyValue("Contract address", token.contractAddress)
-                }
-            }
-
-            builder.appendKeyValue("Host", walletInfo.host)
-            builder.appendKeyValue("Wallet address", walletInfo.addresses)
-            builder.appendKeyValue("Explorer link", walletInfo.explorerLink)
-        }
-
-        return this
-    }
-
-    fun appendTxFailedBlockchainInfo(error: String): FeedbackDataBuilder {
-        val walletInfo = infoHolder.onSendErrorWalletInfo ?: AdditionalFeedbackInfo.EmailWalletInfo()
-        builder.appendKeyValue("Blockchain", walletInfo.blockchain.fullName)
-        builder.appendKeyValue("Derivation path", walletInfo.derivationPath)
-        builder.appendKeyValue("Host", walletInfo.host)
-        builder.appendKeyValue("Token", infoHolder.token)
-        builder.appendKeyValue("Error", error)
-        builder.appendDelimiter()
-        builder.appendKeyValue("Source address", walletInfo.addresses)
-        builder.appendKeyValue("Destination address", infoHolder.destinationAddress)
-        builder.appendKeyValue("Amount", infoHolder.amount)
-        builder.appendKeyValue("Fee", infoHolder.fee)
-        return this
-    }
-
-    fun appendPhoneInfo(): FeedbackDataBuilder {
-        builder.appendKeyValue("Phone model", infoHolder.phoneModel)
-        builder.appendKeyValue("OS version", infoHolder.osVersion)
-        builder.appendKeyValue("App version", infoHolder.appVersion)
-        return this
-    }
-
-    fun build(): String = builder.toString()
-}
-
-private fun StringBuilder.appendKeyValue(key: String, value: String?): StringBuilder = when {
-    value.isNullOrBlank() -> this
-    key.isBlank() -> this.append("$value\n")
-    else -> this.append("$key: $value\n")
-}
-
-private fun StringBuilder.appendDelimiter(): StringBuilder = append("----------\n")

app/src/main/java/com/tangem/tap/common/feedback/LegacyFeedbackManager.kt

@@ -1,136 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import android.content.Context
-import com.tangem.core.navigation.email.EmailSender
-import com.tangem.domain.common.TapWorkarounds
-import com.tangem.domain.feedback.FeedbackManagerFeatureToggles
-import com.tangem.domain.feedback.GetFeedbackEmailUseCase
-import com.tangem.domain.feedback.models.FeedbackEmailType
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.tap.common.extensions.inject
-import com.tangem.tap.common.extensions.sendEmail
-import com.tangem.tap.common.log.TangemLogCollector
-import com.tangem.tap.foregroundActivityObserver
-import com.tangem.tap.proxy.redux.DaggerGraphState
-import com.tangem.tap.scope
-import com.tangem.tap.store
-import com.tangem.tap.withForegroundActivity
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import java.io.File
-import java.io.FileWriter
-import java.io.StringWriter
-
-/**
-[REDACTED_AUTHOR]
- */
-class LegacyFeedbackManager(
-    val infoHolder: AdditionalFeedbackInfo,
-    private val logCollector: TangemLogCollector,
-    private val feedbackManagerFeatureToggles: FeedbackManagerFeatureToggles,
-    private val getFeedbackEmailUseCase: GetFeedbackEmailUseCase,
-) {
-
-    private var sessionLogsFile: File? = null
-
-    fun sendEmail(feedbackData: FeedbackData, scanResponse: ScanResponse?) {
-        if (feedbackManagerFeatureToggles.isLocalLogsEnabled) {
-            scope.launch {
-                val getCardInfo = suspend {
-                    scanResponse ?: error("ScanResponse must be not null")
-                    store.inject(DaggerGraphState::getCardInfoUseCase).invoke(scanResponse).getOrNull()
-                        ?: error("CardInfo must be not null")
-                }
-
-                val email = getFeedbackEmailUseCase(
-                    type = when (feedbackData) {
-                        is FeedbackEmail -> FeedbackEmailType.DirectUserRequest(cardInfo = getCardInfo())
-                        is RateCanBeBetterEmail -> FeedbackEmailType.RateCanBeBetter(cardInfo = getCardInfo())
-                        is ScanFailsEmail -> FeedbackEmailType.ScanningProblem
-                        is SendTransactionFailedEmail -> {
-                            FeedbackEmailType.TransactionSendingProblem(cardInfo = getCardInfo())
-                        }
-                        else -> FeedbackEmailType.DirectUserRequest(cardInfo = getCardInfo())
-                    },
-                )
-
-                store.inject(DaggerGraphState::emailSender).send(
-                    email = EmailSender.Email(
-                        address = email.address,
-                        subject = email.subject,
-                        message = email.message,
-                        attachment = email.file,
-                    ),
-                )
-            }
-        } else {
-            feedbackData.prepare(infoHolder)
-            foregroundActivityObserver.withForegroundActivity { activity ->
-                activity.sendEmail(
-                    email = getSupportEmail(),
-                    subject = activity.getString(feedbackData.subjectResId),
-                    message = feedbackData.joinTogether(activity, infoHolder),
-                    file = getLogFile(activity),
-                )
-            }
-        }
-    }
-
-    fun sendEmail(type: FeedbackEmailType) {
-        if (!feedbackManagerFeatureToggles.isLocalLogsEnabled) error("LOCAL_LOGS feature toggle must be enabled")
-
-        scope.launch {
-            val email = getFeedbackEmailUseCase(type = type)
-
-            store.inject(DaggerGraphState::emailSender).send(
-                email = EmailSender.Email(
-                    address = email.address,
-                    subject = email.subject,
-                    message = email.message,
-                    attachment = email.file,
-                ),
-            )
-        }
-    }
-
-    private fun getLogFile(context: Context): File? {
-        return try {
-            if (sessionLogsFile != null) {
-                return sessionLogsFile
-            }
-            val file = File(context.filesDir, LOGS_FILE)
-            file.delete()
-            file.createNewFile()
-
-            val stringWriter = StringWriter()
-            logCollector.getLogs().forEach { stringWriter.append(it) }
-            val fileWriter = FileWriter(file)
-            fileWriter.write(stringWriter.toString())
-            fileWriter.close()
-            logCollector.clearLogs()
-            if (file.exists()) {
-                sessionLogsFile = file
-                sessionLogsFile
-            } else {
-                null
-            }
-        } catch (ex: Exception) {
-            Timber.e(ex, "Can't create the logs file")
-            null
-        }
-    }
-
-    private fun getSupportEmail(): String {
-        return if (TapWorkarounds.isStart2CoinIssuer(infoHolder.cardIssuer)) {
-            S2C_SUPPORT_EMAIL
-        } else {
-            DEFAULT_SUPPORT_EMAIL
-        }
-    }
-
-    private companion object {
-        const val DEFAULT_SUPPORT_EMAIL = "support@tangem.com"
-        const val S2C_SUPPORT_EMAIL = "cardsupport@start2coin.com"
-        const val LOGS_FILE = "logs.txt"
-    }
-}

app/src/main/java/com/tangem/tap/common/feedback/ProxyFeedbackManager.kt

@@ -1,20 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import com.tangem.domain.feedback.FeedbackManager
-import com.tangem.domain.feedback.models.FeedbackEmailType
-import com.tangem.tap.store
-import timber.log.Timber
-
-internal class ProxyFeedbackManager : FeedbackManager {
-
-    override fun sendEmail(type: FeedbackEmailType) {
-        val manager = store.state.globalState.feedbackManager
-
-        if (manager == null) {
-            Timber.e("Feedback manager is not initialized")
-            return
-        }
-
-        manager.sendEmail(type)
-    }
-}

app/src/main/java/com/tangem/tap/common/log/TangemLogCollector.kt

@@ -1,31 +0,0 @@
-package com.tangem.tap.common.log
-
-import com.tangem.Log
-import com.tangem.LogFormat
-import com.tangem.TangemSdkLogger
-import java.text.SimpleDateFormat
-import java.util.*
-
-class TangemLogCollector(
-    private val levels: List<Log.Level>,
-    private val messageFormatter: LogFormat,
-) : TangemSdkLogger {
-
-    private val dateFormatter = SimpleDateFormat("HH:mm:ss.SSS")
-    private val logs = mutableListOf<String>()
-    private val mutex = Object()
-
-    override fun log(message: () -> String, level: Log.Level) {
-        if (!levels.contains(level)) return
-
-        synchronized(mutex) {
-            val formattedMessage = messageFormatter.format(message, level)
-            val logMessage = "${dateFormatter.format(Date())}: $formattedMessage"
-            logs.add("$logMessage\n")
-        }
-    }
-
-    fun getLogs(): List<String> = synchronized(mutex) { logs.toList() }
-
-    fun clearLogs() = synchronized(mutex) { logs.clear() }
-}

app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt

@@ -3,14 +3,12 @@ package com.tangem.tap.common.redux
 import com.tangem.tap.common.redux.global.globalReducer
 import com.tangem.tap.features.details.redux.DetailsReducer
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectReducer
-import com.tangem.tap.features.disclaimer.redux.DisclaimerReducer
 import com.tangem.tap.features.home.redux.HomeReducer
 import com.tangem.tap.features.onboarding.products.note.redux.OnboardingNoteReducer
 import com.tangem.tap.features.onboarding.products.otherCards.redux.OnboardingOtherCardsReducer
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsReducer
 import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletReducer
 import com.tangem.tap.features.saveWallet.redux.SaveWalletReducer
-import com.tangem.tap.features.tokens.legacy.redux.TokensReducer
 import com.tangem.tap.features.welcome.redux.WelcomeReducer
 import com.tangem.tap.proxy.AppStateHolder
 import com.tangem.tap.proxy.redux.DaggerGraphReducer
@@ -28,8 +26,6 @@ fun appReducer(action: Action, state: AppState?, appStateHolder: AppStateHolder)
         onboardingOtherCardsState = OnboardingOtherCardsReducer.reduce(action, state),
         twinCardsState = TwinCardsReducer.reduce(action, state),
         detailsState = DetailsReducer.reduce(action, state),
-        disclaimerState = DisclaimerReducer.reduce(action, state),
-        tokensState = TokensReducer.reduce(action, state),
         walletConnectState = WalletConnectReducer.reduce(action, state.walletConnectState),
         welcomeState = WelcomeReducer.reduce(action, state),
         saveWalletState = SaveWalletReducer.reduce(action, state),

app/src/main/java/com/tangem/tap/common/redux/AppState.kt

@@ -10,8 +10,6 @@ import com.tangem.tap.features.details.redux.DetailsMiddleware
 import com.tangem.tap.features.details.redux.DetailsState
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectMiddleware
 import com.tangem.tap.features.details.redux.walletconnect.WalletConnectState
-import com.tangem.tap.features.disclaimer.redux.DisclaimerMiddleware
-import com.tangem.tap.features.disclaimer.redux.DisclaimerState
 import com.tangem.tap.features.home.redux.HomeMiddleware
 import com.tangem.tap.features.home.redux.HomeState
 import com.tangem.tap.features.onboarding.products.note.redux.OnboardingNoteMiddleware
@@ -25,7 +23,6 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWallet
 import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletState
 import com.tangem.tap.features.saveWallet.redux.SaveWalletMiddleware
 import com.tangem.tap.features.saveWallet.redux.SaveWalletState
-import com.tangem.tap.features.tokens.legacy.redux.TokensState
 import com.tangem.tap.features.wallet.redux.middlewares.TradeCryptoMiddleware
 import com.tangem.tap.features.welcome.redux.WelcomeMiddleware
 import com.tangem.tap.features.welcome.redux.WelcomeState
@@ -43,8 +40,6 @@ data class AppState(
     val onboardingOtherCardsState: OnboardingOtherCardsState = OnboardingOtherCardsState(),
     val twinCardsState: TwinCardsState = TwinCardsState(),
     val detailsState: DetailsState = DetailsState(),
-    val disclaimerState: DisclaimerState = DisclaimerState(),
-    val tokensState: TokensState = TokensState(),
     val walletConnectState: WalletConnectState = WalletConnectState(),
     val welcomeState: WelcomeState = WelcomeState(),
     val saveWalletState: SaveWalletState = SaveWalletState(),
@@ -75,7 +70,6 @@ data class AppState(
                 OnboardingOtherCardsMiddleware.handler,
                 TwinCardsMiddleware.handler,
                 DetailsMiddleware().detailsMiddleware,
-                DisclaimerMiddleware().disclaimerMiddleware,
                 WalletConnectMiddleware().walletConnectMiddleware,
                 BackupMiddleware().backupMiddleware,
                 WelcomeMiddleware().middleware,

app/src/main/java/com/tangem/tap/common/redux/global/GlobalAction.kt

@@ -2,16 +2,15 @@ package com.tangem.tap.common.redux.global
 
 import com.tangem.common.CompletionResult
 import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.datasource.config.ConfigManager
+import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.redux.StateDialog
-import com.tangem.tap.common.feedback.FeedbackData
-import com.tangem.tap.common.feedback.LegacyFeedbackManager
 import com.tangem.tap.common.redux.DebugErrorAction
 import com.tangem.tap.common.redux.ErrorAction
 import com.tangem.tap.common.redux.NotificationAction
 import com.tangem.tap.domain.TapError
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupStartedSource
 import org.rekotlin.Action
 
 sealed class GlobalAction : Action {
@@ -31,7 +30,11 @@ sealed class GlobalAction : Action {
          * For resuming unfinished backup of standard Wallet see
          * BackupAction.CheckForUnfinishedBackup, GlobalAction.Onboarding.StartForUnfinishedBackup
          */
-        data class Start(val scanResponse: ScanResponse, val canSkipBackup: Boolean = true) : Onboarding()
+        data class Start(
+            val scanResponse: ScanResponse,
+            val source: BackupStartedSource,
+            val canSkipBackup: Boolean = true,
+        ) : Onboarding()
 
         /**
          * Initiate resuming of unfinished backup for standard Wallet.
@@ -71,10 +74,7 @@ sealed class GlobalAction : Action {
 
     data class IsSignWithRing(val isSignWithRing: Boolean) : GlobalAction()
 
-    data class SetConfigManager(val configManager: ConfigManager) : GlobalAction()
-    data class SetFeedbackManager(val feedbackManager: LegacyFeedbackManager) : GlobalAction()
-
-    data class SendEmail(val feedbackData: FeedbackData, val scanResponse: ScanResponse?) : GlobalAction()
+    data class SetConfigManager(val environmentConfigStorage: EnvironmentConfigStorage) : GlobalAction()
 
     object ExchangeManager : GlobalAction() {
         object Init : GlobalAction() {

app/src/main/java/com/tangem/tap/common/redux/global/GlobalMiddleware.kt

@@ -4,7 +4,7 @@ import com.tangem.common.CompletionResult
 import com.tangem.common.core.TangemSdkError
 import com.tangem.common.extensions.guard
 import com.tangem.core.analytics.models.AnalyticsParam
-import com.tangem.datasource.config.models.Config
+import com.tangem.datasource.local.config.environment.EnvironmentConfig
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.common.LogConfig
 import com.tangem.domain.models.scan.CardDTO
@@ -55,15 +55,9 @@ private fun handleAction(action: Action, appState: () -> AppState?) {
         is GlobalAction.RestoreAppCurrency -> {
             restoreAppCurrency()
         }
-        is GlobalAction.SendEmail -> {
-            store.state.globalState.feedbackManager?.sendEmail(
-                feedbackData = action.feedbackData,
-                scanResponse = action.scanResponse,
-            )
-        }
         is GlobalAction.ExchangeManager.Init -> {
             val appStateSafe = appState() ?: return
-            val config = appStateSafe.globalState.configManager?.config ?: return
+            val config = appStateSafe.globalState.environmentConfigStorage?.getConfigSync() ?: return
 
             scope.launch {
                 val scanResponseProvider: () -> ScanResponse? = {
@@ -92,21 +86,24 @@ private fun handleAction(action: Action, appState: () -> AppState?) {
             scope.launch { exchangeManager.update() }
         }
         is GlobalAction.FetchUserCountry -> {
-            scope.launch {
-                // TODO("After adding DI") get dependencies by DI
-                runCatching { store.state.featureRepositoryProvider.homeRepository.getUserCountryCode() }
-                    .onSuccess {
-                        store.dispatchOnMain(
-                            GlobalAction.FetchUserCountry.Success(countryCode = it.code.lowercase()),
-                        )
-                    }
-                    .onFailure {
-                        store.dispatchOnMain(
-                            GlobalAction.FetchUserCountry.Success(
-                                countryCode = Locale.getDefault().country.lowercase(),
-                            ),
-                        )
-                    }
+            val homeFeatureToggles = store.inject(DaggerGraphState::homeFeatureToggles)
+
+            if (!homeFeatureToggles.isMigrateUserCountryCodeEnabled) {
+                scope.launch {
+                    runCatching { store.state.featureRepositoryProvider.homeRepository.getUserCountryCode() }
+                        .onSuccess {
+                            store.dispatchOnMain(
+                                GlobalAction.FetchUserCountry.Success(countryCode = it.code.lowercase()),
+                            )
+                        }
+                        .onFailure {
+                            store.dispatchOnMain(
+                                GlobalAction.FetchUserCountry.Success(
+                                    countryCode = Locale.getDefault().country.lowercase(),
+                                ),
+                            )
+                        }
+                }
             }
         }
     }
@@ -143,21 +140,24 @@ private fun restoreAppCurrency() {
     }
 }
 
-private fun makeSellExchangeService(config: Config): ExchangeService {
+private fun makeSellExchangeService(environmentConfig: EnvironmentConfig): ExchangeService {
     return MoonPayService(
-        apiKey = config.moonPayApiKey,
-        secretKey = config.moonPayApiSecretKey,
+        apiKey = environmentConfig.moonPayApiKey,
+        secretKey = environmentConfig.moonPayApiSecretKey,
         logEnabled = LogConfig.network.moonPayService,
     )
 }
 
-private fun makeBuyExchangeService(config: Config): ExchangeService {
+private fun makeBuyExchangeService(environmentConfig: EnvironmentConfig): ExchangeService {
     return BuyExchangeService(
-        mercuryoService = makeMercuryoExchangeService(config),
+        mercuryoService = makeMercuryoExchangeService(environmentConfig),
     )
 }
 
-private fun makeMercuryoExchangeService(config: Config): MercuryoService {
-    val mercuryoEnvironment = MercuryoEnvironment.prod(config.mercuryoWidgetId, config.mercuryoSecret)
+private fun makeMercuryoExchangeService(environmentConfig: EnvironmentConfig): MercuryoService {
+    val mercuryoEnvironment = MercuryoEnvironment.prod(
+        environmentConfig.mercuryoWidgetId,
+        environmentConfig.mercuryoSecret,
+    )
     return MercuryoService(mercuryoEnvironment)
 }

app/src/main/java/com/tangem/tap/common/redux/global/GlobalReducer.kt

@@ -2,12 +2,9 @@ package com.tangem.tap.common.redux.global
 
 import com.tangem.domain.redux.domainStore
 import com.tangem.domain.redux.global.DomainGlobalAction
-import com.tangem.tap.common.extensions.dispatchOnMain
 import com.tangem.tap.common.redux.AppState
-import com.tangem.tap.features.home.redux.HomeAction
 import com.tangem.tap.features.onboarding.OnboardingManager
 import com.tangem.tap.proxy.AppStateHolder
-import com.tangem.tap.store
 import com.tangem.utils.extensions.replaceBy
 import org.rekotlin.Action
 
@@ -51,7 +48,7 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
             globalState.copy(appCurrency = action.appCurrency)
         }
         is GlobalAction.SetConfigManager -> {
-            globalState.copy(configManager = action.configManager)
+            globalState.copy(environmentConfigStorage = action.environmentConfigStorage)
         }
         is GlobalAction.UpdateWalletSignedHashes -> {
             val card = globalState.scanResponse?.card ?: return globalState
@@ -72,9 +69,6 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
             globalState.copy(scanResponse = globalState.scanResponse.copy(card = newCardInstance))
         }
         is GlobalAction.IsSignWithRing -> globalState.copy(isLastSignWithRing = action.isSignWithRing)
-        is GlobalAction.SetFeedbackManager -> {
-            globalState.copy(feedbackManager = action.feedbackManager)
-        }
         is GlobalAction.ShowDialog -> {
             globalState.copy(dialog = action.stateDialog)
         }
@@ -87,10 +81,7 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
         is GlobalAction.SetIfCardVerifiedOnline ->
             globalState.copy(cardVerifiedOnline = action.verified)
         is GlobalAction.FetchUserCountry.Success -> {
-            store.dispatchOnMain(HomeAction.UpdateCountryCode(action.countryCode))
-            globalState.copy(
-                userCountryCode = action.countryCode,
-            )
+            globalState.copy(userCountryCode = action.countryCode)
         }
         else -> globalState
     }

app/src/main/java/com/tangem/tap/common/redux/global/GlobalState.kt

@@ -1,11 +1,10 @@
 package com.tangem.tap.common.redux.global
 
-import com.tangem.datasource.config.ConfigManager
+import com.tangem.datasource.local.config.environment.EnvironmentConfigStorage
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.apptheme.model.AppThemeMode
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.redux.StateDialog
-import com.tangem.tap.common.feedback.LegacyFeedbackManager
 import com.tangem.tap.domain.TapWalletManager
 import com.tangem.tap.features.onboarding.OnboardingManager
 import com.tangem.tap.network.exchangeServices.CurrencyExchangeManager
@@ -17,12 +16,12 @@ data class GlobalState(
     val onboardingState: OnboardingState = OnboardingState(),
     val cardVerifiedOnline: Boolean = false,
     val tapWalletManager: TapWalletManager = TapWalletManager(),
-    val configManager: ConfigManager? = null,
-    val feedbackManager: LegacyFeedbackManager? = null,
+    val environmentConfigStorage: EnvironmentConfigStorage? = null,
     val appCurrency: AppCurrency = AppCurrency.Default,
     val scanCardFailsCounter: Int = 0,
     val dialog: StateDialog? = null,
     val exchangeManager: CurrencyExchangeManager = CurrencyExchangeManager.dummy(),
+    @Deprecated("Use GetUserCountryCodeUseCase instead")
     val userCountryCode: String? = null,
     val appThemeMode: AppThemeMode = AppThemeMode.DEFAULT,
     val isLastSignWithRing: Boolean = false,

app/src/main/java/com/tangem/tap/common/redux/legacy/LegacyMiddleware.kt

@@ -1,18 +1,12 @@
 package com.tangem.tap.common.redux.legacy
 
-import com.tangem.blockchain.common.AmountType
-import com.tangem.domain.feedback.models.BlockchainErrorInfo
 import com.tangem.domain.redux.LegacyAction
-import com.tangem.domain.utils.convertToSdkAmount
 import com.tangem.tap.common.extensions.dispatchWithMain
 import com.tangem.tap.common.extensions.inject
-import com.tangem.tap.common.extensions.stripZeroPlainString
-import com.tangem.tap.common.feedback.FeedbackEmail
-import com.tangem.tap.common.feedback.RateCanBeBetterEmail
-import com.tangem.tap.common.feedback.SendTransactionFailedEmail
 import com.tangem.tap.common.redux.AppState
 import com.tangem.tap.common.redux.global.GlobalAction
 import com.tangem.tap.features.details.redux.DetailsAction
+import com.tangem.tap.features.onboarding.products.wallet.redux.BackupStartedSource
 import com.tangem.tap.proxy.redux.DaggerGraphState
 import com.tangem.tap.scope
 import com.tangem.tap.store
@@ -23,7 +17,6 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.launch
 import org.rekotlin.Middleware
 
 internal object LegacyMiddleware {
@@ -33,68 +26,14 @@ internal object LegacyMiddleware {
         { next ->
             { action ->
                 when (action) {
-                    is LegacyAction.SendEmailRateCanBeBetter -> {
-                        store.state.globalState.feedbackManager?.sendEmail(
-                            feedbackData = RateCanBeBetterEmail(),
-                            scanResponse = action.scanResponse,
-                        )
-                    }
-                    is LegacyAction.SendEmailSupport -> {
-                        store.state.globalState.feedbackManager?.sendEmail(
-                            feedbackData = FeedbackEmail(),
-                            scanResponse = action.scanResponse,
-                        )
-                    }
                     is LegacyAction.StartOnboardingProcess -> {
                         store.dispatch(
-                            GlobalAction.Onboarding.Start(action.scanResponse, canSkipBackup = action.canSkipBackup),
-                        )
-                    }
-                    is LegacyAction.SendEmailTransactionFailed -> {
-                        if (store.inject(DaggerGraphState::feedbackManagerFeatureToggles).isLocalLogsEnabled) {
-
-                            val amount = action.amount?.convertToSdkAmount(action.cryptoCurrency)
-                            store.inject(DaggerGraphState::saveBlockchainErrorUseCase).invoke(
-                                error = BlockchainErrorInfo(
-                                    errorMessage = action.errorMessage,
-                                    blockchainId = action.cryptoCurrency.network.id.value,
-                                    derivationPath = action.cryptoCurrency.network.derivationPath.value,
-                                    destinationAddress = action.destinationAddress.orEmpty(),
-                                    tokenSymbol = if (amount?.type is AmountType.Token) {
-                                        amount.currencySymbol
-                                    } else {
-                                        ""
-                                    },
-                                    amount = amount?.value?.stripZeroPlainString() ?: "unknown",
-                                    fee = action.fee?.convertToSdkAmount(action.cryptoCurrency)
-                                        ?.value?.stripZeroPlainString() ?: "unknown",
-                                ),
-                            )
-
-                            store.state.globalState.feedbackManager?.sendEmail(
-                                feedbackData = SendTransactionFailedEmail(action.errorMessage),
+                            GlobalAction.Onboarding.Start(
                                 scanResponse = action.scanResponse,
-                            )
-                        } else {
-                            scope.launch {
-                                store.inject(DaggerGraphState::walletManagersFacade)
-                                    .getOrCreateWalletManager(
-                                        userWalletId = action.userWalletId,
-                                        network = action.cryptoCurrency.network,
-                                    )?.let { walletManager ->
-                                        store.state.globalState.feedbackManager?.infoHolder?.updateOnSendError(
-                                            walletManager = walletManager,
-                                            amountToSend = action.amount?.convertToSdkAmount(action.cryptoCurrency),
-                                            feeAmount = action.fee?.convertToSdkAmount(action.cryptoCurrency),
-                                            destinationAddress = action.destinationAddress,
-                                        )
-                                    }
-                                store.state.globalState.feedbackManager?.sendEmail(
-                                    feedbackData = SendTransactionFailedEmail(action.errorMessage),
-                                    scanResponse = null,
-                                )
-                            }
-                        }
+                                source = BackupStartedSource.CreateBackup,
+                                canSkipBackup = action.canSkipBackup,
+                            ),
+                        )
                     }
                     is LegacyAction.PrepareDetailsScreen -> {
                         val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)

app/src/main/java/com/tangem/tap/common/ui/ScanFailsDialog.kt

@@ -8,16 +8,19 @@ import androidx.core.view.isVisible
 import com.tangem.core.analytics.Analytics
 import com.tangem.core.analytics.models.AnalyticsParam
 import com.tangem.core.analytics.models.Basic
+import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.redux.StateDialog
 import com.tangem.tap.common.analytics.events.ScanFailsDialogAnalytics
 import com.tangem.tap.common.extensions.dispatchDialogHide
 import com.tangem.tap.common.extensions.dispatchOpenUrl
-import com.tangem.tap.common.feedback.ScanFailsEmail
-import com.tangem.tap.common.redux.global.GlobalAction
+import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.features.home.LocaleRegionProvider
 import com.tangem.tap.features.home.RUSSIA_COUNTRY_CODE
+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.launch
 
 /**
 [REDACTED_AUTHOR]
@@ -65,7 +68,11 @@ internal object ScanFailsDialog {
             }
             customView.findViewById<TextView>(R.id.request_support_button)?.setOnClickListener {
                 Analytics.send(Basic.ButtonSupport(sourceAnalytics))
-                store.dispatch(GlobalAction.SendEmail(feedbackData = ScanFailsEmail(), scanResponse = null))
+
+                scope.launch {
+                    store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
+                        .invoke(type = FeedbackEmailType.ScanningProblem)
+                }
             }
             customView.findViewById<TextView>(R.id.cancel_button)?.setOnClickListener {
                 store.dispatchDialogHide()