Updated on 2026-08-14

2024-10-29 14:31:53 +03:00 · 2024-10-29 14:31:53 +03:00 · 652159dbce
commit 652159dbce
parent c23bd7b301 06f2d51e87
316 changed files with 6242 additions and 3084 deletions
--- a/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingActionRepository.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingActionRepository.kt
@ -0,0 +1,30 @@
+package com.tangem.data.staking
+
+import com.tangem.datasource.local.token.StakingActionsStore
+import com.tangem.domain.staking.model.stakekit.action.StakingAction
+import com.tangem.domain.staking.repositories.StakingActionRepository
+import com.tangem.domain.tokens.model.CryptoCurrency
+import com.tangem.domain.wallets.models.UserWalletId
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
+
+internal class DefaultStakingActionRepository(
+    private val stakingActionsStore: StakingActionsStore,
+    private val dispatchers: CoroutineDispatcherProvider,
+) : StakingActionRepository {
+
+    override suspend fun store(
+        userWalletId: UserWalletId,
+        cryptoCurrencyId: CryptoCurrency.ID,
+        actions: List<StakingAction>,
+    ) {
+        withContext(dispatchers.io) {
+            stakingActionsStore.store(userWalletId, cryptoCurrencyId, actions)
+        }
+    }
+
+    override fun get(userWalletId: UserWalletId, cryptoCurrencyId: CryptoCurrency.ID): Flow<List<StakingAction>> {
+        return stakingActionsStore.get(userWalletId, cryptoCurrencyId)
+    }
+}
--- a/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingPendingTransactionRepository.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingPendingTransactionRepository.kt
@ -1,32 +0,0 @@
-package com.tangem.data.staking
-
-import com.tangem.domain.staking.model.PendingTransaction
-import com.tangem.domain.staking.model.stakekit.BalanceItem
-import com.tangem.domain.staking.repositories.StakingPendingTransactionRepository
-import com.tangem.domain.wallets.models.UserWalletId
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.CopyOnWriteArrayList
-
-internal class DefaultStakingPendingTransactionRepository : StakingPendingTransactionRepository {
-
-    private val pendingTransactionsMap = ConcurrentHashMap<UserWalletId, CopyOnWriteArrayList<PendingTransaction>>()
-
-    override fun saveTransaction(userWalletId: UserWalletId, transaction: PendingTransaction) {
-        val transactions = pendingTransactionsMap.computeIfAbsent(userWalletId) { CopyOnWriteArrayList() }
-        transactions.add(transaction)
-    }
-
-    override fun removeTransactions(userWalletId: UserWalletId, transactions: Set<PendingTransaction>) {
-        pendingTransactionsMap[userWalletId]?.removeAll(transactions)
-    }
-
-    override fun getTransactionsWithBalanceItems(
-        userWalletId: UserWalletId,
-    ): List<Pair<PendingTransaction, BalanceItem>> {
-        return pendingTransactionsMap[userWalletId]?.mapNotNull { pendingTransaction: PendingTransaction ->
-            PendingTransactionItemConverter.convert(pendingTransaction)?.let { balanceItem ->
-                pendingTransaction to balanceItem
-            }
-        } ?: emptyList()
-    }
-}
--- a/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingRepository.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/DefaultStakingRepository.kt
@ -2,7 +2,6 @@ package com.tangem.data.staking

 import android.util.Base64
 import arrow.core.getOrElse
-import arrow.core.raise.catch
 import com.squareup.moshi.Moshi
 import com.tangem.blockchain.common.Amount
 import com.tangem.blockchain.common.Blockchain
@ -26,21 +25,19 @@ import com.tangem.data.staking.converters.transaction.StakingTransactionTypeConv
 import com.tangem.datasource.api.common.response.getOrThrow
 import com.tangem.datasource.api.stakekit.StakeKitApi
 import com.tangem.datasource.api.stakekit.models.request.*
+import com.tangem.datasource.api.stakekit.models.response.model.NetworkTypeDTO
 import com.tangem.datasource.api.stakekit.models.response.model.YieldBalanceWrapperDTO
+import com.tangem.datasource.api.stakekit.models.response.model.action.StakingActionStatusDTO
 import com.tangem.datasource.api.stakekit.models.response.model.transaction.tron.TronStakeKitTransaction
 import com.tangem.datasource.local.token.StakingBalanceStore
 import com.tangem.datasource.local.token.StakingYieldsStore
-import com.tangem.domain.core.lce.LceFlow
-import com.tangem.domain.core.lce.lceFlow
 import com.tangem.domain.staking.model.StakingApproval
 import com.tangem.domain.staking.model.StakingAvailability
 import com.tangem.domain.staking.model.StakingEntryInfo
-import com.tangem.domain.staking.model.stakekit.NetworkType
-import com.tangem.domain.staking.model.stakekit.Yield
-import com.tangem.domain.staking.model.stakekit.YieldBalance
-import com.tangem.domain.staking.model.stakekit.YieldBalanceList
+import com.tangem.domain.staking.model.stakekit.*
 import com.tangem.domain.staking.model.stakekit.action.StakingAction
 import com.tangem.domain.staking.model.stakekit.action.StakingActionCommonType
+import com.tangem.domain.staking.model.stakekit.action.StakingActionStatus
 import com.tangem.domain.staking.model.stakekit.action.StakingActionType
 import com.tangem.domain.staking.model.stakekit.transaction.ActionParams
 import com.tangem.domain.staking.model.stakekit.transaction.StakingGasEstimate
@ -57,6 +54,7 @@ import com.tangem.utils.coroutines.CoroutineDispatcherProvider
 import com.tangem.utils.extensions.orZero
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.plus
 import kotlinx.coroutines.withContext
 import timber.log.Timber

@ -103,11 +101,9 @@ internal class DefaultStakingRepository(
    private val yieldBalanceConverter = YieldBalanceConverter()
    private val yieldBalanceListConverter = YieldBalanceListConverter(yieldBalanceConverter)

-    private val isYieldBalanceFetching = MutableStateFlow(
-        value = emptyMap<UserWalletId, Boolean>(),
-    )
-
    private val tronStakeKitTransactionAdapter by lazy { moshi.adapter(TronStakeKitTransaction::class.java) }
+    private val networkTypeAdapter by lazy { moshi.adapter(NetworkTypeDTO::class.java) }
+    private val stakingActionStatusAdapter by lazy { moshi.adapter(StakingActionStatusDTO::class.java) }

    override fun getIntegrationKey(cryptoCurrencyId: CryptoCurrency.ID): String = with(cryptoCurrencyId) {
        rawNetworkId.plus(rawCurrencyId)
@ -126,7 +122,7 @@ internal class DefaultStakingRepository(
                    val stakingTokensWithYields = stakeKitApi.getEnabledYields(preferredValidatorsOnly = false)
                        .getOrThrow()

-                    stakingYieldsStore.store(stakingTokensWithYields.data.filter { it.isAvailable })
+                    stakingYieldsStore.store(stakingTokensWithYields.data.filter { it.isAvailable ?: false })
                },
            )
        }
@ -146,12 +142,46 @@ internal class DefaultStakingRepository(
        }
    }

+    override suspend fun getActions(
+        userWalletId: UserWalletId,
+        cryptoCurrency: CryptoCurrency,
+        networkType: NetworkType,
+        stakingActionStatus: StakingActionStatus,
+    ): List<StakingAction> {
+        return withContext(dispatchers.io) {
+            val address = walletManagersFacade.getDefaultAddress(userWalletId, cryptoCurrency.network).orEmpty()
+
+            val networkTypeDto = networkTypeConverter.convertBack(networkType)
+            val networkTypeString = networkTypeDto.extractJsonName()
+
+            val actionStatusDTO = actionStatusConverter.convertBack(stakingActionStatus)
+            val actionStatusString = actionStatusDTO.extractJsonName()
+
+            enterActionResponseConverter.convertListIgnoreErrors(
+                input = stakeKitApi.getActions(
+                    walletAddress = address,
+                    network = networkTypeString,
+                    status = actionStatusString,
+                ).getOrThrow().data,
+                onError = { Timber.e("Error converting staking actions list: $it") },
+            )
+        }
+    }
+
+    private fun NetworkTypeDTO.extractJsonName(): String {
+        return networkTypeAdapter.toJson(this).replace("\"", "")
+    }
+
+    private fun StakingActionStatusDTO.extractJsonName(): String {
+        return stakingActionStatusAdapter.toJson(this).replace("\"", "")
+    }
+
    override suspend fun getEntryInfo(cryptoCurrencyId: CryptoCurrency.ID, symbol: String): StakingEntryInfo {
        return withContext(dispatchers.io) {
            val yield = getYield(cryptoCurrencyId, symbol)

            StakingEntryInfo(
-                apr = requireNotNull(yield.validators.maxByOrNull { it.apr.orZero() }?.apr),
+                apr = requireNotNull(yield.preferredValidators.maxByOrNull { it.apr.orZero() }?.apr),
                rewardSchedule = yield.metadata.rewardSchedule,
                tokenSymbol = yield.token.symbol,
            )
@ -207,23 +237,21 @@ internal class DefaultStakingRepository(
    ): StakingAction {
        return withContext(dispatchers.io) {
            val response = when (params.actionCommonType) {
-                StakingActionCommonType.ENTER -> stakeKitApi.createEnterAction(
+                StakingActionCommonType.Enter -> stakeKitApi.createEnterAction(
                    createActionRequestBody(
                        userWalletId,
                        network,
                        params,
                    ),
                )
-                StakingActionCommonType.EXIT -> stakeKitApi.createExitAction(
+                StakingActionCommonType.Exit -> stakeKitApi.createExitAction(
                    createActionRequestBody(
                        userWalletId,
                        network,
                        params,
                    ),
                )
-                StakingActionCommonType.PENDING_OTHER,
-                StakingActionCommonType.PENDING_REWARDS,
-                -> stakeKitApi.createPendingAction(
+                is StakingActionCommonType.Pending -> stakeKitApi.createPendingAction(
                    createPendingActionRequestBody(params),
                )
            }
@ -239,23 +267,21 @@ internal class DefaultStakingRepository(
    ): StakingGasEstimate {
        return withContext(dispatchers.io) {
            val gasEstimateDTO = when (params.actionCommonType) {
-                StakingActionCommonType.ENTER -> stakeKitApi.estimateGasOnEnter(
+                StakingActionCommonType.Enter -> stakeKitApi.estimateGasOnEnter(
                    createActionRequestBody(
                        userWalletId,
                        network,
                        params,
                    ),
                )
-                StakingActionCommonType.EXIT -> stakeKitApi.estimateGasOnExit(
+                StakingActionCommonType.Exit -> stakeKitApi.estimateGasOnExit(
                    createActionRequestBody(
                        userWalletId,
                        network,
                        params,
                    ),
                )
-                StakingActionCommonType.PENDING_REWARDS,
-                StakingActionCommonType.PENDING_OTHER,
-                -> stakeKitApi.estimateGasOnPending(
+                is StakingActionCommonType.Pending -> stakeKitApi.estimateGasOnPending(
                    createPendingActionRequestBody(params),
                )
            }
@ -389,88 +415,66 @@ internal class DefaultStakingRepository(
        refresh: Boolean,
    ) = withContext(dispatchers.io) {
        if (!stakingFeatureToggle.isStakingEnabled) return@withContext
-        try {
-            isYieldBalanceFetching.update {
-                it + (userWalletId to true)
-            }
-            cacheRegistry.invokeOnExpire(
-                key = getYieldBalancesKey(userWalletId),
-                skipCache = refresh,
-                block = {
-                    val yields = getEnabledYields()
-                    val availableCurrencies = cryptoCurrencies
-                        .mapNotNull { currency ->
-                            val addresses = walletManagersFacade.getAddresses(userWalletId, currency.network)
-                            val integrationId = integrationIdMap[getIntegrationKey(currency.id)]

-                            if (integrationId != null && yields.any { it.id == integrationId }) {
-                                addresses to integrationId
-                            } else {
-                                null
-                            }
-                        }
-                        .flatMap { (addresses, integrationId) ->
-                            addresses.map { address -> address to integrationId }
-                        }
-                        .map { getBalanceRequestData(it.first.value, it.second) }
-                        .ifEmpty {
-                            cacheRegistry.invalidate(getYieldBalancesKey(userWalletId))
-                            error("No addresses found")
-                        }
-                    val result = stakeKitApi.getMultipleYieldBalances(availableCurrencies).getOrThrow()
+        cacheRegistry.invokeOnExpire(
+            key = getYieldBalancesKey(userWalletId),
+            skipCache = refresh,
+            block = {
+                val yields = getEnabledYields().ifEmpty {
+                    Timber.i("No enabled yields for $userWalletId")
+                    stakingBalanceStore.store(userWalletId, emptySet())

-                    stakingBalanceStore.store(userWalletId, result)
-                },
-            )
-        } finally {
-            isYieldBalanceFetching.update {
-                it - userWalletId
-            }
-        }
+                    return@invokeOnExpire
+                }
+                val availableCurrencies = cryptoCurrencies
+                    .mapNotNull { currency ->
+                        val addresses = walletManagersFacade.getAddresses(userWalletId, currency.network)
+                        val integrationId = integrationIdMap[getIntegrationKey(currency.id)]
+
+                        if (integrationId != null && yields.any { it.id == integrationId }) {
+                            addresses to integrationId
+                        } else {
+                            null
+                        }
+                    }
+                    .flatMap { (addresses, integrationId) ->
+                        addresses.map { address -> address to integrationId }
+                    }
+                    .map { getBalanceRequestData(it.first.value, it.second) }
+                    .ifEmpty {
+                        Timber.i("No yield balances available for $userWalletId")
+                        stakingBalanceStore.store(userWalletId, emptySet())
+
+                        cacheRegistry.invalidate(getYieldBalancesKey(userWalletId))
+
+                        return@invokeOnExpire
+                    }
+
+                val result = stakeKitApi
+                    .getMultipleYieldBalances(availableCurrencies)
+                    .getOrThrow()
+
+                stakingBalanceStore.store(userWalletId, result)
+            },
+        )
    }

-    override fun getMultiYieldBalanceFlow(
+    override fun getMultiYieldBalanceUpdates(
        userWalletId: UserWalletId,
        cryptoCurrencies: List<CryptoCurrency>,
    ): Flow<YieldBalanceList> = channelFlow {
        if (!stakingFeatureToggle.isStakingEnabled) {
            send(YieldBalanceList.Empty)
        } else {
-            launch(dispatchers.io) {
-                stakingBalanceStore.get(userWalletId)
-                    .collectLatest { send(yieldBalanceListConverter.convert(it)) }
-            }
+            stakingBalanceStore.get(userWalletId)
+                .onEach {
+                    val balances = yieldBalanceListConverter.convert(it)
+                    send(balances)
+                }
+                .launchIn(scope = this + dispatchers.io)

            withContext(dispatchers.io) {
-                fetchMultiYieldBalance(
-                    userWalletId,
-                    cryptoCurrencies,
-                )
-            }
-        }
-    }.cancellable()
-
-    override fun getMultiYieldBalanceLce(
-        userWalletId: UserWalletId,
-        cryptoCurrencies: List<CryptoCurrency>,
-    ): LceFlow<Throwable, YieldBalanceList> = lceFlow {
-        if (!stakingFeatureToggle.isStakingEnabled) {
-            send(YieldBalanceList.Empty)
-        } else {
-            launch(dispatchers.io) {
-                combine(
-                    stakingBalanceStore.get(userWalletId),
-                    isYieldBalanceFetching.map { it.getOrElse(userWalletId) { false } },
-                ) { result, isFetching ->
-                    val balances = yieldBalanceListConverter.convert(result)
-                    send(balances, isStillLoading = isFetching)
-                }.collect()
-            }
-            withContext(dispatchers.io) {
-                catch(
-                    block = { fetchMultiYieldBalance(userWalletId, cryptoCurrencies, refresh = false) },
-                    catch = { raise(it) },
-                )
+                fetchMultiYieldBalance(userWalletId, cryptoCurrencies, refresh = false)
            }
        }
    }
@ -583,9 +587,10 @@ internal class DefaultStakingRepository(
    }

    private fun getEnabledYields(): List<Yield> {
-        return stakingYieldsStore
-            .get()
-            .map { yieldConverter.convert(it) }
+        return yieldConverter.convertListIgnoreErrors(
+            input = stakingYieldsStore.get(),
+            onError = { Timber.e("Error converting enabled yields list: $it") },
+        )
    }

    private fun getBalanceRequestData(address: String, integrationId: String): YieldBalanceRequestBody {
@ -640,7 +645,7 @@ internal class DefaultStakingRepository(
            Blockchain.Tron.run { id + toCoinId() } to TRON_INTEGRATION_ID,
            Blockchain.Ethereum.id + Blockchain.Polygon.toMigratedCointId() to ETHEREUM_POLYGON_INTEGRATION_ID,
            // Blockchain.Ethereum.id + Blockchain.Polygon.toCoinId() to ETHEREUM_POLYGON_INTEGRATION_ID,
-            // Blockchain.BSC.run { id + toCoinId() } to BINANCE_INTEGRATION_ID,
+            Blockchain.BSC.run { id + toCoinId() } to BINANCE_INTEGRATION_ID,
            // Blockchain.Polkadot.run { id + toCoinId() } to POLKADOT_INTEGRATION_ID,
            // Blockchain.Avalanche.run { id + toCoinId() } to AVALANCHE_INTEGRATION_ID,
            // Blockchain.Cronos.run { id + toCoinId() } to CRONOS_INTEGRATION_ID,
--- a/data/staking/src/main/java/com/tangem/data/staking/PendingTransactionItemConverter.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/PendingTransactionItemConverter.kt
@ -1,23 +0,0 @@
-package com.tangem.data.staking
-
-import com.tangem.domain.staking.model.PendingTransaction
-import com.tangem.domain.staking.model.stakekit.BalanceItem
-import com.tangem.utils.converter.Converter
-import org.joda.time.DateTime
-
-internal object PendingTransactionItemConverter : Converter<PendingTransaction, BalanceItem?> {
-
-    override fun convert(value: PendingTransaction): BalanceItem? {
-        return BalanceItem(
-            groupId = value.groupId ?: return null,
-            token = value.token,
-            type = value.type,
-            amount = value.amount,
-            rawCurrencyId = value.rawCurrencyId,
-            validatorAddress = value.validator?.address,
-            date = DateTime.now(),
-            pendingActions = emptyList(),
-            isPending = true,
-        )
-    }
-}
--- a/data/staking/src/main/java/com/tangem/data/staking/converters/YieldConverter.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/converters/YieldConverter.kt
@ -17,37 +17,37 @@ class YieldConverter(

    override fun convert(value: YieldDTO): Yield {
        return Yield(
-            id = value.id,
-            token = tokenConverter.convert(value.token),
-            tokens = value.tokens.map { tokenConverter.convert(it) },
-            args = convertArgs(value.args),
-            status = convertStatus(value.status),
-            apy = value.apy,
-            rewardRate = value.rewardRate,
-            rewardType = convertRewardType(value.rewardType),
-            metadata = convertMetadata(value.metadata),
-            validators = value.validators
+            id = value.id.asMandatory("id"),
+            token = tokenConverter.convert(value.token.asMandatory("token")),
+            tokens = value.tokens.asMandatory("tokens").map { tokenConverter.convert(it) },
+            args = convertArgs(value.args.asMandatory("args")),
+            status = convertStatus(value.status.asMandatory("status")),
+            apy = value.apy.asMandatory("apy"),
+            rewardRate = value.rewardRate.asMandatory("rewardRate"),
+            rewardType = convertRewardType(value.rewardType.asMandatory("rewardType")),
+            metadata = convertMetadata(value.metadata.asMandatory("metadata")),
+            validators = value.validators.asMandatory("validators")
                .asSequence()
                .filter { it.status == ValidatorStatusDTO.ACTIVE }
                .map { convertValidator(it) }
                .sortedByDescending { it.isStrategicPartner }
                .sortedByDescending { it.apr }
                .toImmutableList(),
-            isAvailable = value.isAvailable,
+            isAvailable = value.isAvailable.asMandatory("isAvailable"),
        )
    }

    private fun convertArgs(argsDTO: YieldDTO.ArgsDTO): Yield.Args {
        return Yield.Args(
-            enter = convertEnter(argsDTO.enter),
+            enter = convertEnter(argsDTO.enter.asMandatory("enter")),
            exit = argsDTO.exit?.let { convertEnter(it) },
        )
    }

    private fun convertEnter(enterDTO: YieldDTO.ArgsDTO.Enter): Yield.Args.Enter {
        return Yield.Args.Enter(
-            addresses = convertAddresses(enterDTO.addresses),
-            args = enterDTO.args
+            addresses = convertAddresses(enterDTO.addresses.asMandatory("addresses")),
+            args = enterDTO.args.asMandatory("args")
                .mapKeys { convertArgType(it.key) }
                .mapValues { convertAddressArgument(it.value) },
        )
@ -55,7 +55,7 @@ class YieldConverter(

    private fun convertAddresses(addressesDTO: YieldDTO.ArgsDTO.Enter.Addresses): Yield.Args.Enter.Addresses {
        return Yield.Args.Enter.Addresses(
-            address = convertAddressArgument(addressesDTO.address),
+            address = convertAddressArgument(addressesDTO.address.asMandatory("address")),
            additionalAddresses = addressesDTO.additionalAddresses
                ?.mapKeys { convertArgType(it.key) }
                ?.mapValues { convertAddressArgument(it.value) },
@ -73,48 +73,51 @@ class YieldConverter(

    private fun convertStatus(statusDTO: YieldDTO.StatusDTO): Yield.Status {
        return Yield.Status(
-            enter = statusDTO.enter,
+            enter = statusDTO.enter.asMandatory("enter"),
            exit = statusDTO.exit,
        )
    }

    private fun convertMetadata(metadataDTO: YieldDTO.MetadataDTO): Yield.Metadata {
        return Yield.Metadata(
-            name = metadataDTO.name,
-            logoUri = metadataDTO.logoUri,
-            description = metadataDTO.description,
+            name = metadataDTO.name.asMandatory("name"),
+            logoUri = metadataDTO.logoUri.asMandatory("logoUri"),
+            description = metadataDTO.description.asMandatory("description"),
            documentation = metadataDTO.documentation,
-            gasFeeToken = tokenConverter.convert(metadataDTO.gasFeeTokenDTO),
-            token = tokenConverter.convert(metadataDTO.tokenDTO),
-            tokens = metadataDTO.tokensDTO.map { tokenConverter.convert(it) },
-            type = metadataDTO.type,
-            rewardSchedule = convertRewardSchedule(metadataDTO.rewardSchedule),
+            gasFeeToken = tokenConverter.convert(metadataDTO.gasFeeTokenDTO.asMandatory("gasFeeTokenDTO")),
+            token = tokenConverter.convert(metadataDTO.tokenDTO.asMandatory("tokenDTO")),
+            tokens = metadataDTO.tokensDTO.asMandatory("tokensDTO").map { tokenConverter.convert(it) },
+            type = metadataDTO.type.asMandatory("type"),
+            rewardSchedule = convertRewardSchedule(metadataDTO.rewardSchedule.asMandatory("rewardSchedule")),
            cooldownPeriod = metadataDTO.cooldownPeriod?.let { convertPeriod(it) },
-            warmupPeriod = convertPeriod(metadataDTO.warmupPeriod),
-            rewardClaiming = convertRewardClaiming(metadataDTO.rewardClaiming),
+            warmupPeriod = convertPeriod(metadataDTO.warmupPeriod.asMandatory("warmupPeriod")),
+            rewardClaiming = convertRewardClaiming(metadataDTO.rewardClaiming.asMandatory("rewardClaiming")),
            defaultValidator = metadataDTO.defaultValidator,
            minimumStake = metadataDTO.minimumStake,
-            supportsMultipleValidators = metadataDTO.supportsMultipleValidators,
-            revshare = convertEnabled(metadataDTO.revshare),
-            fee = convertEnabled(metadataDTO.fee),
+            supportsMultipleValidators = metadataDTO.supportsMultipleValidators.asMandatory(
+                "supportsMultipleValidators",
+            ),
+            revshare = convertEnabled(metadataDTO.revshare.asMandatory("revshare")),
+            fee = convertEnabled(metadataDTO.fee.asMandatory("fee")),
        )
    }

    private fun convertPeriod(periodDTO: YieldDTO.MetadataDTO.PeriodDTO): Yield.Metadata.Period {
        return Yield.Metadata.Period(
-            days = periodDTO.days,
+            days = periodDTO.days.asMandatory("days"),
        )
    }

    private fun convertEnabled(enabledDTO: YieldDTO.MetadataDTO.EnabledDTO): Yield.Metadata.Enabled {
        return Yield.Metadata.Enabled(
-            enabled = enabledDTO.enabled,
+            enabled = enabledDTO.enabled.asMandatory("enabled"),
        )
    }

    private fun convertValidator(validatorDTO: YieldDTO.ValidatorDTO): Yield.Validator {
+        val address = validatorDTO.address.asMandatory("address")
        return Yield.Validator(
-            address = validatorDTO.address,
+            address = address,
            status = convertValidatorStatus(validatorDTO.status),
            name = validatorDTO.name,
            image = validatorDTO.image,
@ -177,7 +180,7 @@ class YieldConverter(
        }
    }

-    private fun isStrategicPartner(validatorAddress: String, validatorName: String): Boolean {
+    private fun isStrategicPartner(validatorAddress: String?, validatorName: String): Boolean {
        return PARTNERS.any { it == validatorAddress } || PARTNERS_NAMES.any { it.equals(validatorName, true) }
    }

--- a/data/staking/src/main/java/com/tangem/data/staking/converters/action/ActionStatusConverter.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/converters/action/ActionStatusConverter.kt
@ -2,9 +2,10 @@ package com.tangem.data.staking.converters.action

 import com.tangem.datasource.api.stakekit.models.response.model.action.StakingActionStatusDTO
 import com.tangem.domain.staking.model.stakekit.action.StakingActionStatus
-import com.tangem.utils.converter.Converter
+import com.tangem.utils.converter.TwoWayConverter
+
+class ActionStatusConverter : TwoWayConverter<StakingActionStatusDTO, StakingActionStatus> {

-class ActionStatusConverter : Converter<StakingActionStatusDTO, StakingActionStatus> {
    override fun convert(value: StakingActionStatusDTO): StakingActionStatus {
        return when (value) {
            StakingActionStatusDTO.CANCELED -> StakingActionStatus.CANCELED
@ -16,4 +17,16 @@ class ActionStatusConverter : Converter<StakingActionStatusDTO, StakingActionSta
            else -> StakingActionStatus.UNKNOWN
        }
    }
+
+    override fun convertBack(value: StakingActionStatus): StakingActionStatusDTO {
+        return when (value) {
+            StakingActionStatus.CANCELED -> StakingActionStatusDTO.CANCELED
+            StakingActionStatus.CREATED -> StakingActionStatusDTO.CREATED
+            StakingActionStatus.WAITING_FOR_NEXT -> StakingActionStatusDTO.WAITING_FOR_NEXT
+            StakingActionStatus.PROCESSING -> StakingActionStatusDTO.PROCESSING
+            StakingActionStatus.FAILED -> StakingActionStatusDTO.FAILED
+            StakingActionStatus.SUCCESS -> StakingActionStatusDTO.SUCCESS
+            else -> StakingActionStatusDTO.UNKNOWN
+        }
+    }
 }
--- a/data/staking/src/main/java/com/tangem/data/staking/converters/action/EnterActionResponseConverter.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/converters/action/EnterActionResponseConverter.kt
@ -1,7 +1,7 @@
 package com.tangem.data.staking.converters.action

 import com.tangem.data.staking.converters.transaction.StakingTransactionConverter
-import com.tangem.datasource.api.stakekit.models.response.EnterActionResponse
+import com.tangem.datasource.api.stakekit.models.response.ActionDTO
 import com.tangem.domain.staking.model.stakekit.action.StakingAction
 import com.tangem.utils.converter.Converter

@ -9,9 +9,9 @@ class EnterActionResponseConverter(
    private val actionStatusConverter: ActionStatusConverter,
    private val stakingActionTypeConverter: StakingActionTypeConverter,
    private val transactionConverter: StakingTransactionConverter,
-) : Converter<EnterActionResponse, StakingAction> {
+) : Converter<ActionDTO, StakingAction> {

-    override fun convert(value: EnterActionResponse): StakingAction {
+    override fun convert(value: ActionDTO): StakingAction {
        return StakingAction(
            id = value.id,
            integrationId = value.integrationId,
--- a/data/staking/src/main/java/com/tangem/data/staking/di/StakingDataModule.kt
+++ b/data/staking/src/main/java/com/tangem/data/staking/di/StakingDataModule.kt
@ -3,8 +3,8 @@ package com.tangem.data.staking.di
 import com.squareup.moshi.Moshi
 import com.tangem.core.analytics.api.AnalyticsEventHandler
 import com.tangem.data.common.cache.CacheRegistry
+import com.tangem.data.staking.*
 import com.tangem.data.staking.DefaultStakingErrorResolver
-import com.tangem.data.staking.DefaultStakingPendingTransactionRepository
 import com.tangem.data.staking.DefaultStakingRepository
 import com.tangem.data.staking.DefaultStakingTransactionHashRepository
 import com.tangem.data.staking.converters.error.StakeKitErrorConverter
@ -12,12 +12,10 @@ import com.tangem.datasource.api.stakekit.StakeKitApi
 import com.tangem.datasource.api.stakekit.models.response.model.error.StakeKitErrorResponse
 import com.tangem.datasource.di.NetworkMoshi
 import com.tangem.datasource.local.preferences.AppPreferencesStore
+import com.tangem.datasource.local.token.StakingActionsStore
 import com.tangem.datasource.local.token.StakingBalanceStore
 import com.tangem.datasource.local.token.StakingYieldsStore
-import com.tangem.domain.staking.repositories.StakingErrorResolver
-import com.tangem.domain.staking.repositories.StakingPendingTransactionRepository
-import com.tangem.domain.staking.repositories.StakingRepository
-import com.tangem.domain.staking.repositories.StakingTransactionHashRepository
+import com.tangem.domain.staking.repositories.*
 import com.tangem.domain.walletmanager.WalletManagersFacade
 import com.tangem.domain.wallets.usecase.GetUserWalletUseCase
 import com.tangem.features.staking.api.featuretoggles.StakingFeatureToggles
@ -74,8 +72,14 @@ internal object StakingDataModule {

    @Provides
    @Singleton
-    fun provideStakingPendingTransactionRepository(): StakingPendingTransactionRepository {
-        return DefaultStakingPendingTransactionRepository()
+    fun provideStakingActionRepository(
+        stakingActionsStore: StakingActionsStore,
+        dispatchers: CoroutineDispatcherProvider,
+    ): StakingActionRepository {
+        return DefaultStakingActionRepository(
+            stakingActionsStore = stakingActionsStore,
+            dispatchers = dispatchers,
+        )
    }

    @Provides