Updated on 2026-08-14

app/src/main/java/com/tangem/tap/TangemApplication.kt

@@ -44,7 +44,6 @@ import com.tangem.tap.common.analytics.AnalyticsFactory
 import com.tangem.tap.common.analytics.api.AnalyticsHandlerBuilder
 import com.tangem.tap.common.analytics.handlers.amplitude.AmplitudeAnalyticsHandler
 import com.tangem.tap.common.analytics.handlers.firebase.FirebaseAnalyticsHandler
-import com.tangem.tap.common.feedback.LegacyFeedbackManager
 import com.tangem.tap.common.images.createCoilImageLoader
 import com.tangem.tap.common.log.TangemAppLoggerInitializer
 import com.tangem.tap.common.redux.AppState
@@ -288,7 +287,7 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
 
     private fun initWithConfigDependency(config: Config) {
         initAnalytics(this, config)
-        initFeedbackManager(store)
+        Log.addLogger(logger = tangemSdkLogger)
     }
 
     private fun initAnalytics(application: Application, config: Config) {
@@ -308,11 +307,4 @@ abstract class TangemApplication : Application(), ImageLoaderFactory {
         factory.build(Analytics, buildData)
         // ExceptionHandler.append(blockchainExceptionHandler) TODO: [REDACTED_JIRA]
     }
-
-    private fun initFeedbackManager(store: Store<AppState>) {
-        Log.addLogger(logger = tangemSdkLogger)
-
-        val feedbackManager = LegacyFeedbackManager(sendFeedbackEmailUseCase = sendFeedbackEmailUseCase)
-        store.dispatch(GlobalAction.SetFeedbackManager(feedbackManager))
-    }
 }

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

@@ -1,20 +0,0 @@
-package com.tangem.tap.common.feedback
-
-import com.tangem.domain.feedback.SendFeedbackEmailUseCase
-import com.tangem.domain.feedback.models.FeedbackEmailType
-import com.tangem.tap.scope
-import kotlinx.coroutines.launch
-
-/**
-[REDACTED_AUTHOR]
- */
-class LegacyFeedbackManager(
-    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
-) {
-
-    fun sendEmail(type: FeedbackEmailType) {
-        scope.launch {
-            sendFeedbackEmailUseCase(type = type)
-        }
-    }
-}

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/redux/global/GlobalAction.kt

@@ -6,7 +6,6 @@ import com.tangem.datasource.config.ConfigManager
 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.LegacyFeedbackManager
 import com.tangem.tap.common.redux.DebugErrorAction
 import com.tangem.tap.common.redux.ErrorAction
 import com.tangem.tap.common.redux.NotificationAction
@@ -69,7 +68,6 @@ sealed class GlobalAction : Action {
     ) : GlobalAction()
 
     data class SetConfigManager(val configManager: ConfigManager) : GlobalAction()
-    data class SetFeedbackManager(val feedbackManager: LegacyFeedbackManager) : GlobalAction()
 
     object ExchangeManager : GlobalAction() {
         object Init : GlobalAction() {

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

@@ -68,9 +68,6 @@ fun globalReducer(action: Action, state: AppState, appStateHolder: AppStateHolde
             )
             globalState.copy(scanResponse = globalState.scanResponse.copy(card = newCardInstance))
         }
-        is GlobalAction.SetFeedbackManager -> {
-            globalState.copy(feedbackManager = action.feedbackManager)
-        }
         is GlobalAction.ShowDialog -> {
             globalState.copy(dialog = action.stateDialog)
         }

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

@@ -5,7 +5,6 @@ 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
@@ -18,7 +17,6 @@ data class GlobalState(
     val cardVerifiedOnline: Boolean = false,
     val tapWalletManager: TapWalletManager = TapWalletManager(),
     val configManager: ConfigManager? = null,
-    val feedbackManager: LegacyFeedbackManager? = null,
     val appCurrency: AppCurrency = AppCurrency.Default,
     val scanCardFailsCounter: Int = 0,
     val dialog: StateDialog? = null,

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

@@ -1,12 +1,6 @@
 package com.tangem.tap.common.redux.legacy
 
-import com.tangem.blockchain.common.AmountType
-import com.tangem.domain.feedback.models.BlockchainErrorInfo
-import com.tangem.domain.feedback.models.CardInfo
-import com.tangem.domain.feedback.models.FeedbackEmailType
-import com.tangem.domain.models.scan.ScanResponse
 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.redux.AppState
@@ -17,7 +11,6 @@ import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.utils.coroutines.JobHolder
 import com.tangem.utils.coroutines.saveIn
-import com.tangem.utils.extensions.stripZeroPlainString
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flowOn
@@ -40,42 +33,6 @@ internal object LegacyMiddleware {
                             ),
                         )
                     }
-                    is LegacyAction.SendEmailRateCanBeBetter -> {
-                        store.state.globalState.feedbackManager?.sendEmail(
-                            type = FeedbackEmailType.RateCanBeBetter(cardInfo = getCardInfo(action.scanResponse)),
-                        )
-                    }
-                    is LegacyAction.SendEmailSupport -> {
-                        store.state.globalState.feedbackManager?.sendEmail(
-                            type = FeedbackEmailType.DirectUserRequest(cardInfo = getCardInfo(action.scanResponse)),
-                        )
-                    }
-                    is LegacyAction.SendEmailTransactionFailed -> {
-                        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(
-                            type = FeedbackEmailType.TransactionSendingProblem(
-                                cardInfo = getCardInfo(action.scanResponse),
-                            ),
-                        )
-                    }
                     is LegacyAction.PrepareDetailsScreen -> {
                         val userWalletsListManager = store.inject(DaggerGraphState::generalUserWalletsListManager)
                         val walletsRepository = store.inject(DaggerGraphState::walletsRepository)
@@ -99,10 +56,4 @@ internal object LegacyMiddleware {
             }
         }
     }
-
-    private fun getCardInfo(scanResponse: ScanResponse): CardInfo {
-        return store.inject(DaggerGraphState::getCardInfoUseCase).invoke(scanResponse)
-            .getOrNull()
-            ?: error("Card info not found")
-    }
 }

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

@@ -13,10 +13,14 @@ 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.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 +69,10 @@ internal object ScanFailsDialog {
             customView.findViewById<TextView>(R.id.request_support_button)?.setOnClickListener {
                 Analytics.send(Basic.ButtonSupport(sourceAnalytics))
 
-                store.state.globalState.feedbackManager?.sendEmail(type = FeedbackEmailType.ScanningProblem)
+                scope.launch {
+                    store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
+                        .invoke(type = FeedbackEmailType.ScanningProblem)
+                }
             }
             customView.findViewById<TextView>(R.id.cancel_button)?.setOnClickListener {
                 store.dispatchDialogHide()

app/src/main/java/com/tangem/tap/di/UtilsModule.kt

@@ -5,8 +5,6 @@ import com.tangem.core.navigation.finisher.AppFinisher
 import com.tangem.core.navigation.settings.SettingsManager
 import com.tangem.core.navigation.share.ShareManager
 import com.tangem.core.navigation.url.UrlOpener
-import com.tangem.domain.feedback.FeedbackManager
-import com.tangem.tap.common.feedback.ProxyFeedbackManager
 import com.tangem.tap.common.finisher.AndroidAppFinisher
 import com.tangem.tap.common.settings.IntentSettingsManager
 import com.tangem.tap.common.share.IntentShareManager
@@ -30,10 +28,6 @@ internal object UtilsModule {
     @Singleton
     fun provideUrlOpener(): UrlOpener = CustomTabsUrlOpener()
 
-    @Provides
-    @Singleton
-    fun provideFeedbackManager(): FeedbackManager = ProxyFeedbackManager()
-
     @Provides
     @Singleton
     fun provideAppFinisher(@ApplicationContext context: Context): AppFinisher = AndroidAppFinisher(context)

app/src/main/java/com/tangem/tap/features/onboarding/OnboardingMenuProvider.kt

@@ -11,9 +11,11 @@ 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.proxy.redux.DaggerGraphState
+import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.utils.Provider
 import com.tangem.wallet.R
+import kotlinx.coroutines.launch
 
 /**
 [REDACTED_AUTHOR]
@@ -33,7 +35,10 @@ class OnboardingMenuProvider(
             val cardInfo = store.inject(DaggerGraphState::getCardInfoUseCase).invoke(scanResponseProvider()).getOrNull()
                 ?: error("CardInfo must be not null")
 
-            store.state.globalState.feedbackManager?.sendEmail(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+            scope.launch {
+                store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
+                    .invoke(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+            }
 
             true
         }

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt

@@ -46,6 +46,7 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.*
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.AccessCodeDialog
 import com.tangem.tap.mainScope
 import com.tangem.tap.proxy.redux.DaggerGraphState
+import com.tangem.tap.scope
 import com.tangem.tap.store
 import com.tangem.utils.Provider
 import com.tangem.wallet.R
@@ -516,7 +517,10 @@ class OnboardingWalletFragment :
             val getCardInfoUseCase = store.inject(DaggerGraphState::getCardInfoUseCase)
             val cardInfo = requireNotNull(getCardInfoUseCase.invoke(scanResponse).getOrNull())
 
-            store.state.globalState.feedbackManager?.sendEmail(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+            scope.launch {
+                store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
+                    .invoke(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+            }
         },
         onOpenUriClick = { uri ->
             store.dispatchOpenUrl(uri.toString())

app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/WalletActivationErrorDialog.kt

@@ -11,8 +11,10 @@ import com.tangem.tap.common.extensions.dispatchDialogHide
 import com.tangem.tap.common.extensions.inject
 import com.tangem.tap.features.onboarding.OnboardingDialog
 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
 
 object WalletActivationErrorDialog {
 
@@ -31,7 +33,10 @@ object WalletActivationErrorDialog {
                 val cardInfo = store.inject(DaggerGraphState::getCardInfoUseCase).invoke(scanResponse).getOrNull()
                     ?: error("CardInfo must be not null")
 
-                store.state.globalState.feedbackManager?.sendEmail(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+                scope.launch {
+                    store.inject(DaggerGraphState::sendFeedbackEmailUseCase)
+                        .invoke(type = FeedbackEmailType.DirectUserRequest(cardInfo))
+                }
             }
             setOnDismissListener { store.dispatchDialogHide() }
             setCancelable(false)

domain/feedback/src/main/java/com/tangem/domain/feedback/FeedbackManager.kt

@@ -1,8 +0,0 @@
-package com.tangem.domain.feedback
-
-import com.tangem.domain.feedback.models.FeedbackEmailType
-
-interface FeedbackManager {
-
-    fun sendEmail(type: FeedbackEmailType)
-}

domain/legacy/src/main/java/com/tangem/domain/redux/LegacyAction.kt

@@ -1,17 +1,10 @@
 package com.tangem.domain.redux
 
 import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.tokens.model.CryptoCurrency
-import com.tangem.domain.wallets.models.UserWalletId
 import org.rekotlin.Action
-import java.math.BigDecimal
 
 sealed interface LegacyAction : Action {
 
-    data class SendEmailSupport(val scanResponse: ScanResponse) : LegacyAction
-
-    data class SendEmailRateCanBeBetter(val scanResponse: ScanResponse) : LegacyAction
-
     /**
      * Initiate an onboarding process.
      * For resuming unfinished backup of standard Wallet see
@@ -19,25 +12,5 @@ sealed interface LegacyAction : Action {
      */
     data class StartOnboardingProcess(val scanResponse: ScanResponse, val canSkipBackup: Boolean = true) : LegacyAction
 
-    /**
-     * Sending an email to support when sending transaction failed
-     *
-     * @param cryptoCurrency current currency
-     * @param userWalletId selected user wallet id
-     * @param amount sending amount
-     * @param fee spending fee
-     * @param destinationAddress recipient address
-     * @param errorMessage sending error
-     */
-    data class SendEmailTransactionFailed(
-        val cryptoCurrency: CryptoCurrency,
-        val userWalletId: UserWalletId,
-        val amount: BigDecimal?,
-        val fee: BigDecimal?,
-        val destinationAddress: String?,
-        val errorMessage: String,
-        val scanResponse: ScanResponse,
-    ) : LegacyAction
-
     data object PrepareDetailsScreen : LegacyAction
 }

features/details/impl/src/main/kotlin/com/tangem/features/details/model/DetailsModel.kt

@@ -7,6 +7,9 @@ import com.tangem.core.decompose.model.Model
 import com.tangem.core.decompose.model.ParamsContainer
 import com.tangem.core.decompose.navigation.Router
 import com.tangem.core.navigation.url.UrlOpener
+import com.tangem.domain.feedback.GetCardInfoUseCase
+import com.tangem.domain.feedback.SendFeedbackEmailUseCase
+import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.redux.LegacyAction
 import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.walletconnect.CheckIsWalletConnectAvailableUseCase
@@ -42,6 +45,8 @@ internal class DetailsModel @Inject constructor(
     paramsContainer: ParamsContainer,
     private val getSelectedWalletSyncUseCase: GetSelectedWalletSyncUseCase,
     private val appStateHolder: ReduxStateHolder,
+    private val getCardInfoUseCase: GetCardInfoUseCase,
+    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
     override val dispatchers: CoroutineDispatcherProvider,
 ) : Model() {
 
@@ -94,7 +99,9 @@ internal class DetailsModel @Inject constructor(
             val scanResponse = getSelectedWalletSyncUseCase().getOrNull()?.scanResponse
                 ?: error("Selected wallet is null")
 
-            appStateHolder.dispatch(LegacyAction.SendEmailSupport(scanResponse))
+            val cardInfo = getCardInfoUseCase(scanResponse).getOrNull() ?: return@launch
+
+            sendFeedbackEmailUseCase(type = FeedbackEmailType.DirectUserRequest(cardInfo = cardInfo))
         }
     }
 

features/send/impl/src/main/java/com/tangem/features/send/impl/presentation/viewmodel/SendViewModel.kt

@@ -6,6 +6,7 @@ import androidx.lifecycle.*
 import arrow.core.Either
 import arrow.core.getOrElse
 import arrow.core.left
+import com.tangem.blockchain.common.AmountType
 import com.tangem.blockchain.common.TransactionData
 import com.tangem.blockchain.common.transaction.TransactionFee
 import com.tangem.common.routing.AppRoute
@@ -18,11 +19,14 @@ import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
 import com.tangem.domain.common.util.cardTypesResolver
+import com.tangem.domain.feedback.GetCardInfoUseCase
+import com.tangem.domain.feedback.SaveBlockchainErrorUseCase
+import com.tangem.domain.feedback.SendFeedbackEmailUseCase
+import com.tangem.domain.feedback.models.BlockchainErrorInfo
+import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.qrscanning.models.SourceType
 import com.tangem.domain.qrscanning.usecases.ListenToQrScanningUseCase
 import com.tangem.domain.qrscanning.usecases.ParseQrCodeUseCase
-import com.tangem.domain.redux.LegacyAction
-import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.settings.IsSendTapHelpEnabledUseCase
 import com.tangem.domain.settings.NeverShowTapHelpUseCase
 import com.tangem.domain.tokens.*
@@ -55,6 +59,7 @@ import com.tangem.features.send.impl.presentation.state.recipient.RecipientSendF
 import com.tangem.lib.crypto.BlockchainUtils
 import com.tangem.utils.Provider
 import com.tangem.utils.coroutines.*
+import com.tangem.utils.extensions.stripZeroPlainString
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
@@ -82,7 +87,6 @@ internal class SendViewModel @Inject constructor(
     private val sendTransactionUseCase: SendTransactionUseCase,
     private val createTransactionUseCase: CreateTransactionUseCase,
     private val validateWalletAddressUseCase: ValidateWalletAddressUseCase,
-    private val reduxStateHolder: ReduxStateHolder,
     private val isAmountSubtractAvailableUseCase: IsAmountSubtractAvailableUseCase,
     private val getBalanceHidingSettingsUseCase: GetBalanceHidingSettingsUseCase,
     private val analyticsEventHandler: AnalyticsEventHandler,
@@ -96,6 +100,9 @@ internal class SendViewModel @Inject constructor(
     private val fetchPendingTransactionsUseCase: FetchPendingTransactionsUseCase,
     private val isUtxoConsolidationAvailableUseCase: IsUtxoConsolidationAvailableUseCase,
     private val validateWalletMemoUseCase: ValidateWalletMemoUseCase,
+    private val saveBlockchainErrorUseCase: SaveBlockchainErrorUseCase,
+    private val getCardInfoUseCase: GetCardInfoUseCase,
+    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
     @DelayedWork private val coroutineScope: CoroutineScope,
     validateTransactionUseCase: ValidateTransactionUseCase,
     getCurrencyCheckUseCase: GetCurrencyCheckUseCase,
@@ -521,17 +528,31 @@ internal class SendViewModel @Inject constructor(
         } else {
             null
         }
-        reduxStateHolder.dispatch(
-            LegacyAction.SendEmailTransactionFailed(
-                cryptoCurrency = cryptoCurrency,
-                userWalletId = userWalletId,
-                amount = receivingAmount,
-                fee = feeValue,
-                destinationAddress = recipient,
+
+        val amount = receivingAmount?.convertToSdkAmount(cryptoCurrency)
+
+        saveBlockchainErrorUseCase(
+            error = BlockchainErrorInfo(
                 errorMessage = errorMessage,
-                scanResponse = userWallet.scanResponse,
+                blockchainId = cryptoCurrency.network.id.value,
+                derivationPath = cryptoCurrency.network.derivationPath.value,
+                destinationAddress = recipient.orEmpty(),
+                tokenSymbol = if (amount?.type is AmountType.Token) {
+                    amount.currencySymbol
+                } else {
+                    ""
+                },
+                amount = amount?.value?.stripZeroPlainString() ?: "unknown",
+                fee = feeValue?.convertToSdkAmount(cryptoCurrency)
+                    ?.value?.stripZeroPlainString() ?: "unknown",
             ),
         )
+
+        val cardInfo = getCardInfoUseCase(userWallet.scanResponse).getOrNull() ?: return
+
+        viewModelScope.launch {
+            sendFeedbackEmailUseCase(type = FeedbackEmailType.TransactionSendingProblem(cardInfo = cardInfo))
+        }
     }
 
     override fun onTokenDetailsClick(currency: CryptoCurrency) = innerRouter.openTokenDetails(userWalletId, currency)

features/staking/impl/src/main/java/com/tangem/features/staking/impl/presentation/viewmodel/StakingViewModel.kt

@@ -18,9 +18,9 @@ import com.tangem.core.ui.haptic.VibratorHapticManager
 import com.tangem.domain.appcurrency.GetSelectedAppCurrencyUseCase
 import com.tangem.domain.appcurrency.model.AppCurrency
 import com.tangem.domain.balancehiding.GetBalanceHidingSettingsUseCase
-import com.tangem.domain.feedback.FeedbackManager
 import com.tangem.domain.feedback.GetCardInfoUseCase
 import com.tangem.domain.feedback.SaveBlockchainErrorUseCase
+import com.tangem.domain.feedback.SendFeedbackEmailUseCase
 import com.tangem.domain.feedback.models.BlockchainErrorInfo
 import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.staking.InvalidatePendingTransactionsUseCase
@@ -92,7 +92,6 @@ internal class StakingViewModel @Inject constructor(
     private val getAllowanceUseCase: GetAllowanceUseCase,
     private val isApproveNeededUseCase: IsApproveNeededUseCase,
     private val vibratorHapticManager: VibratorHapticManager,
-    private val feedbackManager: FeedbackManager,
     private val getCardInfoUseCase: GetCardInfoUseCase,
     private val saveBlockchainErrorUseCase: SaveBlockchainErrorUseCase,
     private val getBalanceNotEnoughForFeeWarningUseCase: GetBalanceNotEnoughForFeeWarningUseCase,
@@ -105,6 +104,7 @@ internal class StakingViewModel @Inject constructor(
     private val stakingFeeTransactionLoader: StakingFeeTransactionLoader.Factory,
     private val stakingBalanceUpdater: StakingBalanceUpdater.Factory,
     private val analyticsEventHandler: AnalyticsEventHandler,
+    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
     @DelayedWork private val coroutineScope: CoroutineScope,
     savedStateHandle: SavedStateHandle,
 ) : ViewModel(), DefaultLifecycleObserver, StakingClickIntents {
@@ -716,7 +716,7 @@ internal class StakingViewModel @Inject constructor(
                 unsignedTransactions = transactionsInProgress.map { it.unsignedTransaction },
             )
 
-            feedbackManager.sendEmail(email)
+            sendFeedbackEmailUseCase(email)
         }
     }
 

features/wallet/impl/build.gradle.kts

@@ -80,6 +80,7 @@ dependencies {
     implementation(projects.domain.visa)
     implementation(projects.domain.staking.models)
     implementation(projects.domain.markets.models)
+    implementation(projects.domain.feedback)
 
     //TODO: Create api/impl modules for onboarding [REDACTED_JIRA]
     implementation(projects.features.onboarding)

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/viewmodels/intents/WalletWarningsClickIntents.kt

@@ -6,6 +6,9 @@ import com.tangem.core.analytics.models.AnalyticsParam
 import com.tangem.core.ui.extensions.resourceReference
 import com.tangem.domain.card.DerivePublicKeysUseCase
 import com.tangem.domain.card.SetCardWasScannedUseCase
+import com.tangem.domain.feedback.GetCardInfoUseCase
+import com.tangem.domain.feedback.SendFeedbackEmailUseCase
+import com.tangem.domain.feedback.models.FeedbackEmailType
 import com.tangem.domain.redux.LegacyAction
 import com.tangem.domain.redux.ReduxStateHolder
 import com.tangem.domain.settings.NeverToSuggestRateAppUseCase
@@ -84,6 +87,8 @@ internal class WalletWarningsClickIntentsImplementor @Inject constructor(
     private val dispatchers: CoroutineDispatcherProvider,
     private val shouldShowSwapPromoWalletUseCase: ShouldShowSwapPromoWalletUseCase,
     private val shouldShowTravalaPromoWalletUseCase: ShouldShowTravalaPromoWalletUseCase,
+    private val getCardInfoUseCase: GetCardInfoUseCase,
+    private val sendFeedbackEmailUseCase: SendFeedbackEmailUseCase,
 ) : BaseWalletClickIntents(), WalletWarningsClickIntents {
 
     override fun onAddBackupCardClick() {
@@ -209,12 +214,10 @@ internal class WalletWarningsClickIntentsImplementor @Inject constructor(
         viewModelScope.launch(dispatchers.main) {
             neverToSuggestRateAppUseCase()
 
-            reduxStateHolder.dispatch(
-                LegacyAction.SendEmailRateCanBeBetter(
-                    scanResponse = getSelectedUserWallet()?.scanResponse
-                        ?: error("ScanResponse must be not null"),
-                ),
-            )
+            val scanResponse = getSelectedUserWallet()?.scanResponse ?: return@launch
+            val cardInfo = getCardInfoUseCase(scanResponse).getOrNull() ?: return@launch
+
+            sendFeedbackEmailUseCase(type = FeedbackEmailType.RateCanBeBetter(cardInfo = cardInfo))
         }
     }
 
@@ -268,12 +271,12 @@ internal class WalletWarningsClickIntentsImplementor @Inject constructor(
     }
 
     override fun onSupportClick() {
-        reduxStateHolder.dispatch(
-            LegacyAction.SendEmailSupport(
-                scanResponse = getSelectedUserWallet()?.scanResponse
-                    ?: error("ScanResponse must be not null"),
-            ),
-        )
+        val scanResponse = getSelectedUserWallet()?.scanResponse ?: return
+        val cardInfo = getCardInfoUseCase(scanResponse).getOrNull() ?: return
+
+        viewModelScope.launch {
+            sendFeedbackEmailUseCase(type = FeedbackEmailType.DirectUserRequest(cardInfo = cardInfo))
+        }
     }
 
     private fun getSelectedUserWallet(): UserWallet? {