Hotfix/9.0.2

build.gradle

@@ -1,8 +1,8 @@
 buildscript {
     ext {
         // App version
-        versionName = '9.0.1'
-        versionCode = 159
+        versionName = '9.0.2'
+        versionCode = 161
 
         applicationId = "io.novafoundation.nova"
         releaseApplicationSuffix = "market"
@@ -51,7 +51,7 @@ buildscript {
 
         web3jVersion = '4.9.5'
 
-        substrateSdkVersion = '2.2.0'
+        substrateSdkVersion = '2.3.0'
 
         gifVersion = '1.2.19'
 

feature-account-impl/src/main/java/io/novafoundation/nova/feature_account_impl/data/fee/types/HydrationConversionFeePayment.kt

@@ -27,11 +27,11 @@ internal class HydrationConversionFeePayment(
 ) : FeePayment {
 
     override suspend fun modifyExtrinsic(extrinsicBuilder: ExtrinsicBuilder) {
-        val baseCall = extrinsicBuilder.getCall()
+        val baseCalls = extrinsicBuilder.getCalls()
         extrinsicBuilder.resetCalls()
 
         extrinsicBuilder.setFeeCurrency(hydraDxAssetIdConverter.toOnChainIdOrThrow(paymentAsset))
-        extrinsicBuilder.call(baseCall)
+        extrinsicBuilder.calls(baseCalls)
         extrinsicBuilder.setFeeCurrency(hydraDxAssetIdConverter.systemAssetId)
     }
 

feature-staking-api/src/main/java/io/novafoundation/nova/feature_staking_api/domain/api/StakingRepository.kt

@@ -3,6 +3,7 @@ package io.novafoundation.nova.feature_staking_api.domain.api
 import io.novafoundation.nova.feature_account_api.data.model.AccountIdMap
 import io.novafoundation.nova.feature_staking_api.domain.model.EraIndex
 import io.novafoundation.nova.feature_staking_api.domain.model.Exposure
+import io.novafoundation.nova.feature_staking_api.domain.model.InflationPredictionInfo
 import io.novafoundation.nova.feature_staking_api.domain.model.RewardDestination
 import io.novafoundation.nova.feature_staking_api.domain.model.SlashingSpans
 import io.novafoundation.nova.feature_staking_api.domain.model.StakingLedger
@@ -58,6 +59,8 @@ interface StakingRepository {
     suspend fun maxNominators(chainId: ChainId): BigInteger?
 
     suspend fun nominatorsCount(chainId: ChainId): BigInteger?
+
+    suspend fun getInflationPredictionInfo(chainId: ChainId): InflationPredictionInfo
 }
 
 suspend fun StakingRepository.historicalEras(chainId: ChainId): List<BigInteger> {

feature-staking-api/src/main/java/io/novafoundation/nova/feature_staking_api/domain/model/InflationPredictionInfo.kt

@@ -0,0 +1,47 @@
+package io.novafoundation.nova.feature_staking_api.domain.model
+
+import io.novafoundation.nova.common.data.network.runtime.binding.bindNumber
+import io.novafoundation.nova.common.data.network.runtime.binding.castToList
+import io.novafoundation.nova.common.data.network.runtime.binding.castToStruct
+import io.novafoundation.nova.common.utils.divideToDecimal
+import io.novafoundation.nova.feature_wallet_api.data.network.blockhain.types.Balance
+import kotlin.math.roundToInt
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.days
+
+class InflationPredictionInfo(
+    val nextMint: NextMint
+) {
+
+    class NextMint(
+        val toStakers: Balance,
+        val toTreasury: Balance
+    )
+
+    companion object {
+
+        fun fromDecoded(decoded: Any?): InflationPredictionInfo {
+            val asStruct = decoded.castToStruct()
+
+            return InflationPredictionInfo(
+                nextMint = bindNextMint(asStruct["nextMint"])
+            )
+        }
+
+        private fun bindNextMint(decoded: Any?): NextMint {
+            val (toStakersRaw, toTreasuryRaw) = decoded.castToList()
+
+            return NextMint(
+                toStakers = bindNumber(toStakersRaw),
+                toTreasury = bindNumber(toTreasuryRaw)
+            )
+        }
+    }
+}
+
+fun InflationPredictionInfo.calculateStakersInflation(totalIssuance: Balance, eraDuration: Duration): Double {
+    val periodsInYear = (365.days / eraDuration).roundToInt()
+    val inflationPerMint = nextMint.toStakers.divideToDecimal(totalIssuance)
+
+    return inflationPerMint.toDouble() * periodsInYear
+}

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/data/repository/StakingRepositoryImpl.kt

@@ -16,6 +16,7 @@ import io.novafoundation.nova.feature_staking_api.domain.model.Exposure
 import io.novafoundation.nova.feature_staking_api.domain.model.ExposureOverview
 import io.novafoundation.nova.feature_staking_api.domain.model.ExposurePage
 import io.novafoundation.nova.feature_staking_api.domain.model.IndividualExposure
+import io.novafoundation.nova.feature_staking_api.domain.model.InflationPredictionInfo
 import io.novafoundation.nova.feature_staking_api.domain.model.Nominations
 import io.novafoundation.nova.feature_staking_api.domain.model.SlashingSpans
 import io.novafoundation.nova.feature_staking_api.domain.model.StakingLedger
@@ -43,6 +44,7 @@ import io.novafoundation.nova.feature_staking_impl.data.network.blockhain.update
 import io.novafoundation.nova.feature_staking_impl.data.network.blockhain.updaters.activeEraStorageKey
 import io.novafoundation.nova.feature_staking_impl.data.repository.datasource.StakingStoriesDataSource
 import io.novafoundation.nova.feature_wallet_api.domain.interfaces.WalletConstants
+import io.novafoundation.nova.runtime.call.MultiChainRuntimeCallsApi
 import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.ChainId
@@ -75,6 +77,7 @@ class StakingRepositoryImpl(
     private val chainRegistry: ChainRegistry,
     private val stakingStoriesDataSource: StakingStoriesDataSource,
     private val storageCache: StorageCache,
+    private val multiChainRuntimeCallsApi: MultiChainRuntimeCallsApi,
 ) : StakingRepository {
 
     override suspend fun eraStartSessionIndex(chainId: ChainId, currentEra: BigInteger): EraIndex {
@@ -266,6 +269,17 @@ class StakingRepositoryImpl(
         chainId = chainId
     )
 
+    override suspend fun getInflationPredictionInfo(chainId: ChainId): InflationPredictionInfo {
+        val callApi = multiChainRuntimeCallsApi.forChain(chainId)
+
+        return callApi.call(
+            section = "Inflation",
+            method = "experimental_inflation_prediction_info",
+            arguments = emptyMap(),
+            returnBinding = InflationPredictionInfo::fromDecoded
+        )
+    }
+
     private suspend fun <T> queryStorageIfExists(
         chainId: ChainId,
         storageName: String,
@@ -318,6 +332,7 @@ class StakingRepositoryImpl(
                     stashId,
                     prefs
                 )
+
                 nominations != null -> StakingState.Stash.Nominator(
                     chain,
                     chainAsset,

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/di/StakingFeatureModule.kt

@@ -70,9 +70,9 @@ import io.novafoundation.nova.feature_staking_impl.data.repository.datasource.re
 import io.novafoundation.nova.feature_staking_impl.data.repository.datasource.reward.PoolStakingRewardsDataSource
 import io.novafoundation.nova.feature_staking_impl.data.repository.datasource.reward.RealStakingRewardsDataSourceRegistry
 import io.novafoundation.nova.feature_staking_impl.data.repository.datasource.reward.StakingRewardsDataSourceRegistry
-import io.novafoundation.nova.feature_staking_impl.data.validators.ValidatorsPreferencesSource
 import io.novafoundation.nova.feature_staking_impl.data.validators.NovaValidatorsApi
 import io.novafoundation.nova.feature_staking_impl.data.validators.RemoteValidatorsPreferencesSource
+import io.novafoundation.nova.feature_staking_impl.data.validators.ValidatorsPreferencesSource
 import io.novafoundation.nova.feature_staking_impl.di.staking.DefaultBulkRetriever
 import io.novafoundation.nova.feature_staking_impl.di.staking.PayoutsBulkRetriever
 import io.novafoundation.nova.feature_staking_impl.domain.StakingInteractor
@@ -177,15 +177,17 @@ class StakingFeatureModule {
         stakingStoriesDataSource: StakingStoriesDataSource,
         walletConstants: WalletConstants,
         chainRegistry: ChainRegistry,
-        storageCache: StorageCache
+        storageCache: StorageCache,
+        multiChainRuntimeCallsApi: MultiChainRuntimeCallsApi
     ): StakingRepository = StakingRepositoryImpl(
         accountStakingDao = accountStakingDao,
         remoteStorage = remoteStorageSource,
         localStorage = localStorageSource,
         stakingStoriesDataSource = stakingStoriesDataSource,
         walletConstants = walletConstants,
         chainRegistry = chainRegistry,
-        storageCache = storageCache
+        storageCache = storageCache,
+        multiChainRuntimeCallsApi = multiChainRuntimeCallsApi
     )
 
     @Provides

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/domain/rewards/InflationPredictionInfoCalculator.kt

@@ -0,0 +1,18 @@
+package io.novafoundation.nova.feature_staking_impl.domain.rewards
+
+import io.novafoundation.nova.feature_staking_api.domain.model.InflationPredictionInfo
+import io.novafoundation.nova.feature_staking_api.domain.model.calculateStakersInflation
+import io.novafoundation.nova.feature_wallet_api.data.network.blockhain.types.Balance
+import kotlin.time.Duration
+
+class InflationPredictionInfoCalculator(
+    private val inflationPredictionInfo: InflationPredictionInfo,
+    private val eraDuration: Duration,
+    private val totalIssuance: Balance,
+    validators: List<RewardCalculationTarget>
+) : InflationBasedRewardCalculator(validators, totalIssuance) {
+
+    override fun calculateYearlyInflation(stakedPortion: Double): Double {
+        return inflationPredictionInfo.calculateStakersInflation(totalIssuance, eraDuration)
+    }
+}

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/domain/rewards/RewardCalculatorFactory.kt

@@ -14,6 +14,7 @@ import io.novafoundation.nova.feature_staking_impl.data.stakingType
 import io.novafoundation.nova.feature_staking_impl.data.unwrapNominationPools
 import io.novafoundation.nova.feature_staking_impl.domain.common.StakingSharedComputation
 import io.novafoundation.nova.feature_staking_impl.domain.common.electedExposuresInActiveEra
+import io.novafoundation.nova.feature_staking_impl.domain.common.eraTimeCalculator
 import io.novafoundation.nova.feature_staking_impl.domain.error.accountIdNotFound
 import io.novafoundation.nova.runtime.ext.Geneses
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
@@ -42,7 +43,8 @@ class RewardCalculatorFactory(
     suspend fun create(
         stakingOption: StakingOption,
         exposures: AccountIdMap<Exposure>,
-        validatorsPrefs: AccountIdMap<ValidatorPrefs?>
+        validatorsPrefs: AccountIdMap<ValidatorPrefs?>,
+        scope: CoroutineScope
     ): RewardCalculator = withContext(Dispatchers.Default) {
         val totalIssuance = totalIssuanceRepository.getTotalIssuance(stakingOption.assetWithChain.chain.id)
 
@@ -57,7 +59,7 @@ class RewardCalculatorFactory(
             )
         }
 
-        stakingOption.createRewardCalculator(validators, totalIssuance)
+        stakingOption.createRewardCalculator(validators, totalIssuance, scope)
     }
 
     suspend fun create(stakingOption: StakingOption, scope: CoroutineScope): RewardCalculator = withContext(Dispatchers.Default) {
@@ -66,13 +68,17 @@ class RewardCalculatorFactory(
         val exposures = shareStakingSharedComputation.get().electedExposuresInActiveEra(chainId, scope)
         val validatorsPrefs = stakingRepository.getValidatorPrefs(chainId, exposures.keys)
 
-        create(stakingOption, exposures, validatorsPrefs)
+        create(stakingOption, exposures, validatorsPrefs, scope)
     }
 
-    private suspend fun StakingOption.createRewardCalculator(validators: List<RewardCalculationTarget>, totalIssuance: BigInteger): RewardCalculator {
+    private suspend fun StakingOption.createRewardCalculator(
+        validators: List<RewardCalculationTarget>,
+        totalIssuance: BigInteger,
+        scope: CoroutineScope
+    ): RewardCalculator {
         return when (unwrapNominationPools().stakingType) {
             RELAYCHAIN, RELAYCHAIN_AURA -> {
-                val custom = customRelayChainCalculator(validators, totalIssuance)
+                val custom = customRelayChainCalculator(validators, totalIssuance, scope)
                 if (custom != null) return custom
 
                 val activePublicParachains = parasRepository.activePublicParachains(assetWithChain.chain.id)
@@ -88,10 +94,12 @@ class RewardCalculatorFactory(
 
     private suspend fun StakingOption.customRelayChainCalculator(
         validators: List<RewardCalculationTarget>,
-        totalIssuance: BigInteger
+        totalIssuance: BigInteger,
+        scope: CoroutineScope
     ): RewardCalculator? {
         return when (chain.id) {
             Chain.Geneses.VARA -> Vara(chain.id, validators, totalIssuance)
+            Chain.Geneses.POLKADOT -> PolkadotInflationPrediction(validators, totalIssuance, scope)
             else -> null
         }
     }
@@ -119,4 +127,28 @@ class RewardCalculatorFactory(
             }
             .getOrNull()
     }
+
+    private suspend fun StakingOption.PolkadotInflationPrediction(
+        validators: List<RewardCalculationTarget>,
+        totalIssuance: BigInteger,
+        scope: CoroutineScope
+    ): RewardCalculator? {
+        return runCatching {
+            val eraRewardCalculator = shareStakingSharedComputation.get().eraTimeCalculator(this, scope)
+            val eraDuration = eraRewardCalculator.eraDuration()
+
+            val inflationPredictionInfo = stakingRepository.getInflationPredictionInfo(chain.id)
+
+            InflationPredictionInfoCalculator(
+                inflationPredictionInfo = inflationPredictionInfo,
+                eraDuration = eraDuration,
+                totalIssuance = totalIssuance,
+                validators = validators
+            )
+        }
+            .onFailure {
+                Log.e("RewardCalculatorFactory", "Failed to create Polkadot Inflation Prediction reward calculator, fallbacking to default", it)
+            }
+            .getOrNull()
+    }
 }

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/domain/staking/start/common/types/direct/RelaychainStakingTypeDetailsInteractor.kt

@@ -8,8 +8,6 @@ import io.novafoundation.nova.feature_staking_impl.data.components
 import io.novafoundation.nova.feature_staking_impl.data.stakingType
 import io.novafoundation.nova.feature_staking_impl.domain.common.StakingSharedComputation
 import io.novafoundation.nova.feature_staking_impl.domain.model.PayoutType
-import io.novafoundation.nova.feature_staking_impl.domain.rewards.DAYS_IN_YEAR
-import io.novafoundation.nova.feature_staking_impl.domain.rewards.calculateMaxPeriodReturns
 import io.novafoundation.nova.feature_staking_impl.domain.staking.start.common.types.StakingTypeDetails
 import io.novafoundation.nova.feature_staking_impl.domain.staking.start.common.types.StakingTypeDetailsInteractor
 import io.novafoundation.nova.feature_wallet_api.domain.model.Asset
@@ -63,7 +61,7 @@ class RelaychainStakingTypeDetailsInteractor(
         val (chain, chainAsset, stakingType) = stakingOption.components
 
         return stakingSharedComputation.rewardCalculator(chain, chainAsset, stakingType, coroutineScope)
-            .calculateMaxPeriodReturns(DAYS_IN_YEAR)
+            .maxAPY
             .asPerbill()
     }
 }

feature-staking-impl/src/main/java/io/novafoundation/nova/feature_staking_impl/domain/validators/ValidatorProvider.kt

@@ -55,7 +55,7 @@ class ValidatorProvider(
         val identities = identityRepository.getIdentitiesFromIdsHex(chainId, requestedValidatorIds)
         val slashes = stakingRepository.getSlashes(chainId, requestedValidatorIds)
 
-        val rewardCalculator = rewardCalculatorFactory.create(stakingOption, electedValidatorExposures, validatorPrefs)
+        val rewardCalculator = rewardCalculatorFactory.create(stakingOption, electedValidatorExposures, validatorPrefs, scope)
         val maxNominators = stakingConstantsRepository.maxRewardedNominatorPerValidator(chainId)
 
         return requestedValidatorIds.map { accountIdHex ->

feature-wallet-api/src/main/java/io/novafoundation/nova/feature_wallet_api/domain/model/CrossChainTransfersConfiguration.kt

@@ -64,7 +64,11 @@ sealed class AssetLocationPath {
 }
 
 enum class XcmTransferType {
-    X_TOKENS, XCM_PALLET_RESERVE, XCM_PALLET_TELEPORT, UNKNOWN
+    X_TOKENS,
+    XCM_PALLET_RESERVE,
+    XCM_PALLET_TELEPORT,
+    XCM_PALLET_TRANSFER_ASSETS,
+    UNKNOWN
 }
 
 enum class XCMInstructionType {

feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/mappers/CrossChain.kt

@@ -115,6 +115,7 @@ private fun mapXcmTransferTypeFromRemote(remote: String): XcmTransferType {
         "xtokens" -> XcmTransferType.X_TOKENS
         "xcmpallet" -> XcmTransferType.XCM_PALLET_RESERVE
         "xcmpallet-teleport" -> XcmTransferType.XCM_PALLET_TELEPORT
+        "xcmpallet-transferAssets" -> XcmTransferType.XCM_PALLET_TRANSFER_ASSETS
         else -> XcmTransferType.UNKNOWN
     }
 }

feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/network/crosschain/RealCrossChainTransactor.kt

@@ -95,6 +95,7 @@ class RealCrossChainTransactor(
             XcmTransferType.X_TOKENS -> xTokensTransfer(configuration, transfer, crossChainFee)
             XcmTransferType.XCM_PALLET_RESERVE -> xcmPalletReserveTransfer(configuration, transfer, crossChainFee)
             XcmTransferType.XCM_PALLET_TELEPORT -> xcmPalletTeleport(configuration, transfer, crossChainFee)
+            XcmTransferType.XCM_PALLET_TRANSFER_ASSETS -> xcmPalletTransferAssets(configuration, transfer, crossChainFee)
             XcmTransferType.UNKNOWN -> throw IllegalArgumentException("Unknown transfer type")
         }
     }
@@ -126,6 +127,20 @@ class RealCrossChainTransactor(
     }
 
     private fun destWeightEncodable(weight: Weight): Any = weight
+
+    private suspend fun ExtrinsicBuilder.xcmPalletTransferAssets(
+        configuration: CrossChainTransferConfiguration,
+        assetTransfer: AssetTransfer,
+        crossChainFee: Balance
+    ) {
+        xcmPalletTransfer(
+            configuration = configuration,
+            assetTransfer = assetTransfer,
+            crossChainFee = crossChainFee,
+            callName = "transfer_assets"
+        )
+    }
+
     private suspend fun ExtrinsicBuilder.xcmPalletReserveTransfer(
         configuration: CrossChainTransferConfiguration,
         assetTransfer: AssetTransfer,