Updated on 2026-08-14

app/src/main/java/com/tangem/tap/di/data/CardDataModule.kt

@@ -1,34 +0,0 @@
-package com.tangem.tap.di.data
-
-import com.tangem.data.common.network.NetworkFactory
-import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.card.repository.DerivationsRepository
-import com.tangem.sdk.api.TangemSdkManager
-import com.tangem.tap.domain.card.DefaultDerivationsRepository
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-internal object CardDataModule {
-
-    @Singleton
-    @Provides
-    fun providesDerivationsRepository(
-        tangemSdkManager: TangemSdkManager,
-        userWalletsStore: UserWalletsStore,
-        networkFactory: NetworkFactory,
-        dispatchers: CoroutineDispatcherProvider,
-    ): DerivationsRepository {
-        return DefaultDerivationsRepository(
-            tangemSdkManager = tangemSdkManager,
-            userWalletsStore = userWalletsStore,
-            networkFactory = networkFactory,
-            dispatchers = dispatchers,
-        )
-    }
-}

app/src/main/java/com/tangem/tap/di/domain/CardDomainModule.kt

@@ -2,11 +2,14 @@ package com.tangem.tap.di.domain
 
 import com.tangem.domain.card.*
 import com.tangem.domain.card.repository.CardRepository
-import com.tangem.domain.card.repository.DerivationsRepository
+import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.demo.IsDemoCardUseCase
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.legacy.UserWalletsListManager
+import com.tangem.domain.wallets.usecase.DerivePublicKeysUseCase
+import com.tangem.domain.wallets.usecase.GetExtendedPublicKeyForCurrencyUseCase
+import com.tangem.domain.wallets.usecase.HasMissedDerivationsUseCase
 import com.tangem.domain.wallets.usecase.IsNeedToBackupUseCase
 import com.tangem.domain.wallets.usecase.NetworkHasDerivationUseCase
 import com.tangem.sdk.api.TangemSdkManager

app/src/main/java/com/tangem/tap/di/domain/ManageTokensDomainModule.kt

@@ -1,6 +1,6 @@
 package com.tangem.tap.di.domain
 
-import com.tangem.domain.card.repository.DerivationsRepository
+import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.managetokens.*
 import com.tangem.domain.managetokens.repository.CustomTokensRepository
 import com.tangem.domain.managetokens.repository.ManageTokensRepository

app/src/main/java/com/tangem/tap/di/domain/MarketsDomainModule.kt

@@ -1,7 +1,7 @@
 package com.tangem.tap.di.domain
 
 import com.tangem.blockchainsdk.utils.ExcludedBlockchains
-import com.tangem.domain.card.repository.DerivationsRepository
+import com.tangem.domain.wallets.derivations.DerivationsRepository
 import com.tangem.domain.markets.*
 import com.tangem.domain.markets.repositories.MarketsTokenRepository
 import com.tangem.domain.networks.multi.MultiNetworkStatusFetcher

app/src/main/java/com/tangem/tap/di/domain/TransactionDomainModule.kt

@@ -1,5 +1,6 @@
 package com.tangem.tap.di.domain
 
+import com.tangem.data.wallets.hot.TangemHotWalletSigner
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.demo.models.DemoConfig
 import com.tangem.domain.networks.single.SingleNetworkStatusFetcher
@@ -11,7 +12,6 @@ import com.tangem.domain.transaction.FeeRepository
 import com.tangem.domain.transaction.TransactionRepository
 import com.tangem.domain.transaction.usecase.*
 import com.tangem.domain.walletmanager.WalletManagersFacade
-import com.tangem.tap.domain.hot.TangemHotWalletSigner
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn

app/src/main/java/com/tangem/tap/di/hot/TangemHotSdkModule.kt

@@ -1,8 +1,6 @@
 package com.tangem.tap.di.hot
 
 import com.tangem.hot.sdk.TangemHotSdk
-import com.tangem.tap.domain.hot.HotWalletPasswordRequester
-import com.tangem.tap.features.hot.DefaultHotWalletPasswordRequester
 import com.tangem.tap.features.hot.TangemHotSDKProxy
 import dagger.Binds
 import dagger.Module
@@ -17,8 +15,4 @@ internal interface TangemHotSdkModule {
     @Binds
     @Singleton
     fun bindTangemHotSdk(proxy: TangemHotSDKProxy): TangemHotSdk
-
-    @Binds
-    @Singleton
-    fun bindHotWalletPasswordRequester(impl: DefaultHotWalletPasswordRequester): HotWalletPasswordRequester
 }

app/src/main/java/com/tangem/tap/domain/card/DefaultDerivationsRepository.kt

@@ -1,173 +0,0 @@
-package com.tangem.tap.domain.card
-
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchainsdk.utils.fromNetworkId
-import com.tangem.common.CompletionResult
-import com.tangem.common.card.EllipticCurve
-import com.tangem.common.core.TangemSdkError
-import com.tangem.common.doOnFailure
-import com.tangem.common.doOnSuccess
-import com.tangem.common.extensions.ByteArrayKey
-import com.tangem.common.extensions.toMapKey
-import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.data.common.network.NetworkFactory
-import com.tangem.datasource.local.userwallet.UserWalletsStore
-import com.tangem.domain.card.BackendId
-import com.tangem.domain.card.repository.DerivationsRepository
-import com.tangem.domain.models.currency.CryptoCurrency
-import com.tangem.domain.models.network.Network
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.domain.models.wallet.UserWalletId
-import com.tangem.domain.models.wallet.requireColdWallet
-import com.tangem.operations.derivation.ExtendedPublicKeysMap
-import com.tangem.sdk.api.TangemSdkManager
-import com.tangem.tap.domain.tasks.UserWalletIdPreflightReadFilter
-import com.tangem.utils.coroutines.CoroutineDispatcherProvider
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-
-internal typealias Derivations = Map<ByteArrayKey, List<DerivationPath>>
-private typealias DerivedKeys = Map<ByteArrayKey, ExtendedPublicKeysMap>
-
-internal class DefaultDerivationsRepository(
-    private val tangemSdkManager: TangemSdkManager,
-    private val userWalletsStore: UserWalletsStore,
-    private val networkFactory: NetworkFactory,
-    private val dispatchers: CoroutineDispatcherProvider,
-) : DerivationsRepository {
-
-    override suspend fun derivePublicKeys(userWalletId: UserWalletId, currencies: List<CryptoCurrency>) {
-        derivePublicKeysByNetworks(userWalletId = userWalletId, networks = currencies.map(CryptoCurrency::network))
-    }
-
-    override suspend fun derivePublicKeysByNetworkIds(userWalletId: UserWalletId, networkIds: List<Network.RawID>) {
-        val userWallet = userWalletsStore.getSyncOrNull(userWalletId) ?: error("User wallet not found")
-
-        derivePublicKeysByNetworks(
-            userWalletId = userWalletId,
-            networks = networkIds.mapNotNull {
-                networkFactory.create(
-                    blockchain = Blockchain.fromNetworkId(it.value) ?: return@mapNotNull null,
-                    extraDerivationPath = null,
-                    userWallet = userWallet,
-                )
-            },
-        )
-    }
-
-    override suspend fun derivePublicKeysByNetworks(userWalletId: UserWalletId, networks: List<Network>) {
-        val userWallet = withContext(dispatchers.io) {
-            userWalletsStore.getSyncOrNull(userWalletId) ?: error("User wallet not found")
-        }
-
-        if (userWallet is UserWallet.Hot) {
-            return
-        }
-
-        userWallet.requireColdWallet()
-
-        if (!userWallet.scanResponse.card.settings.isHDWalletAllowed) {
-            Timber.d("Nothing to derive")
-            return
-        }
-
-        val derivations = MissedDerivationsFinder(scanResponse = userWallet.scanResponse)
-            .findByNetworks(networks)
-            .ifEmpty {
-                Timber.d("Nothing to derive")
-                return
-            }
-
-        derivePublicKeys(userWalletId = userWalletId, derivations = derivations)
-    }
-
-    override suspend fun hasMissedDerivations(
-        userWalletId: UserWalletId,
-        networksWithDerivationPath: Map<BackendId, String?>,
-    ): Boolean {
-        val userWallet = userWalletsStore.getSyncOrNull(userWalletId) ?: error("User wallet not found")
-
-        if (userWallet is UserWallet.Hot) {
-            return false
-        }
-
-        val derivations =
-            MissedDerivationsFinder(scanResponse = userWallet.requireColdWallet().scanResponse)
-                .findByNetworks(
-                    networksWithDerivationPath.mapNotNull { (backendId, extraDerivationPath) ->
-                        networkFactory.create(
-                            blockchain = Blockchain.fromNetworkId(backendId) ?: return@mapNotNull null,
-                            extraDerivationPath = extraDerivationPath,
-                            userWallet = userWallet,
-                        )
-                    },
-                )
-
-        return derivations.isNotEmpty()
-    }
-
-    override suspend fun derivePublicKeys(userWalletId: UserWalletId, derivations: Derivations): DerivedKeys {
-        // todo replace it in task [REDACTED_JIRA]
-        val preflightReadFilter = UserWalletIdPreflightReadFilter(userWalletId)
-        tangemSdkManager.derivePublicKeys(
-            cardId = null,
-            derivations = derivations,
-            preflightReadFilter = preflightReadFilter,
-        ).doOnSuccess { response ->
-            updatePublicKeys(userWalletId = userWalletId, keys = response.entries)
-                .doOnSuccess {
-                    // TODO [REDACTED_TASK_KEY]
-                    validateDerivations(scanResponse = it.requireColdWallet().scanResponse, derivations = derivations)
-                    return response.entries
-                }
-                .doOnFailure { throw it }
-        }
-            .doOnFailure { throw it }
-
-        error("This code should never be reached")
-    }
-
-    /**
-     * It throws an exception if any of the provided derivations are invalid
-     * Validation for NonHardened moved to application layer, to avoid fails when derive multiple paths
-     * It needs to be called after success [derivePublicKeys] or in same flows
-     */
-    private fun validateDerivations(scanResponse: ScanResponse, derivations: Derivations) {
-        derivations.entries.forEach { derivationForKey ->
-            val wallet = scanResponse.card.wallets.firstOrNull { it.publicKey.toMapKey() == derivationForKey.key }
-            if (wallet == null) return@forEach
-            val hasHardenedNodes = derivationForKey.value.any { path -> path.nodes.any { node -> !node.isHardened } }
-            if (wallet.curve == EllipticCurve.Ed25519Slip0010 && hasHardenedNodes) {
-                throw TangemSdkError.NonHardenedDerivationNotSupported()
-            }
-        }
-    }
-
-    private suspend fun updatePublicKeys(userWalletId: UserWalletId, keys: DerivedKeys): CompletionResult<UserWallet> {
-        return withContext(dispatchers.io) {
-            userWalletsStore.update(
-                userWalletId = userWalletId,
-                update = { userWallet -> userWallet.requireColdWallet().updateDerivedKeys(keys) }, // TODO [REDACTED_TASK_KEY]
-            )
-        }
-    }
-
-    private fun UserWallet.Cold.updateDerivedKeys(keys: DerivedKeys): UserWallet {
-        return copy(
-            scanResponse = scanResponse.copy(
-                derivedKeys = getUpdatedDerivedKeys(oldKeys = scanResponse.derivedKeys, newKeys = keys),
-            ),
-        )
-    }
-
-    private fun getUpdatedDerivedKeys(oldKeys: DerivedKeys, newKeys: DerivedKeys): DerivedKeys {
-        return (oldKeys.keys + newKeys.keys).toSet()
-            .associateWith { walletKey ->
-                val oldDerivations = ExtendedPublicKeysMap(oldKeys[walletKey] ?: emptyMap())
-                val newDerivations = newKeys[walletKey] ?: ExtendedPublicKeysMap(emptyMap())
-
-                ExtendedPublicKeysMap(oldDerivations + newDerivations)
-            }
-    }
-}

app/src/main/java/com/tangem/tap/domain/card/MissedDerivationsFinder.kt

@@ -1,124 +0,0 @@
-package com.tangem.tap.domain.card
-
-import com.tangem.blockchain.blockchains.cardano.CardanoUtils
-import com.tangem.blockchain.common.Blockchain
-import com.tangem.blockchainsdk.utils.toBlockchain
-import com.tangem.common.card.EllipticCurve
-import com.tangem.common.extensions.ByteArrayKey
-import com.tangem.common.extensions.toMapKey
-import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.domain.card.configs.CardConfig
-import com.tangem.domain.card.common.util.derivationStyleProvider
-import com.tangem.domain.models.currency.CryptoCurrency
-import com.tangem.domain.models.network.Network
-import com.tangem.domain.models.scan.KeyWalletPublicKey
-import com.tangem.domain.models.scan.ScanResponse
-import com.tangem.operations.derivation.ExtendedPublicKeysMap
-
-private typealias DerivationData = Pair<ByteArrayKey, List<DerivationPath>>
-
-/**
- * Finder of missed derivations
- *
- * @property scanResponse scanning response
- *
-[REDACTED_AUTHOR]
- */
-internal class MissedDerivationsFinder(private val scanResponse: ScanResponse) {
-
-    /** Find missed derivations for given currencies [currencies] */
-    fun find(currencies: List<CryptoCurrency>): Derivations {
-        return currencies.map { it.network }.let(::findByNetworks)
-    }
-
-    fun findByNetworks(networks: List<Network>): Derivations {
-        return buildMap<ByteArrayKey, MutableList<DerivationPath>> {
-            networks
-                .mapToNewDerivations()
-                .forEach { data ->
-                    val current = this[data.first]
-                    if (current != null) {
-                        current.addAll(data.second)
-                        current.distinct()
-                    } else {
-                        this[data.first] = data.second.toMutableList()
-                    }
-                }
-        }
-    }
-
-    private fun List<Network>.mapToNewDerivations(): List<DerivationData> {
-        val config = CardConfig.createConfig(scanResponse.card)
-        return mapNotNull { network ->
-            val blockchain = network.toBlockchain()
-            val curve = config.primaryCurve(blockchain) ?: return@mapNotNull null
-
-            findNewDerivations(curve = curve, scanResponse = scanResponse, network = network)
-        }
-    }
-
-    private fun findNewDerivations(
-        curve: EllipticCurve,
-        scanResponse: ScanResponse,
-        network: Network,
-    ): DerivationData? {
-        val wallet = scanResponse.card.wallets.firstOrNull { it.curve == curve } ?: return null
-        val publicKey = wallet.publicKey.toMapKey()
-
-        val derivationCandidates = network
-            .getDerivationCandidates(curve)
-            .ifEmpty { return null }
-            .filterAlreadyDerivedKeys(publicKey)
-            .ifEmpty { return null }
-
-        return publicKey to derivationCandidates
-    }
-
-    private fun Network.getDerivationCandidates(curve: EllipticCurve): List<DerivationPath> {
-        val blockchain = this.toBlockchain()
-
-        return buildList {
-            add(blockchain.getDerivationPath(curve = curve))
-            add(blockchain.getCustomDerivationPath(curve = curve, network = this@getDerivationCandidates))
-            add(blockchain.getCardanoDerivationPathIfNeeded(network = this@getDerivationCandidates))
-        }
-            .filterNotNull()
-            .distinct()
-    }
-
-    private fun Blockchain.getDerivationPath(curve: EllipticCurve): DerivationPath? {
-        return if (getSupportedCurves().contains(curve)) {
-            derivationPath(style = scanResponse.derivationStyleProvider.getDerivationStyle())
-        } else {
-            null
-        }
-    }
-
-    private fun Blockchain.getCustomDerivationPath(curve: EllipticCurve, network: Network): DerivationPath? {
-        return if (getSupportedCurves().contains(curve)) {
-            network.derivationPath.value?.let(::DerivationPath)
-        } else {
-            null
-        }
-    }
-
-    private fun Blockchain.getCardanoDerivationPathIfNeeded(network: Network): DerivationPath? {
-        return if (this == Blockchain.Cardano) {
-            network.derivationPath.value?.let {
-                CardanoUtils.extendedDerivationPath(derivationPath = DerivationPath(it))
-            }
-        } else {
-            null
-        }
-    }
-
-    private fun List<DerivationPath>.filterAlreadyDerivedKeys(publicKey: KeyWalletPublicKey): List<DerivationPath> {
-        val alreadyDerivedPaths = getAlreadyDerivedKeys(publicKey)
-        return filterNot(alreadyDerivedPaths::contains)
-    }
-
-    private fun getAlreadyDerivedKeys(publicKey: KeyWalletPublicKey): List<DerivationPath> {
-        val extendedPublicKeysMap = scanResponse.derivedKeys[publicKey] ?: ExtendedPublicKeysMap(emptyMap())
-        return extendedPublicKeysMap.keys.toList()
-    }
-}

app/src/main/java/com/tangem/tap/domain/hot/HotWalletAccessor.kt

@@ -1,113 +0,0 @@
-package com.tangem.tap.domain.hot
-
-import com.tangem.common.core.TangemSdkError
-import com.tangem.features.hotwallet.HotWalletPasswordRequester
-import com.tangem.hot.sdk.TangemHotSdk
-import com.tangem.hot.sdk.exception.WrongPasswordException
-import com.tangem.hot.sdk.model.*
-import javax.inject.Inject
-
-class HotWalletAccessor @Inject constructor(
-    private val tangemHotSdk: TangemHotSdk,
-    private val hotWalletPasswordRequester: HotWalletPasswordRequester,
-) {
-
-    suspend fun signHashes(hotWalletId: HotWalletId, dataToSign: List<DataToSign>): List<SignedData> {
-        val auth = when (hotWalletId.authType) {
-            HotWalletId.AuthType.NoPassword -> HotAuth.NoAuth
-            HotWalletId.AuthType.Password -> requestPassword(false)
-            HotWalletId.AuthType.Biometry -> HotAuth.Biometry
-        }
-
-        return runCatchingSdkErrors(hotWalletId, auth) {
-            tangemHotSdk.signHashes(
-                unlockHotWallet = UnlockHotWallet(
-                    walletId = hotWalletId,
-                    auth = it,
-                ),
-                dataToSign = dataToSign,
-            ).also {
-                hotWalletPasswordRequester.dismiss()
-            }
-        }
-    }
-
-    private suspend fun <T> runCatchingSdkErrors(
-        hotWalletId: HotWalletId,
-        auth: HotAuth,
-        block: suspend (auth: HotAuth) -> T,
-    ): T {
-        return runCatchingWrongPassInternal(
-            originalAuth = auth,
-            auth = auth,
-            block = { blockAuth ->
-                block(blockAuth).also {
-                    // TODO [REDACTED_TASK_KEY] if user has biometry enabled, we set it as the new auth method
-                    if (blockAuth is HotAuth.Password /*&& has biometry enabled */) {
-                        tangemHotSdk.changeAuth(
-                            unlockHotWallet = UnlockHotWallet(
-                                walletId = hotWalletId,
-                                auth = blockAuth,
-                            ),
-                            auth = HotAuth.Biometry,
-                        )
-                    }
-                }
-            },
-        )
-    }
-
-    private suspend fun <T> runCatchingWrongPassInternal(
-        originalAuth: HotAuth,
-        auth: HotAuth,
-        block: suspend (auth: HotAuth) -> T,
-    ): T = runCatching {
-        block(auth)
-    }.getOrElse { exception ->
-        if (auth is HotAuth.Biometry && exception.isBiometryError()) {
-            // fallback to password if biometry fails
-            val passAuth = requestPassword(true)
-
-            return@getOrElse runCatchingWrongPassInternal(
-                originalAuth = originalAuth,
-                auth = passAuth,
-                block = block,
-            )
-        }
-
-        if (exception !is WrongPasswordException) {
-            throw exception
-        }
-
-        // If the exception is a wrong password, we need to request the password again
-
-        hotWalletPasswordRequester.wrongPassword()
-        val passResult = requestPassword(originalAuth is HotAuth.Biometry)
-
-        runCatchingWrongPassInternal(
-            originalAuth = originalAuth,
-            auth = passResult,
-            block = block,
-        )
-    }
-
-    private suspend fun requestPassword(hasBiometry: Boolean): HotAuth {
-        return hotWalletPasswordRequester.requestPassword(hasBiometry).toAuth() ?: throw TangemSdkError.UserCancelled()
-    }
-
-    private fun Throwable.isBiometryError(): Boolean {
-        return this is TangemSdkError.AuthenticationFailed ||
-            this is TangemSdkError.AuthenticationCanceled ||
-            this is TangemSdkError.AuthenticationLockout ||
-            this is TangemSdkError.AuthenticationUnavailable ||
-            this is TangemSdkError.AuthenticationAlreadyInProgress ||
-            this is TangemSdkError.AuthenticationNotInitialized ||
-            this is TangemSdkError.AuthenticationPermanentLockout
-    }
-
-    private fun HotWalletPasswordRequester.Result.toAuth() = when (this) {
-        HotWalletPasswordRequester.Result.UseBiometry -> HotAuth.Biometry
-        HotWalletPasswordRequester.Result.Dismiss -> null
-        is HotWalletPasswordRequester.Result.EnteredPassword -> this.password
-    }
-}

app/src/main/java/com/tangem/tap/domain/hot/HotWalletPasswordRequester.kt

@@ -1,9 +0,0 @@
-package com.tangem.tap.domain.hot
-
-import com.tangem.hot.sdk.model.HotAuth
-import com.tangem.hot.sdk.model.HotWalletId
-
-interface HotWalletPasswordRequester {
-
-    suspend fun requestPassword(hotWalletId: HotWalletId): HotAuth.Password
-}

app/src/main/java/com/tangem/tap/domain/hot/TangemHotSigner.kt

@@ -1,78 +0,0 @@
-package com.tangem.tap.domain.hot
-
-import com.tangem.blockchain.common.TransactionSigner
-import com.tangem.blockchain.common.Wallet
-import com.tangem.common.CompletionResult
-import com.tangem.common.core.TangemSdkError
-import com.tangem.common.map
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.hot.sdk.model.DataToSign
-import com.tangem.operations.sign.SignData
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-
-class TangemHotSigner @AssistedInject constructor(
-    @Assisted private val userWallet: UserWallet.Hot,
-    private val hotWalletAccessor: HotWalletAccessor,
-) : TransactionSigner {
-
-    override suspend fun sign(hash: ByteArray, publicKey: Wallet.PublicKey): CompletionResult<ByteArray> {
-        return sign(listOf(hash), publicKey).map { it.first() }
-    }
-
-    override suspend fun sign(
-        hashes: List<ByteArray>,
-        publicKey: Wallet.PublicKey,
-    ): CompletionResult<List<ByteArray>> {
-        val wallet = userWallet.wallets.orEmpty().firstOrNull { it.publicKey == publicKey.seedKey }
-            ?: return CompletionResult.Failure(
-                TangemSdkError.ExceptionError(IllegalStateException("wallet is locked")),
-            )
-
-        val result = hotWalletAccessor.signHashes(
-            hotWalletId = userWallet.hotWalletId,
-            dataToSign = listOf(
-                DataToSign(
-                    curve = wallet.curve,
-                    hashes = hashes,
-                    derivationPath = publicKey.derivationPath,
-                ),
-            ),
-        )
-
-        return CompletionResult.Success(result.map { it.signatures }.flatten())
-    }
-
-    override suspend fun multiSign(
-        dataToSign: List<SignData>,
-        publicKey: Wallet.PublicKey,
-    ): CompletionResult<Map<ByteArray, ByteArray>> {
-        val result = hotWalletAccessor.signHashes(
-            hotWalletId = userWallet.hotWalletId,
-            dataToSign = dataToSign.map { signData ->
-                val wallet = userWallet.wallets.orEmpty().firstOrNull { it.publicKey == signData.publicKey }
-                    ?: return CompletionResult.Failure(
-                        TangemSdkError.ExceptionError(IllegalStateException("wallet is locked")),
-                    )
-
-                DataToSign(
-                    curve = wallet.curve,
-                    hashes = listOf(signData.hash),
-                    derivationPath = signData.derivationPath,
-                )
-            },
-        )
-
-        return CompletionResult.Success(
-            result.mapIndexed { index, data ->
-                dataToSign[index].publicKey to data.signatures.first()
-            }.toMap(),
-        )
-    }
-
-    @AssistedFactory
-    interface Factory {
-        fun create(@Assisted userWallet: UserWallet.Hot): TangemHotSigner
-    }
-}

app/src/main/java/com/tangem/tap/domain/hot/TangemHotWalletSigner.kt

@@ -1,98 +0,0 @@
-package com.tangem.tap.domain.hot
-
-import com.tangem.blockchain.common.TransactionSigner
-import com.tangem.blockchain.common.Wallet
-import com.tangem.common.CompletionResult
-import com.tangem.common.core.TangemSdkError
-import com.tangem.common.map
-import com.tangem.domain.models.wallet.UserWallet
-import com.tangem.hot.sdk.model.DataToSign
-import com.tangem.operations.sign.SignData
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import timber.log.Timber
-
-class TangemHotWalletSigner @AssistedInject constructor(
-    @Assisted private val userWallet: UserWallet.Hot,
-    private val hotWalletAccessor: HotWalletAccessor,
-) : TransactionSigner {
-
-    override suspend fun sign(hash: ByteArray, publicKey: Wallet.PublicKey): CompletionResult<ByteArray> {
-        return sign(listOf(hash), publicKey).map { it.first() }
-    }
-
-    override suspend fun sign(
-        hashes: List<ByteArray>,
-        publicKey: Wallet.PublicKey,
-    ): CompletionResult<List<ByteArray>> {
-        val wallet = userWallet.wallets.orEmpty().firstOrNull { it.publicKey.contentEquals(publicKey.seedKey) }
-            ?: return CompletionResult.Failure(
-                TangemSdkError.ExceptionError(IllegalStateException("wallet is locked")),
-            )
-
-        val result = runCatching {
-            hotWalletAccessor.signHashes(
-                hotWalletId = userWallet.hotWalletId,
-                dataToSign = listOf(
-                    DataToSign(
-                        curve = wallet.curve,
-                        hashes = hashes,
-                        derivationPath = publicKey.derivationPath,
-                    ),
-                ),
-            )
-        }.getOrElse {
-            Timber.e(it)
-            return if (it is TangemSdkError) {
-                CompletionResult.Failure(it)
-            } else {
-                CompletionResult.Failure(TangemSdkError.ExceptionError(it))
-            }
-        }
-
-        return CompletionResult.Success(result.map { it.signatures }.flatten())
-    }
-
-    override suspend fun multiSign(
-        dataToSign: List<SignData>,
-        publicKey: Wallet.PublicKey,
-    ): CompletionResult<Map<ByteArray, ByteArray>> {
-        val result = runCatching {
-            hotWalletAccessor.signHashes(
-                hotWalletId = userWallet.hotWalletId,
-                dataToSign = dataToSign.map { signData ->
-                    val wallet =
-                        userWallet.wallets.orEmpty().firstOrNull { it.publicKey.contentEquals(signData.publicKey) }
-                            ?: return CompletionResult.Failure(
-                                TangemSdkError.ExceptionError(IllegalStateException("wallet is locked")),
-                            )
-
-                    DataToSign(
-                        curve = wallet.curve,
-                        hashes = listOf(signData.hash),
-                        derivationPath = signData.derivationPath,
-                    )
-                },
-            )
-        }.getOrElse {
-            Timber.e(it)
-            return if (it is TangemSdkError) {
-                CompletionResult.Failure(it)
-            } else {
-                CompletionResult.Failure(TangemSdkError.ExceptionError(it))
-            }
-        }
-
-        return CompletionResult.Success(
-            result.mapIndexed { index, data ->
-                dataToSign[index].publicKey to data.signatures.first()
-            }.toMap(),
-        )
-    }
-
-    @AssistedFactory
-    interface Factory {
-        fun create(@Assisted userWallet: UserWallet.Hot): TangemHotWalletSigner
-    }
-}

app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt

@@ -20,7 +20,7 @@ import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
 import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.domain.card.common.util.cardTypesResolver
-import com.tangem.domain.card.common.util.derivationStyleProvider
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
 import com.tangem.domain.models.wallet.UserWalletId

app/src/main/java/com/tangem/tap/domain/tasks/product/CreateProductWalletTask.kt

@@ -14,7 +14,7 @@ import com.tangem.common.map
 import com.tangem.crypto.bip39.Mnemonic
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.domain.card.CardTypesResolver
-import com.tangem.domain.card.DerivationStyleProvider
+import com.tangem.domain.wallets.derivations.DerivationStyleProvider
 import com.tangem.domain.card.common.TapWorkarounds.isTestCard
 import com.tangem.domain.card.configs.CardConfig
 import com.tangem.domain.models.scan.CardDTO

app/src/main/java/com/tangem/tap/domain/tasks/product/DerivationsFinder.kt

@@ -6,7 +6,7 @@ import com.tangem.blockchain.common.derivation.DerivationStyle
 import com.tangem.blockchainsdk.utils.fromNetworkId
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.datasource.local.token.UserTokensResponseStore
-import com.tangem.domain.card.DerivationStyleProvider
+import com.tangem.domain.wallets.derivations.DerivationStyleProvider
 import com.tangem.domain.card.common.TapWorkarounds.useOldStyleDerivation
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.wallet.UserWalletId

app/src/main/java/com/tangem/tap/domain/tasks/product/ScanProductTask.kt

@@ -14,14 +14,14 @@ import com.tangem.common.tlv.Tlv
 import com.tangem.common.tlv.TlvDecoder
 import com.tangem.crypto.CryptoUtils
 import com.tangem.crypto.hdWallet.DerivationPath
-import com.tangem.domain.card.DerivationStyleProvider
+import com.tangem.domain.wallets.derivations.DerivationStyleProvider
 import com.tangem.domain.card.common.TapWorkarounds.isExcluded
 import com.tangem.domain.card.common.TapWorkarounds.isNotSupportedInThatRelease
 import com.tangem.domain.card.common.TapWorkarounds.isStart2Coin
 import com.tangem.domain.card.common.TapWorkarounds.isTangemTwins
 import com.tangem.domain.card.common.TapWorkarounds.isVisa
 import com.tangem.domain.common.TwinsHelper
-import com.tangem.domain.card.common.util.derivationStyleProvider
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.domain.card.common.visa.VisaUtilities
 import com.tangem.domain.card.configs.CardConfig
 import com.tangem.domain.models.scan.CardDTO

app/src/main/java/com/tangem/tap/domain/tasks/visa/VisaCustomerWalletApproveTask.kt

@@ -16,7 +16,7 @@ import com.tangem.common.extensions.toHexString
 import com.tangem.core.error.ext.tangemError
 import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
-import com.tangem.domain.card.common.util.derivationStyleProvider
+import com.tangem.domain.wallets.derivations.derivationStyleProvider
 import com.tangem.domain.card.common.visa.VisaUtilities
 import com.tangem.domain.card.common.visa.VisaWalletPublicKeyUtility
 import com.tangem.domain.card.common.visa.VisaWalletPublicKeyUtility.findKeyWithoutDerivation

app/src/main/java/com/tangem/tap/features/hot/DefaultHotWalletPasswordRequester.kt

@@ -1,13 +0,0 @@
-package com.tangem.tap.features.hot
-
-import com.tangem.hot.sdk.model.HotAuth
-import com.tangem.hot.sdk.model.HotWalletId
-import com.tangem.tap.domain.hot.HotWalletPasswordRequester
-import javax.inject.Inject
-
-class DefaultHotWalletPasswordRequester @Inject constructor() : HotWalletPasswordRequester {
-
-    override suspend fun requestPassword(hotWalletId: HotWalletId): HotAuth.Password {
-        return HotAuth.Password("TODO [REDACTED_TASK_KEY]".toCharArray()) // TODO [REDACTED_TASK_KEY]
-    }
-}