feat!: Rewire dependencies on the staking module

app/provider/app.go

@@ -373,15 +373,6 @@ func New(
 		authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ValidatorAddrPrefix()),
 		authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ConsensusAddrPrefix()),
 	)
-	app.MintKeeper = mintkeeper.NewKeeper(
-		appCodec,
-		runtime.NewKVStoreService(keys[minttypes.StoreKey]),
-		app.StakingKeeper,
-		app.AccountKeeper,
-		app.BankKeeper,
-		authtypes.FeeCollectorName,
-		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
-	)
 	app.DistrKeeper = distrkeeper.NewKeeper(
 		appCodec,
 		runtime.NewKVStoreService(keys[distrtypes.StoreKey]),
@@ -456,19 +447,6 @@ func New(
 		runtime.ProvideCometInfoService(),
 	)
 
-	govConfig := govtypes.DefaultConfig()
-	app.GovKeeper = govkeeper.NewKeeper(
-		appCodec,
-		runtime.NewKVStoreService(keys[govtypes.StoreKey]),
-		app.AccountKeeper,
-		app.BankKeeper,
-		app.StakingKeeper,
-		app.DistrKeeper,
-		app.MsgServiceRouter(),
-		govConfig,
-		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
-	)
-
 	app.ProviderKeeper = ibcproviderkeeper.NewKeeper(
 		appCodec,
 		keys[providertypes.StoreKey],
@@ -483,13 +461,41 @@ func New(
 		app.AccountKeeper,
 		app.DistrKeeper,
 		app.BankKeeper,
-		*app.GovKeeper,
+		govkeeper.Keeper{}, // will be set after the GovKeeper is created
 		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
 		authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ValidatorAddrPrefix()),
 		authcodec.NewBech32Codec(sdk.GetConfig().GetBech32ConsensusAddrPrefix()),
 		authtypes.FeeCollectorName,
 	)
 
+	govConfig := govtypes.DefaultConfig()
+	app.GovKeeper = govkeeper.NewKeeper(
+		appCodec,
+		runtime.NewKVStoreService(keys[govtypes.StoreKey]),
+		app.AccountKeeper,
+		app.BankKeeper,
+		app.StakingKeeper,
+		app.DistrKeeper,
+		app.MsgServiceRouter(),
+		govConfig,
+		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+	)
+
+	// set the GovKeeper in the ProviderKeeper
+	app.ProviderKeeper.SetGovKeeper(*app.GovKeeper)
+
+	app.MintKeeper = mintkeeper.NewKeeper(
+		appCodec,
+		runtime.NewKVStoreService(keys[minttypes.StoreKey]),
+		// use the ProviderKeeper as StakingKeeper for mint
+		// because minting should be based on the consensus-active validators
+		app.ProviderKeeper,
+		app.AccountKeeper,
+		app.BankKeeper,
+		authtypes.FeeCollectorName,
+		authtypes.NewModuleAddress(govtypes.ModuleName).String(),
+	)
+
 	// gov router must be set after the provider keeper is created
 	// otherwise the provider keeper will not be able to handle proposals (will be nil)
 	govRouter := govv1beta1.NewRouter()

x/ccv/provider/keeper/keeper.go

@@ -143,6 +143,10 @@ func (k Keeper) mustValidateFields() {
 	// ccv.PanicIfZeroOrNil(k.govKeeper, "govKeeper")                         // 17
 }
 
+func (k *Keeper) SetGovKeeper(govKeeper govkeeper.Keeper) {
+	k.govKeeper = govKeeper
+}
+
 // Logger returns a module-specific logger.
 func (k Keeper) Logger(ctx context.Context) log.Logger {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)

x/ccv/provider/keeper/staking_keeper_interface.go

@@ -0,0 +1,81 @@
+package keeper
+
+import (
+	"context"
+
+	"cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+// Iterates over the consensus-active validators by power.
+// The same as IterateBondedValidatorsByPower in the StakingKeeper,
+// but only returns the first MaxProviderConsensusValidators validators.
+// This is used to implement the interface of the staking keeper to interface with
+// modules that need to reference the consensus-active validators.
+func (k Keeper) IterateBondedValidatorsByPower(ctx context.Context, fn func(index int64, validator stakingtypes.ValidatorI) (stop bool)) error {
+	maxProviderConsensusVals := k.GetMaxProviderConsensusValidators(sdk.UnwrapSDKContext(ctx))
+	counter := int64(0)
+	return k.stakingKeeper.IterateBondedValidatorsByPower(ctx, func(index int64, validator stakingtypes.ValidatorI) (stop bool) {
+		if counter >= maxProviderConsensusVals {
+			return true
+		}
+		counter++
+		return fn(index, validator)
+	})
+}
+
+// Gets the amount of bonded tokens, which is equal
+// to the amount of tokens of the consensus-active validators.
+// The same as TotalBondedTokens, but only counts
+// tokens of the first MaxProviderConsensusValidators validators.
+// This is used to implement the interface of the staking keeper to interface with
+// modules that need to reference the consensus-active validators.
+func (k Keeper) TotalBondedTokens(ctx context.Context) (math.Int, error) {
+	// iterate through the bonded validators
+	totalBondedTokens := math.ZeroInt()
+
+	k.IterateBondedValidatorsByPower(ctx, func(_ int64, validator stakingtypes.ValidatorI) (stop bool) {
+		tokens := validator.GetTokens()
+		totalBondedTokens = totalBondedTokens.Add(tokens)
+		return false
+	})
+
+	return totalBondedTokens, nil
+}
+
+// The same as IterateDelegations in the StakingKeeper.
+// Necessary to implement the interface of the staking keeper to interface with
+// other modules.
+func (k Keeper) IterateDelegations(ctx context.Context, delegator sdk.AccAddress, fn func(index int64, delegation stakingtypes.DelegationI) (stop bool)) error {
+	return k.stakingKeeper.IterateDelegations(ctx, delegator, fn)
+}
+
+// The same as StakingTotalSupply in the StakingKeeper.
+// Necessary to implement the interface of the staking keeper to interface with
+// other modules.
+func (k Keeper) StakingTokenSupply(ctx context.Context) (math.Int, error) {
+	return k.stakingKeeper.StakingTokenSupply(ctx)
+}
+
+// Gets the ratio of tokens staked to validators active in the consensus
+// to the total supply of tokens.
+// Same as BondedRatio in the StakingKeeper, but only counts
+// tokens of the first MaxProviderConsensusValidators bonded validators.
+func (k Keeper) BondedRatio(ctx context.Context) (math.LegacyDec, error) {
+	totalSupply, err := k.StakingTokenSupply(ctx)
+	if err != nil {
+		return math.LegacyZeroDec(), err
+	}
+
+	bondedTokens, err := k.TotalBondedTokens(ctx)
+	if err != nil {
+		return math.LegacyZeroDec(), err
+	}
+
+	if !totalSupply.IsPositive() {
+		return math.LegacyZeroDec(), nil
+	}
+
+	return math.LegacyNewDecFromInt(bondedTokens).QuoInt(totalSupply), nil
+}

x/ccv/provider/keeper/staking_keeper_interface_test.go

@@ -0,0 +1,96 @@
+package keeper_test
+
+import (
+	"sort"
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
+	testkeeper "github.com/cosmos/interchain-security/v5/testutil/keeper"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/require"
+)
+
+// Tests that IterateBondedValidatorsByPower returns the correct validators,
+// namely the ones with most power, and stops when the max number of validators is reached.
+func TestIterateBondedValidatorsByPower(t *testing.T) {
+	tests := []struct {
+		name           string
+		maxValidators  int64
+		powers         []int64
+		expectedPowers []int64
+	}{
+		{
+			name:           "no validators",
+			maxValidators:  5,
+			powers:         []int64{},
+			expectedPowers: []int64{},
+		},
+		{
+			name:           "validators less than max",
+			maxValidators:  5,
+			powers:         []int64{10, 20, 30},
+			expectedPowers: []int64{10, 20, 30}, // get all validators back
+		},
+		{
+			name:           "validators more than max",
+			maxValidators:  2,
+			powers:         []int64{10, 20, 30},
+			expectedPowers: []int64{30, 20}, // get the top 2 validators back
+		},
+		{
+			name:           "validators equal to max",
+			maxValidators:  3,
+			powers:         []int64{10, 20, 30},
+			expectedPowers: []int64{30, 20, 10}, // get all validators back
+		},
+		{
+			name:           "validators with equal powers",
+			maxValidators:  3,
+			powers:         []int64{10, 10, 10, 20, 20, 30, 30},
+			expectedPowers: []int64{30, 30, 20}, // get the top 3 validators back
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+			defer ctrl.Finish()
+
+			counter := int64(0)
+			vals, _ := createStakingValidatorsAndMocks(ctx, mocks, tt.powers...)
+
+			params := providerKeeper.GetParams(ctx)
+			params.MaxProviderConsensusValidators = tt.maxValidators
+			providerKeeper.SetParams(ctx, params)
+
+			// sort vals by descending number of tokens
+			sort.Slice(
+				vals,
+				func(i, j int) bool {
+					return vals[i].GetTokens().Int64() > vals[j].GetTokens().Int64()
+				},
+			)
+
+			mocks.MockStakingKeeper.EXPECT().IterateBondedValidatorsByPower(gomock.Any(), gomock.Any()).DoAndReturn(
+				func(ctx sdk.Context, cb func(int64, stakingtypes.ValidatorI) bool) error {
+					for i, val := range vals {
+						if stop := cb(int64(i), val); stop {
+							break
+						}
+					}
+					return nil
+				})
+			actualValPowers := []int64{}
+			err := providerKeeper.IterateBondedValidatorsByPower(ctx, func(index int64, validator types.ValidatorI) (stop bool) {
+				counter++
+				actualValPowers = append(actualValPowers, validator.GetTokens().Int64())
+				return false
+			})
+			require.NoError(t, err)
+			// we don't check that the elements exactly match; just matching the powers is good enough
+			require.ElementsMatch(t, tt.expectedPowers, actualValPowers)
+		})
+	}
+}