diff --git a/data/yield-supply/src/main/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepository.kt b/data/yield-supply/src/main/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepository.kt index 86c802d7db..d804ebb1c3 100644 --- a/data/yield-supply/src/main/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepository.kt +++ b/data/yield-supply/src/main/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepository.kt @@ -30,6 +30,7 @@ internal class DefaultYieldSupplyTransactionRepository( override suspend fun createEnterTransactions( userWalletId: UserWalletId, cryptoCurrencyStatus: CryptoCurrencyStatus, + maxNetworkFee: BigDecimal, ): List { val cryptoCurrency = cryptoCurrencyStatus.currency @@ -62,6 +63,7 @@ internal class DefaultYieldSupplyTransactionRepository( existingYieldContractAddress = existingYieldContractAddress, calculatedYieldContractAddress = calculatedYieldContractAddress, yieldTokenStatus = yieldTokenStatus, + maxNetworkFee = maxNetworkFee, ) } @@ -93,12 +95,14 @@ internal class DefaultYieldSupplyTransactionRepository( ) } + @Suppress("LongParameterList") private fun buildEnterTransactions( walletManager: WalletManager, cryptoCurrency: CryptoCurrency.Token, existingYieldContractAddress: String?, calculatedYieldContractAddress: String, yieldTokenStatus: YieldSupplyStatus?, + maxNetworkFee: BigDecimal, ): MutableList { val enterTransactions = mutableListOf() @@ -108,6 +112,7 @@ internal class DefaultYieldSupplyTransactionRepository( createDeployTransaction( walletManager = walletManager, cryptoCurrency = cryptoCurrency, + maxNetworkFee = maxNetworkFee, ), ) } @@ -118,6 +123,7 @@ internal class DefaultYieldSupplyTransactionRepository( cryptoCurrency = cryptoCurrency, yieldSupplyStatus = yieldTokenStatus, yieldContractAddress = calculatedYieldContractAddress, + maxNetworkFee = maxNetworkFee, ), ) !yieldTokenStatus.isActive -> enterTransactions.add( @@ -126,6 +132,7 @@ internal class DefaultYieldSupplyTransactionRepository( cryptoCurrency = cryptoCurrency, yieldSupplyStatus = yieldTokenStatus, yieldContractAddress = calculatedYieldContractAddress, + maxNetworkFee = maxNetworkFee, ), ) else -> Unit @@ -202,6 +209,7 @@ internal class DefaultYieldSupplyTransactionRepository( isActive = sdkSupplyStatus?.isActive == true, isInitialized = sdkSupplyStatus?.isInitialized == true, isAllowedToSpend = isAllowedToSpend, + // maxNetworkFee = sdkSupplyStatus?.maxNetworkFee, ) }.onFailure(Timber::e).getOrNull() } @@ -209,11 +217,12 @@ internal class DefaultYieldSupplyTransactionRepository( private fun createDeployTransaction( walletManager: WalletManager, cryptoCurrency: CryptoCurrency.Token, + maxNetworkFee: BigDecimal, ): TransactionData.Uncompiled { val callData = YieldSupplyContractCallDataProviderFactory.getDeployCallData( tokenContractAddress = cryptoCurrency.contractAddress, walletAddress = walletManager.wallet.address, - maxNetworkFee = MAX_NETWORK_FEE.convertToSdkAmount(cryptoCurrency), + maxNetworkFee = maxNetworkFee.convertToSdkAmount(cryptoCurrency), ) val factoryContractAddress = walletManager.getYieldSupplyContractAddresses()?.factoryContractAddress @@ -234,10 +243,11 @@ internal class DefaultYieldSupplyTransactionRepository( cryptoCurrency: CryptoCurrency.Token, yieldContractAddress: String, yieldSupplyStatus: YieldSupplyStatus, + maxNetworkFee: BigDecimal, ): TransactionData.Uncompiled { val callData = YieldSupplyContractCallDataProviderFactory.getInitTokenCallData( tokenContractAddress = cryptoCurrency.contractAddress, - maxNetworkFee = MAX_NETWORK_FEE.convertToSdkAmount(cryptoCurrency), + maxNetworkFee = maxNetworkFee.convertToSdkAmount(cryptoCurrency), ) return createTransaction( @@ -255,10 +265,11 @@ internal class DefaultYieldSupplyTransactionRepository( cryptoCurrency: CryptoCurrency.Token, yieldContractAddress: String, yieldSupplyStatus: YieldSupplyStatus, + maxNetworkFee: BigDecimal, ): TransactionData.Uncompiled { val callData = YieldSupplyContractCallDataProviderFactory.getReactivateTokenCallData( tokenContractAddress = cryptoCurrency.contractAddress, - maxNetworkFee = MAX_NETWORK_FEE.convertToSdkAmount(cryptoCurrency), + maxNetworkFee = maxNetworkFee.convertToSdkAmount(cryptoCurrency), ) return createTransaction( @@ -364,8 +375,4 @@ internal class DefaultYieldSupplyTransactionRepository( isAllowedToSpend = yieldSupplyStatus?.isAllowedToSpend ?: false, ), ) - - private companion object { - val MAX_NETWORK_FEE: BigDecimal = BigDecimal.TEN // TODO for TESTNET only - } } \ No newline at end of file diff --git a/data/yield-supply/src/test/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepositoryTest.kt b/data/yield-supply/src/test/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepositoryTest.kt index 069e3630f8..a31cac1f50 100644 --- a/data/yield-supply/src/test/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepositoryTest.kt +++ b/data/yield-supply/src/test/java/com/tangem/data/yield/supply/DefaultYieldSupplyTransactionRepositoryTest.kt @@ -16,7 +16,6 @@ import com.tangem.domain.models.yield.supply.YieldSupplyStatus import com.tangem.domain.utils.convertToSdkAmount import com.tangem.domain.walletmanager.WalletManagersFacade import com.tangem.utils.coroutines.TestingCoroutineDispatcherProvider -import com.tangem.blockchain.yieldsupply.providers.YieldSupplyStatus as SDKYieldSupplyStatus import io.mockk.coEvery import io.mockk.every import io.mockk.mockk @@ -26,6 +25,7 @@ import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.TestInstance import java.math.BigDecimal +import com.tangem.blockchain.yieldsupply.providers.YieldSupplyStatus as SDKYieldSupplyStatus @TestInstance(TestInstance.Lifecycle.PER_CLASS) class DefaultYieldSupplyTransactionRepositoryTest { @@ -74,7 +74,11 @@ class DefaultYieldSupplyTransactionRepositoryTest { coEvery { walletManager.isAllowedToSpend(any()) } returns false coEvery { walletManager.calculateYieldContract() } returns yieldContractAddress - val result = repository.createEnterTransactions(userWalletId, cryptoCurrencyStatus) + val result = repository.createEnterTransactions( + userWalletId = userWalletId, + cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = BigDecimal.TEN, + ) // Assert that 3 transactions are returned: deploy, approve, enter Truth.assertThat(result).isNotNull() @@ -117,13 +121,18 @@ class DefaultYieldSupplyTransactionRepositoryTest { fun `createEnterTransactions returns init-approve-enter transactions`() = runTest { coEvery { walletManager.getYieldContract() } returns yieldContractAddress coEvery { walletManager.calculateYieldContract() } returns yieldContractAddress + coEvery { walletManager.isAllowedToSpend(any()) } returns false coEvery { walletManager.getYieldSupplyStatus(any()) } returns SDKYieldSupplyStatus( isActive = false, isInitialized = false, maxNetworkFee = BigDecimal.TEN, ) - val result = repository.createEnterTransactions(userWalletId, cryptoCurrencyStatus) + val result = repository.createEnterTransactions( + userWalletId = userWalletId, + cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = BigDecimal.TEN, + ) // Assert that 3 transactions are returned: init token, approve, enter Truth.assertThat(result).isNotNull() @@ -165,13 +174,18 @@ class DefaultYieldSupplyTransactionRepositoryTest { fun `createEnterTransactions returns reactivate-approve-enter transactions`() = runTest { coEvery { walletManager.getYieldContract() } returns yieldContractAddress coEvery { walletManager.calculateYieldContract() } returns yieldContractAddress + coEvery { walletManager.isAllowedToSpend(any()) } returns false coEvery { walletManager.getYieldSupplyStatus(any()) } returns SDKYieldSupplyStatus( isActive = false, isInitialized = true, maxNetworkFee = BigDecimal.TEN, ) - val result = repository.createEnterTransactions(userWalletId, cryptoCurrencyStatus) + val result = repository.createEnterTransactions( + userWalletId = userWalletId, + cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = BigDecimal.TEN, + ) // Assert that 3 transactions are returned: reactivate token, approve, enter Truth.assertThat(result).isNotNull() @@ -220,7 +234,11 @@ class DefaultYieldSupplyTransactionRepositoryTest { ) coEvery { walletManager.isAllowedToSpend(any()) } returns true - val result = repository.createEnterTransactions(userWalletId, cryptoCurrencyStatus) + val result = repository.createEnterTransactions( + userWalletId = userWalletId, + cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = BigDecimal.TEN, + ) // Assert that 2 transactions are returned: approve, enter Truth.assertThat(result).isNotNull() @@ -257,7 +275,11 @@ class DefaultYieldSupplyTransactionRepositoryTest { ) coEvery { walletManager.isAllowedToSpend(any()) } returns true - val result = repository.createEnterTransactions(userWalletId, cryptoCurrencyStatus) + val result = repository.createEnterTransactions( + userWalletId = userWalletId, + cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = BigDecimal.TEN, + ) // Assert that transaction is returned: enter Truth.assertThat(result).isNotNull() diff --git a/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/YieldSupplyTransactionRepository.kt b/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/YieldSupplyTransactionRepository.kt index 34a17c1905..17b679579a 100644 --- a/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/YieldSupplyTransactionRepository.kt +++ b/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/YieldSupplyTransactionRepository.kt @@ -6,12 +6,14 @@ import com.tangem.domain.models.currency.CryptoCurrency import com.tangem.domain.models.currency.CryptoCurrencyStatus import com.tangem.domain.models.wallet.UserWalletId import com.tangem.domain.models.yield.supply.YieldSupplyStatus +import java.math.BigDecimal interface YieldSupplyTransactionRepository { suspend fun createEnterTransactions( userWalletId: UserWalletId, cryptoCurrencyStatus: CryptoCurrencyStatus, + maxNetworkFee: BigDecimal, ): List suspend fun createExitTransaction( diff --git a/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/usecase/YieldSupplyStartEarningUseCase.kt b/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/usecase/YieldSupplyStartEarningUseCase.kt index b5e73e680f..a9ee4d9c8f 100644 --- a/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/usecase/YieldSupplyStartEarningUseCase.kt +++ b/domain/yield-supply/src/main/java/com/tangem/domain/yield/supply/usecase/YieldSupplyStartEarningUseCase.kt @@ -5,6 +5,7 @@ import com.tangem.blockchain.common.TransactionData import com.tangem.domain.models.currency.CryptoCurrencyStatus import com.tangem.domain.models.wallet.UserWalletId import com.tangem.domain.yield.supply.YieldSupplyTransactionRepository +import java.math.BigDecimal class YieldSupplyStartEarningUseCase( private val yieldSupplyTransactionRepository: YieldSupplyTransactionRepository, @@ -13,10 +14,12 @@ class YieldSupplyStartEarningUseCase( suspend operator fun invoke( userWalletId: UserWalletId, cryptoCurrencyStatus: CryptoCurrencyStatus, + maxNetworkFee: BigDecimal, ): Either> = Either.catch { yieldSupplyTransactionRepository.createEnterTransactions( userWalletId = userWalletId, cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = maxNetworkFee, ) } } \ No newline at end of file diff --git a/domain/yield-supply/src/test/java/com/tangem/domain/yield/supply/YieldSupplyEstimateEnterFeeUseCaseTest.kt b/domain/yield-supply/src/test/java/com/tangem/domain/yield/supply/YieldSupplyEstimateEnterFeeUseCaseTest.kt index a38b1d1f15..1cff840e6d 100644 --- a/domain/yield-supply/src/test/java/com/tangem/domain/yield/supply/YieldSupplyEstimateEnterFeeUseCaseTest.kt +++ b/domain/yield-supply/src/test/java/com/tangem/domain/yield/supply/YieldSupplyEstimateEnterFeeUseCaseTest.kt @@ -2,9 +2,14 @@ package com.tangem.domain.yield.supply import arrow.core.Either import com.google.common.truth.Truth +import com.tangem.blockchain.blockchains.ethereum.EthereumTransactionExtras +import com.tangem.blockchain.common.Blockchain import com.tangem.blockchain.common.TransactionData +import com.tangem.blockchain.common.TransactionExtras +import com.tangem.blockchain.common.smartcontract.SmartContractCallDataProviderFactory import com.tangem.blockchain.common.transaction.Fee import com.tangem.blockchain.common.transaction.TransactionFee +import com.tangem.blockchain.yieldsupply.YieldSupplyContractCallDataProviderFactory import com.tangem.domain.models.currency.CryptoCurrency import com.tangem.domain.models.wallet.UserWallet import com.tangem.domain.transaction.FeeRepository @@ -50,123 +55,187 @@ class YieldSupplyEstimateEnterFeeUseCaseTest { amount = BigDecimal.ONE.convertToSdkAmount(cryptoCurrency), ) - private fun uncompiled(fee: Fee) = TransactionData.Uncompiled( + private fun uncompiled(fee: Fee, extras: TransactionExtras) = TransactionData.Uncompiled( fee = fee, amount = BigDecimal.ONE.convertToSdkAmount(cryptoCurrency), contractAddress = null, sourceAddress = "0x1234567890123456789012345678901234567890", destinationAddress = "0x1234567890123456789012345678901234567890", + extras = extras, ) @Test - fun `test 1 transaction uses constant gas limit Legacy`() = runTest { + fun `test enter transaction uses constant gas limit Legacy`() = runTest { val fee = TransactionFee.Single(ethLegacyFee()) - val tx = uncompiled(ethLegacyFee()) coEvery { feeRepository.calculateFee(any(), any(), any()) } returns fee - val result = useCase(userWallet, cryptoCurrency, listOf(tx)) + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getDeployTx(), + getEnterTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(1) - val lastFee = txs.last().fee as Fee.Ethereum.Legacy - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.Legacy + val enterFee = txs.last().fee as Fee.Ethereum.Legacy + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(enterFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) } @Test - fun `test 2 transactions, only last uses constant gas limit Legacy`() = runTest { + fun `test not enter transaction uses gas limit Legacy`() = runTest { val fee = TransactionFee.Single(ethLegacyFee()) - val tx = uncompiled(ethLegacyFee()) coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee) - val result = useCase(userWallet, cryptoCurrency, listOf(tx, tx)) + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getDeployTx(), + getApproveTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(2) - val firstFee = txs.first().fee as Fee.Ethereum.Legacy - val lastFee = txs.last().fee as Fee.Ethereum.Legacy - Truth.assertThat(firstFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.Legacy + val approveFee = txs.last().fee as Fee.Ethereum.Legacy + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(approveFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) } @Test - fun `test 3 transactions, only last uses constant gas limit Legacy`() = runTest { + fun `test enter transaction with wrong order uses gas limit Legacy`() = runTest { val fee = TransactionFee.Single(ethLegacyFee()) - val tx = uncompiled(ethLegacyFee()) - coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee, fee) - val result = useCase(userWallet, cryptoCurrency, listOf(tx, tx, tx)) + coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee) + + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getEnterTx(), + getDeployTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(3) - val firstFee = txs[0].fee as Fee.Ethereum.Legacy - val secondFee = txs[1].fee as Fee.Ethereum.Legacy - val lastFee = txs[2].fee as Fee.Ethereum.Legacy - Truth.assertThat(firstFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(secondFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.Legacy + val enterFee = txs.last().fee as Fee.Ethereum.Legacy + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(enterFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) } @Test - fun `test 1 transaction uses constant gas limit Eip1559`() = runTest { + fun `test enter transaction uses constant gas limit Eip1559`() = runTest { val fee = TransactionFee.Single(ethEip1559Fee()) - val tx = uncompiled(ethEip1559Fee()) coEvery { feeRepository.calculateFee(any(), any(), any()) } returns fee - val result = useCase(userWallet, cryptoCurrency, listOf(tx)) + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getDeployTx(), + getEnterTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(1) - val lastFee = txs.last().fee as Fee.Ethereum.EIP1559 - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.EIP1559 + val enterFee = txs.last().fee as Fee.Ethereum.EIP1559 + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(enterFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) } @Test - fun `test 2 transactions, only last uses constant gas limit Eip1559`() = runTest { + fun `test not enter transaction uses gas limit Eip1559`() = runTest { val fee = TransactionFee.Single(ethEip1559Fee()) - val tx = uncompiled(ethEip1559Fee()) coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee) - val result = useCase(userWallet, cryptoCurrency, listOf(tx, tx)) + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getDeployTx(), + getApproveTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(2) - val firstFee = txs.first().fee as Fee.Ethereum.EIP1559 - val lastFee = txs.last().fee as Fee.Ethereum.EIP1559 - Truth.assertThat(firstFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.EIP1559 + val approveFee = txs.last().fee as Fee.Ethereum.EIP1559 + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(approveFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) } @Test - fun `test 3 transactions, only last uses constant gas limit Eip1559`() = runTest { + fun `test enter transaction with wrong order uses gas limit Eip1559`() = runTest { val fee = TransactionFee.Single(ethEip1559Fee()) - val tx = uncompiled(ethEip1559Fee()) - coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee, fee) - val result = useCase(userWallet, cryptoCurrency, listOf(tx, tx, tx)) + coEvery { feeRepository.calculateFee(any(), any(), any()) } returnsMany listOf(fee, fee) + + val result = useCase( + userWallet = userWallet, + cryptoCurrency = cryptoCurrency, + transactionDataList = listOf( + getEnterTx(), + getDeployTx(), + ), + ) Truth.assertThat(result.isRight()).isTrue() val txs = (result as Either.Right).value - Truth.assertThat(txs.size).isEqualTo(3) - val firstFee = txs[0].fee as Fee.Ethereum.EIP1559 - val secondFee = txs[1].fee as Fee.Ethereum.EIP1559 - val lastFee = txs[2].fee as Fee.Ethereum.EIP1559 - Truth.assertThat(firstFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(secondFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) - Truth.assertThat(lastFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) + val deployFee = txs.first().fee as Fee.Ethereum.EIP1559 + val enterFee = txs.last().fee as Fee.Ethereum.EIP1559 + Truth.assertThat(deployFee.gasLimit).isEqualTo(BigInteger.valueOf(21_000)) + Truth.assertThat(enterFee.gasLimit).isEqualTo(BigInteger.valueOf(350_000)) } + + private fun getDeployTx() = uncompiled( + fee = ethLegacyFee(), + extras = EthereumTransactionExtras( + YieldSupplyContractCallDataProviderFactory.getDeployCallData( + walletAddress = "0x1234567890123456789012345678901234567890", + tokenContractAddress = "0x1234567890123456789012345678901234567890", + maxNetworkFee = BigDecimal.ONE.convertToSdkAmount(cryptoCurrency), + ), + ), + ) + + private fun getApproveTx() = uncompiled( + fee = ethLegacyFee(), + extras = EthereumTransactionExtras( + SmartContractCallDataProviderFactory.getApprovalCallData( + spenderAddress = "0x1234567890123456789012345678901234567890", + amount = null, + blockchain = Blockchain.EthereumTestnet, + ), + ), + ) + + private fun getEnterTx() = uncompiled( + fee = ethLegacyFee(), + extras = EthereumTransactionExtras( + YieldSupplyContractCallDataProviderFactory.getEnterCallData( + tokenContractAddress = "0x1234567890123456789012345678901234567890", + ), + ), + ) } \ No newline at end of file diff --git a/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/main/model/YieldSupplyModel.kt b/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/main/model/YieldSupplyModel.kt index 327f65e671..e8cab11656 100644 --- a/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/main/model/YieldSupplyModel.kt +++ b/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/main/model/YieldSupplyModel.kt @@ -36,7 +36,7 @@ internal class YieldSupplyModel @Inject constructor( private val params = paramsContainer.require() val uiState: StateFlow - field = MutableStateFlow(YieldSupplyUM.Loading) + field = MutableStateFlow(YieldSupplyUM.Loading) val bottomSheetNavigation: SlotNavigation = SlotNavigation() @@ -44,12 +44,12 @@ internal class YieldSupplyModel @Inject constructor( var userWallet: UserWallet by Delegates.notNull() val cryptoCurrencyStatusFlow: StateFlow - field = MutableStateFlow( - CryptoCurrencyStatus( - currency = params.cryptoCurrency, - value = CryptoCurrencyStatus.Loading, - ), - ) + field = MutableStateFlow( + CryptoCurrencyStatus( + currency = params.cryptoCurrency, + value = CryptoCurrencyStatus.Loading, + ), + ) init { subscribeOnCurrencyStatusUpdates() diff --git a/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/subcomponents/startearning/model/YieldSupplyStartEarningModel.kt b/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/subcomponents/startearning/model/YieldSupplyStartEarningModel.kt index 25b22b91ae..4119ea3edd 100644 --- a/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/subcomponents/startearning/model/YieldSupplyStartEarningModel.kt +++ b/features/yield-supply/impl/src/main/java/com/tangem/features/yield/supply/impl/subcomponents/startearning/model/YieldSupplyStartEarningModel.kt @@ -106,6 +106,7 @@ internal class YieldSupplyStartEarningModel @Inject constructor( val transactionListData = yieldSupplyStartEarningUseCase( userWalletId = userWallet.walletId, cryptoCurrencyStatus = cryptoCurrencyStatus, + maxNetworkFee = MAX_NETWORK_FEE, ).getOrNull() ?: return val updatedTransactionList = yieldSupplyEstimateEnterFeeUseCase.invoke( @@ -221,4 +222,8 @@ internal class YieldSupplyStartEarningModel @Inject constructor( onLoadFee() } } + + private companion object { + val MAX_NETWORK_FEE: BigDecimal = BigDecimal.TEN // TODO replace with value from api + } } \ No newline at end of file