revert: restore original Nova staking code

Removed custom staking modifications - use Nova's original implementation. Chain config (A+B=C) handles Polkadot 2.0 correctly via timelineChain.
2026-04-29 21:47:59 +00:00 · 2026-02-11 12:07:51 +03:00
parent 20bf60fd3a
commit 1fac88b573
13 changed files with 35 additions and 131 deletions
@@ -90,8 +90,8 @@ class RealStakingDashboardUpdateSystem(
                    sharedRequestsBuilder.subscribe(accountScope)

                    chainUpdates.mergeIfMultiple()
-                }.catch { e ->
-                    Log.e("StakingDashboardUpdateSystem", "Failed to sync staking dashboard status for ${stakingChain.name}", e)
+                }.catch {
+                    Log.d("StakingDashboardUpdateSystem", "Failed to sync staking dashboard status for ${stakingChain.name}")
                }
            }

@@ -212,8 +212,7 @@ class StakingFeatureModule {
        bagListRepository: BagListRepository,
        totalIssuanceRepository: TotalIssuanceRepository,
        eraTimeCalculatorFactory: EraTimeCalculatorFactory,
-        stakingConstantsRepository: StakingConstantsRepository,
-        chainRegistry: ChainRegistry
+        stakingConstantsRepository: StakingConstantsRepository
    ) = StakingSharedComputation(
        stakingRepository = stakingRepository,
        computationalCache = computationalCache,
@@ -222,8 +221,7 @@ class StakingFeatureModule {
        bagListRepository = bagListRepository,
        totalIssuanceRepository = totalIssuanceRepository,
        eraTimeCalculatorFactory = eraTimeCalculatorFactory,
-        stakingConstantsRepository = stakingConstantsRepository,
-        chainRegistry = chainRegistry
+        stakingConstantsRepository = stakingConstantsRepository
    )

    @Provides
@@ -299,8 +297,7 @@ class StakingFeatureModule {
        sessionRepository: SessionRepository,
        chainStateRepository: ChainStateRepository,
        electionsSessionRegistry: ElectionsSessionRegistry,
-        chainRegistry: ChainRegistry,
-    ) = EraTimeCalculatorFactory(stakingRepository, sessionRepository, chainStateRepository, electionsSessionRegistry, chainRegistry)
+    ) = EraTimeCalculatorFactory(stakingRepository, sessionRepository, chainStateRepository, electionsSessionRegistry)

    @Provides
    @FeatureScope
@@ -56,9 +56,9 @@ import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.pools.
 import io.novafoundation.nova.feature_staking_impl.presentation.nominationPools.common.PoolDisplayFormatter
 import io.novafoundation.nova.feature_staking_impl.presentation.nominationPools.common.RealPoolDisplayFormatter
 import io.novafoundation.nova.runtime.call.MultiChainRuntimeCallsApi
-import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
 import io.novafoundation.nova.runtime.di.LOCAL_STORAGE_SOURCE
 import io.novafoundation.nova.runtime.di.REMOTE_STORAGE_SOURCE
+import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
 import io.novafoundation.nova.runtime.storage.source.StorageDataSource
 import javax.inject.Named

@@ -151,14 +151,12 @@ class NominationPoolModule {
        poolAccountDerivation: PoolAccountDerivation,
        relaychainStakingInteractor: StakingInteractor,
        nominationPoolMemberUseCase: NominationPoolMemberUseCase,
-        chainRegistry: ChainRegistry,
    ): NominationPoolsNetworkInfoInteractor = RealNominationPoolsNetworkInfoInteractor(
        relaychainStakingSharedComputation = relaychainStakingSharedComputation,
        nominationPoolGlobalsRepository = nominationPoolGlobalsRepository,
        poolAccountDerivation = poolAccountDerivation,
        relaychainStakingInteractor = relaychainStakingInteractor,
-        nominationPoolMemberUseCase = nominationPoolMemberUseCase,
-        chainRegistry = chainRegistry
+        nominationPoolMemberUseCase = nominationPoolMemberUseCase
    )

    @Provides
@@ -9,7 +9,6 @@ import io.novafoundation.nova.feature_staking_impl.data.chain
 import io.novafoundation.nova.feature_staking_impl.data.repository.SessionRepository
 import io.novafoundation.nova.feature_staking_impl.data.repository.consensus.ElectionsSessionRegistry
 import io.novafoundation.nova.runtime.ext.timelineChainIdOrSelf
-import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
 import io.novafoundation.nova.runtime.repository.ChainStateRepository
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
@@ -97,7 +96,6 @@ class EraTimeCalculatorFactory(
    private val sessionRepository: SessionRepository,
    private val chainStateRepository: ChainStateRepository,
    private val electionsSessionRegistry: ElectionsSessionRegistry,
-    private val chainRegistry: ChainRegistry,
 ) {

    suspend fun create(
@@ -105,8 +103,8 @@ class EraTimeCalculatorFactory(
        activeEraFlow: Flow<EraIndex>
    ): Flow<EraTimeCalculator> {
        val stakingChain = stakingOption.chain
+        val stakingChainId = stakingChain.id
        val timelineChainId = stakingChain.timelineChainIdOrSelf()
-        val timelineChain = chainRegistry.getChain(timelineChainId)

        val electionsSession = electionsSessionRegistry.electionsSessionFor(stakingOption)

@@ -114,7 +112,7 @@ class EraTimeCalculatorFactory(
        val sessionLength = electionsSession.sessionLength(timelineChainId)

        val eraAndStartSessionIndex = activeEraFlow.map { activeEra ->
-            val eraStartSessionIndex = stakingRepository.eraStartSessionIndex(timelineChainId, activeEra)
+            val eraStartSessionIndex = stakingRepository.eraStartSessionIndex(stakingChainId, activeEra)
            activeEra to eraStartSessionIndex
        }

@@ -126,7 +124,7 @@ class EraTimeCalculatorFactory(
        ) { (activeEra, eraStartSessionIndex), currentSessionIndex, currentEpochIndex, currentSlot ->
            EraTimeCalculator(
                startTimeStamp = System.currentTimeMillis().toBigInteger(),
-                eraLength = stakingRepository.eraLength(timelineChain),
+                eraLength = stakingRepository.eraLength(stakingChain),
                blockCreationTime = chainStateRepository.predictedBlockTime(timelineChainId),
                currentSessionIndex = currentSessionIndex,
                currentEpochIndex = currentEpochIndex ?: currentSessionIndex,
@@ -18,8 +18,6 @@ import io.novafoundation.nova.feature_staking_impl.domain.minimumStake
 import io.novafoundation.nova.feature_staking_impl.domain.rewards.RewardCalculator
 import io.novafoundation.nova.feature_staking_impl.domain.rewards.RewardCalculatorFactory
 import io.novafoundation.nova.feature_wallet_api.data.network.blockhain.types.Balance
-import io.novafoundation.nova.runtime.ext.timelineChainIdOrSelf
-import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
 import io.novafoundation.nova.runtime.multiNetwork.ChainWithAsset
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.ChainId
@@ -45,18 +43,15 @@ class StakingSharedComputation(
    private val bagListRepository: BagListRepository,
    private val totalIssuanceRepository: TotalIssuanceRepository,
    private val eraTimeCalculatorFactory: EraTimeCalculatorFactory,
-    private val stakingConstantsRepository: StakingConstantsRepository,
-    private val chainRegistry: ChainRegistry
+    private val stakingConstantsRepository: StakingConstantsRepository
 ) {

    fun eraCalculatorFlow(stakingOption: StakingOption, scope: CoroutineScope): Flow<EraTimeCalculator> {
-        val chain = stakingOption.assetWithChain.chain
-        val chainId = chain.id
-        val timelineChainId = chain.timelineChainIdOrSelf()
+        val chainId = stakingOption.assetWithChain.chain.id
        val key = "ERA_TIME_CALCULATOR:$chainId"

        return computationalCache.useSharedFlow(key, scope) {
-            val activeEraFlow = activeEraFlow(timelineChainId, scope)
+            val activeEraFlow = activeEraFlow(chainId, scope)

            eraTimeCalculatorFactory.create(stakingOption, activeEraFlow)
        }
@@ -84,17 +79,14 @@ class StakingSharedComputation(
        val key = "MIN_STAKE:$chainId"

        return computationalCache.useSharedFlow(key, scope) {
-            val chain = chainRegistry.getChain(chainId)
-            val timelineChainId = chain.timelineChainIdOrSelf()
-
-            val minBond = stakingRepository.minimumNominatorBond(timelineChainId)
-            val bagListLocator = bagListRepository.bagListLocatorOrNull(timelineChainId)
-            val totalIssuance = totalIssuanceRepository.getTotalIssuance(timelineChainId)
+            val minBond = stakingRepository.minimumNominatorBond(chainId)
+            val bagListLocator = bagListRepository.bagListLocatorOrNull(chainId)
+            val totalIssuance = totalIssuanceRepository.getTotalIssuance(chainId)
            val bagListScoreConverter = BagListScoreConverter.U128(totalIssuance)
-            val maxElectingVoters = bagListRepository.maxElectingVotes(timelineChainId)
-            val bagListSize = bagListRepository.bagListSize(timelineChainId)
+            val maxElectingVoters = bagListRepository.maxElectingVotes(chainId)
+            val bagListSize = bagListRepository.bagListSize(chainId)

-            electedExposuresWithActiveEraFlow(timelineChainId, scope).map { (exposures, activeEraIndex) ->
+            electedExposuresWithActiveEraFlow(chainId, scope).map { (exposures, activeEraIndex) ->
                val minStake = minimumStake(
                    exposures = exposures.values,
                    minimumNominatorBond = minBond,
@@ -1,40 +1,7 @@
 package io.novafoundation.nova.feature_staking_impl.domain.nominationPools

 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
-import io.novafoundation.nova.runtime.multiNetwork.chain.model.ChainId

-/**
- * Finds the staking type that backs nomination pools.
- *
- * In Polkadot 1.0: Both relaychain and nomination-pools exist on the same chain
- * In Polkadot 2.0: nomination-pools may exist on Asset Hub without local backing type
- *                  (backing is via XCM from relay chain)
- *
- * @return The backing staking type, or RELAYCHAIN as default for Polkadot 2.0 compatibility
- */
 fun Chain.Asset.findStakingTypeBackingNominationPools(): Chain.Asset.StakingType {
-    return staking.firstOrNull { it != Chain.Asset.StakingType.NOMINATION_POOLS }
-        ?: Chain.Asset.StakingType.RELAYCHAIN  // Polkadot 2.0: default to RELAYCHAIN for Asset Hub
-}
-
-/**
- * Checks if this asset has nomination pools backed by a local staking type.
- * Returns false for Polkadot 2.0 Asset Hub where backing is cross-chain.
- */
-fun Chain.Asset.hasLocalNominationPoolsBacking(): Boolean {
-    return staking.any { it != Chain.Asset.StakingType.NOMINATION_POOLS }
-}
-
-/**
- * Returns the chain ID where staking exposures (validators, eras) live.
- *
- * For nomination pools on a parachain (e.g. Asset Hub in Polkadot 2.0),
- * the staking ledger/exposures are on the parent relay chain.
- * For relay chains or chains with local staking, returns the chain's own ID.
- */
-fun Chain.stakingBackingChainId(stakingType: Chain.Asset.StakingType): ChainId {
-    if (stakingType == Chain.Asset.StakingType.NOMINATION_POOLS && parentId != null) {
-        return parentId!!
-    }
-    return id
+    return staking.first { it != Chain.Asset.StakingType.NOMINATION_POOLS }
 }
@@ -13,11 +13,9 @@ import io.novafoundation.nova.feature_account_api.data.model.AccountIdMap
 import io.novafoundation.nova.feature_staking_api.domain.model.Exposure
 import io.novafoundation.nova.feature_staking_impl.data.StakingOption
 import io.novafoundation.nova.feature_staking_impl.data.chain
-import io.novafoundation.nova.feature_staking_impl.data.stakingType
 import io.novafoundation.nova.feature_staking_api.domain.nominationPool.model.PoolId
 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.nominationPools.stakingBackingChainId
 import io.novafoundation.nova.feature_staking_impl.domain.common.electedExposuresInActiveEra
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.common.NominationPoolSharedComputation
 import io.novafoundation.nova.feature_staking_impl.domain.rewards.RewardCalculator
@@ -30,8 +28,6 @@ class NominationPoolRewardCalculatorFactory(

    suspend fun create(stakingOption: StakingOption, sharedComputationScope: CoroutineScope): NominationPoolRewardCalculator {
        val chainId = stakingOption.chain.id
-        // For nomination pools on parachains (like Asset Hub), get exposures from parent relay chain
-        val stakingBackingChainId = stakingOption.chain.stakingBackingChainId(stakingOption.stakingType)

        val delegateOption = stakingOption.unwrapNominationPools()

@@ -42,7 +38,7 @@ class NominationPoolRewardCalculatorFactory(

        return RealNominationPoolRewardCalculator(
            directStakingDelegate = delegate,
-            exposures = sharedStakingSharedComputation.electedExposuresInActiveEra(stakingBackingChainId, sharedComputationScope),
+            exposures = sharedStakingSharedComputation.electedExposuresInActiveEra(stakingOption.assetWithChain.chain.id, sharedComputationScope),
            commissions = poolCommissions,
            poolStashesById = allPoolAccounts
        )
@@ -18,7 +18,6 @@ import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.common
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.main.alerts.NominationPoolAlert.RedeemTokens
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.main.alerts.NominationPoolAlert.WaitingForNextEra
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.main.alerts.RealNominationPoolsAlertsInteractor.AlertsResolutionContext.PoolContext
-import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.stakingBackingChainId
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
 import io.novasama.substrate_sdk_android.hash.isPositive
 import io.novasama.substrate_sdk_android.runtime.AccountId
@@ -50,13 +49,11 @@ class RealNominationPoolsAlertsInteractor(
        return flowOfAll {
            val poolId = poolMember.poolId
            val poolStash = poolAccountDerivation.bondedAccountOf(poolId, chain.id)
-            // For nomination pools on parachains (like Asset Hub), get exposures from parent relay chain
-            val stakingBackingChainId = chain.stakingBackingChainId(Chain.Asset.StakingType.NOMINATION_POOLS)

            combine(
                nominationPoolsSharedComputation.participatingPoolNominationsFlow(poolStash, poolId, chain.id, shareComputationScope),
                nominationPoolsSharedComputation.unbondingPoolsFlow(poolId, chain.id, shareComputationScope),
-                stakingSharedComputation.electedExposuresWithActiveEraFlow(stakingBackingChainId, shareComputationScope),
+                stakingSharedComputation.electedExposuresWithActiveEraFlow(chain.id, shareComputationScope),
            ) { poolNominations, unbondingPools, (eraStakers, activeEra) ->
                val alertsContext = AlertsResolutionContext(
                    eraStakers = eraStakers,
@@ -12,9 +12,6 @@ import io.novafoundation.nova.feature_staking_impl.domain.StakingInteractor
 import io.novafoundation.nova.feature_staking_impl.domain.common.StakingSharedComputation
 import io.novafoundation.nova.feature_staking_impl.domain.common.electedExposuresInActiveEraFlow
 import io.novafoundation.nova.feature_staking_impl.domain.model.NetworkInfo
-import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.stakingBackingChainId
-import io.novafoundation.nova.runtime.multiNetwork.ChainRegistry
-import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain
 import io.novafoundation.nova.feature_staking_impl.domain.model.StakingPeriod
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.common.NominationPoolMemberUseCase
 import io.novafoundation.nova.feature_wallet_api.data.network.blockhain.types.Balance
@@ -22,8 +19,6 @@ import io.novafoundation.nova.runtime.multiNetwork.chain.model.ChainId
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.emitAll
-import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.map
 import java.math.BigInteger

@@ -40,7 +35,6 @@ class RealNominationPoolsNetworkInfoInteractor(
    private val poolAccountDerivation: PoolAccountDerivation,
    private val relaychainStakingInteractor: StakingInteractor,
    private val nominationPoolMemberUseCase: NominationPoolMemberUseCase,
-    private val chainRegistry: ChainRegistry,
 ) : NominationPoolsNetworkInfoInteractor {

    override fun observeShouldShowNetworkInfo(): Flow<Boolean> {
@@ -50,13 +44,9 @@ class RealNominationPoolsNetworkInfoInteractor(
    override fun observeNetworkInfo(
        chainId: ChainId,
        sharedComputationScope: CoroutineScope
-    ): Flow<NetworkInfo> = flow {
-        // For nomination pools on parachains (like Asset Hub), get exposures from parent relay chain
-        val chain = chainRegistry.getChain(chainId)
-        val stakingBackingChainId = chain.stakingBackingChainId(Chain.Asset.StakingType.NOMINATION_POOLS)
-
-        val networkInfoFlow = combine(
-            relaychainStakingSharedComputation.electedExposuresInActiveEraFlow(stakingBackingChainId, sharedComputationScope),
+    ): Flow<NetworkInfo> {
+        return combine(
+            relaychainStakingSharedComputation.electedExposuresInActiveEraFlow(chainId, sharedComputationScope),
            nominationPoolGlobalsRepository.observeMinJoinBond(chainId),
            nominationPoolGlobalsRepository.lastPoolIdFlow(chainId),
            lockupDurationFlow(sharedComputationScope),
@@ -69,8 +59,6 @@ class RealNominationPoolsNetworkInfoInteractor(
                nominatorsCount = null
            )
        }
-
-        emitAll(networkInfoFlow)
    }

    private fun lockupDurationFlow(sharedComputationScope: CoroutineScope) = flowOf { relaychainStakingInteractor.getLockupDuration(sharedComputationScope) }
@@ -9,10 +9,8 @@ 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.Nominations
 import io.novafoundation.nova.feature_staking_impl.data.StakingOption
-import io.novafoundation.nova.feature_staking_impl.data.stakingType
 import io.novafoundation.nova.feature_staking_impl.data.nominationPools.network.blockhain.models.PoolMember
 import io.novafoundation.nova.feature_staking_impl.domain.common.StakingSharedComputation
-import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.stakingBackingChainId
 import io.novafoundation.nova.feature_staking_impl.domain.common.isWaiting
 import io.novafoundation.nova.feature_staking_impl.domain.model.StakeSummary
 import io.novafoundation.nova.feature_staking_impl.domain.nominationPools.common.NominationPoolSharedComputation
@@ -50,14 +48,12 @@ class RealNominationPoolStakeSummaryInteractor(
        sharedComputationScope: CoroutineScope,
    ): Flow<StakeSummary<PoolMemberStatus>> = flowOfAll {
        val chainId = stakingOption.assetWithChain.chain.id
-        // For nomination pools on parachains (like Asset Hub), get exposures from parent relay chain
-        val stakingBackingChainId = stakingOption.assetWithChain.chain.stakingBackingChainId(stakingOption.stakingType)
        val poolStash = poolAccountDerivation.bondedAccountOf(poolMember.poolId, chainId)

        combineTransform(
            nominationPoolSharedComputation.participatingBondedPoolStateFlow(poolStash, poolMember.poolId, chainId, sharedComputationScope),
            nominationPoolSharedComputation.participatingPoolNominationsFlow(poolStash, poolMember.poolId, chainId, sharedComputationScope),
-            stakingSharedComputation.electedExposuresWithActiveEraFlow(stakingBackingChainId, sharedComputationScope)
+            stakingSharedComputation.electedExposuresWithActiveEraFlow(chainId, sharedComputationScope)
        ) { bondedPoolState, poolNominations, (eraStakers, activeEra) ->
            val activeStaked = bondedPoolState.amountOf(poolMember.points)

@@ -13,7 +13,6 @@ import io.novafoundation.nova.feature_staking_impl.data.repository.VaraRepositor
 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.nominationPools.stakingBackingChainId
 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
@@ -28,7 +27,6 @@ import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain.Asset.Staki
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain.Asset.StakingType.TURING
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.Chain.Asset.StakingType.UNSUPPORTED
 import io.novafoundation.nova.runtime.multiNetwork.chain.model.ChainId
-import io.novafoundation.nova.runtime.ext.timelineChainIdOrSelf
 import io.novafoundation.nova.runtime.repository.TotalIssuanceRepository
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -49,10 +47,7 @@ class RewardCalculatorFactory(
        validatorsPrefs: AccountIdMap<ValidatorPrefs?>,
        scope: CoroutineScope
    ): RewardCalculator = withContext(Dispatchers.Default) {
-        val timelineChainId = stakingOption.assetWithChain.chain.timelineChainIdOrSelf()
-        val totalIssuance = totalIssuanceRepository.getTotalIssuance(timelineChainId)
-
-        Log.d("RewardCalculatorFactory", "totalIssuance for $timelineChainId: $totalIssuance")
+        val totalIssuance = totalIssuanceRepository.getTotalIssuance(stakingOption.assetWithChain.chain.id)

        val validators = exposures.keys.mapNotNull { accountIdHex ->
            val exposure = exposures[accountIdHex] ?: accountIdNotFound(accountIdHex)
@@ -65,22 +60,14 @@ class RewardCalculatorFactory(
            )
        }

-        Log.d("RewardCalculatorFactory", "Validators count for reward calculation: ${validators.size}")
-        if (validators.isNotEmpty()) {
-            val totalStaked = validators.sumOf { it.totalStake }
-            Log.d("RewardCalculatorFactory", "Total staked: $totalStaked, stakedPortion: ${totalStaked.toDouble() / totalIssuance.toDouble()}")
-        }
-
        stakingOption.createRewardCalculator(validators, totalIssuance, scope)
    }

    suspend fun create(stakingOption: StakingOption, scope: CoroutineScope): RewardCalculator = withContext(Dispatchers.Default) {
-        val chain = stakingOption.assetWithChain.chain
-        // For nomination pools on parachains (like Asset Hub), get exposures from parent relay chain
-        val stakingBackingChainId = chain.stakingBackingChainId(stakingOption.stakingType)
+        val chainId = stakingOption.assetWithChain.chain.id

-        val exposures = shareStakingSharedComputation.get().electedExposuresInActiveEra(stakingBackingChainId, scope)
-        val validatorsPrefs = stakingRepository.getValidatorPrefs(stakingBackingChainId, exposures.keys)
+        val exposures = shareStakingSharedComputation.get().electedExposuresInActiveEra(chainId, scope)
+        val validatorsPrefs = stakingRepository.getValidatorPrefs(chainId, exposures.keys)

        create(stakingOption, exposures, validatorsPrefs, scope)
    }
@@ -95,16 +82,10 @@ class RewardCalculatorFactory(
                val custom = customRelayChainCalculator(validators, totalIssuance, scope)
                if (custom != null) return custom

-                val timelineChainId = chain.timelineChainIdOrSelf()
-                val activePublicParachains = parasRepository.activePublicParachains(timelineChainId)
-                Log.d("RewardCalculatorFactory", "activePublicParachains for $timelineChainId: $activePublicParachains")
+                val activePublicParachains = parasRepository.activePublicParachains(assetWithChain.chain.id)
+                val inflationConfig = InflationConfig.create(chain.id, activePublicParachains)

-                val inflationConfig = InflationConfig.create(timelineChainId, activePublicParachains)
-                Log.d("RewardCalculatorFactory", "Using Default InflationConfig for $timelineChainId")
-
-                val calculator = RewardCurveInflationRewardCalculator(validators, totalIssuance, inflationConfig)
-                Log.d("RewardCalculatorFactory", "expectedAPY: ${calculator.expectedAPY}, maxAPY: ${calculator.maxAPY}")
-                calculator
+                RewardCurveInflationRewardCalculator(validators, totalIssuance, inflationConfig)
            }

            ALEPH_ZERO -> AlephZeroRewardCalculator(validators, chainAsset = assetWithChain.asset)
@@ -102,13 +102,7 @@ class StakingDashboardViewModel(
    fun onNoStakeItemClicked(index: Int) = launch {
        val withoutStakeItems = stakingDashboardFlow.firstLoaded().withoutStake
        val withoutStakeItem = withoutStakeItems.getOrNull(index) ?: return@launch
-        val noStakeItemState = withoutStakeItem.stakingState as? NoStake
-
-        if (noStakeItemState == null) {
-            // Item is still syncing (NotYetResolved state)
-            showToast(resourceManager.getString(R.string.staking_dashboard_syncing))
-            return@launch
-        }
+        val noStakeItemState = withoutStakeItem.stakingState as? NoStake ?: return@launch

        val stakingTypes = noStakeItemState.flowType.allStakingTypes
        val chain = withoutStakeItem.chain
@@ -1 +1 @@
-VERSION_CODE=163
+VERSION_CODE=166