feat!: Wire the provider module to return ValidatorUpdates, instead of the staking module

app/provider/app.go

@@ -116,6 +116,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/testutil/testdata/testpb"
 	sigtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
 	txmodule "github.com/cosmos/cosmos-sdk/x/auth/tx/config"
+
+	no_valupdates_staking "github.com/cosmos/interchain-security/v5/x/ccv/no_valupdates_staking"
 )
 
 const (
@@ -552,7 +554,7 @@ func New(
 		mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil, app.GetSubspace(minttypes.ModuleName)),
 		slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(slashingtypes.ModuleName), app.interfaceRegistry),
 		distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(distrtypes.ModuleName)),
-		staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper, app.GetSubspace(stakingtypes.ModuleName)),
+		no_valupdates_staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper, app.GetSubspace(stakingtypes.ModuleName)),
 		upgrade.NewAppModule(&app.UpgradeKeeper, app.AccountKeeper.AddressCodec()),
 		evidence.NewAppModule(app.EvidenceKeeper),
 

proto/interchain_security/ccv/provider/v1/provider.proto

@@ -251,6 +251,10 @@ message Params {
 
   // The number of blocks that comprise an epoch.
   int64 blocks_per_epoch = 10;
+
+  // The maximal number of validators that will be passed
+  // to the consensus engine on the provider.
+  int64 max_provider_consensus_validators = 11;
 }
 
 // SlashAcks contains cons addresses of consumer chain validators

x/ccv/no_valupdates_staking/doc.go

@@ -0,0 +1,8 @@
+/*
+Package staking defines a "wrapper" module around the Cosmos SDK's native
+x/staking module. In other words, it provides the exact same functionality as
+the native module in that it simply embeds the native module. However, it
+overrides `EndBlock` which will return no validator set updates. Instead,
+it is assumed that some other module will provide the validator set updates.
+*/
+package staking

x/ccv/no_valupdates_staking/module.go

@@ -0,0 +1,74 @@
+package staking
+
+import (
+	"encoding/json"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	"github.com/cosmos/cosmos-sdk/x/staking"
+	"github.com/cosmos/cosmos-sdk/x/staking/exported"
+	"github.com/cosmos/cosmos-sdk/x/staking/keeper"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+)
+
+var (
+	_ module.AppModule           = AppModule{}
+	_ module.AppModuleBasic      = AppModuleBasic{}
+	_ module.AppModuleSimulation = AppModule{}
+)
+
+// AppModule embeds the Cosmos SDK's x/staking AppModuleBasic.
+type AppModuleBasic struct {
+	staking.AppModuleBasic
+}
+
+// AppModule embeds the Cosmos SDK's x/staking AppModule where we only override
+// specific methods.
+type AppModule struct {
+	// embed the Cosmos SDK's x/staking AppModule
+	staking.AppModule
+
+	keeper     keeper.Keeper
+	accKeeper  types.AccountKeeper
+	bankKeeper types.BankKeeper
+}
+
+// NewAppModule creates a new AppModule object using the native x/staking module
+// AppModule constructor.
+func NewAppModule(
+	cdc codec.Codec,
+	keeper *keeper.Keeper,
+	ak types.AccountKeeper,
+	bk types.BankKeeper,
+	ls exported.Subspace,
+) AppModule {
+	stakingAppMod := staking.NewAppModule(cdc, keeper, ak, bk, ls)
+	return AppModule{
+		AppModule:  stakingAppMod,
+		keeper:     *keeper,
+		accKeeper:  ak,
+		bankKeeper: bk,
+	}
+}
+
+// InitGenesis delegates the InitGenesis call to the underlying x/staking module,
+// however, it returns no validator updates as validator updates will be provided by the provider module.
+func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
+	var genesisState types.GenesisState
+
+	cdc.MustUnmarshalJSON(data, &genesisState)
+	_ = am.keeper.InitGenesis(ctx, &genesisState)
+
+	return []abci.ValidatorUpdate{}
+}
+
+// EndBlock delegates the EndBlock call to the underlying x/staking module,
+// however, it returns no validator updates as validator updates will be provided by the provider module.
+func (am AppModule) EndBlock(ctx sdk.Context) ([]abci.ValidatorUpdate, error) {
+	_, err := am.keeper.EndBlocker(ctx)
+	// return the error, but no validator updates
+	return []abci.ValidatorUpdate{}, err
+}

x/ccv/provider/keeper/params.go

@@ -78,6 +78,13 @@ func (k Keeper) GetBlocksPerEpoch(ctx sdk.Context) int64 {
 	return params.BlocksPerEpoch
 }
 
+// GetMaxProviderConsensusValidators returns the number of validators that will be passed on from the staking module
+// to the consensus engine on the provider
+func (k Keeper) GetMaxProviderConsensusValidators(ctx sdk.Context) int64 {
+	params := k.GetParams(ctx)
+	return params.MaxProviderConsensusValidators
+}
+
 // GetParams returns the paramset for the provider module
 func (k Keeper) GetParams(ctx sdk.Context) types.Params {
 	store := ctx.KVStore(k.storeKey)

x/ccv/provider/keeper/params_test.go

@@ -50,6 +50,7 @@ func TestParams(t *testing.T) {
 			Amount: math.NewInt(10000000),
 		},
 		600,
+		10,
 	)
 	providerKeeper.SetParams(ctx, newParams)
 	params = providerKeeper.GetParams(ctx)

x/ccv/provider/keeper/provider_consensus.go

@@ -0,0 +1,56 @@
+package keeper
+
+import (
+	"cosmossdk.io/math"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/cosmos/interchain-security/v5/x/ccv/provider/types"
+)
+
+// SetLastProviderConsensusValidator sets the given validator to be stored
+// as part of the last provider consensus validator set
+func (k Keeper) SetLastProviderConsensusValidator(
+	ctx sdk.Context,
+	validator types.ConsumerValidator,
+) {
+	k.setValidator(ctx, []byte{types.LastProviderConsensusValsPrefix}, validator)
+}
+
+// SetLastProviderConsensusValSet resets the stored last validator set sent to the consensus engine on the provider
+// to the provided nextValidators.
+func (k Keeper) SetLastProviderConsensusValSet(ctx sdk.Context, nextValidators []types.ConsumerValidator) {
+	k.setValSet(ctx, []byte{types.LastProviderConsensusValsPrefix}, nextValidators)
+}
+
+// DeleteLastProviderConsensusValidator removes the validator with `providerConsAddr` address
+// from the stored last provider consensus validator set
+func (k Keeper) DeleteLastProviderConsensusValidator(
+	ctx sdk.Context,
+	providerConsAddr types.ProviderConsAddress,
+) {
+	k.deleteValidator(ctx, []byte{types.LastProviderConsensusValsPrefix}, providerConsAddr)
+}
+
+// DeleteLastProviderConsensusValSet deletes all the stored validators from the
+// last provider consensus validator set
+func (k Keeper) DeleteLastProviderConsensusValSet(
+	ctx sdk.Context,
+) {
+	k.deleteValSet(ctx, []byte{types.LastProviderConsensusValsPrefix})
+}
+
+// GetLastProviderConsensusValSet returns the last stored
+// validator set sent to the consensus engine on the provider
+func (k Keeper) GetLastProviderConsensusValSet(
+	ctx sdk.Context,
+) []types.ConsumerValidator {
+	return k.getValSet(ctx, []byte{types.LastProviderConsensusValsPrefix})
+}
+
+// GetLastTotalProviderConsensusPower returns the total power of the last stored
+// validator set sent to the consensus engine on the provider
+func (k Keeper) GetLastTotalProviderConsensusPower(
+	ctx sdk.Context,
+) math.Int {
+	return k.getTotalPower(ctx, []byte{types.LastProviderConsensusValsPrefix})
+}

x/ccv/provider/keeper/provider_consensus_test.go

@@ -0,0 +1,102 @@
+package keeper_test
+
+import (
+	"testing"
+
+	"github.com/cometbft/cometbft/proto/tendermint/crypto"
+	"github.com/stretchr/testify/require"
+
+	testkeeper "github.com/cosmos/interchain-security/v5/testutil/keeper"
+	"github.com/cosmos/interchain-security/v5/x/ccv/provider/types"
+)
+
+func TestSetLastProviderConsensusValidator(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	validator := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr"),
+		Power:             2,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	providerKeeper.SetLastProviderConsensusValidator(ctx, validator)
+
+	// Retrieve the stored validator
+	storedValidator := providerKeeper.GetLastProviderConsensusValSet(ctx)[0]
+
+	require.Equal(t, validator, storedValidator, "stored validator does not match")
+}
+
+func TestSetLastProviderConsensusValSet(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	validator1 := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr1"),
+		Power:             2,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	validator2 := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr2"),
+		Power:             3,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	nextValidators := []types.ConsumerValidator{validator1, validator2}
+
+	providerKeeper.SetLastProviderConsensusValSet(ctx, nextValidators)
+
+	// Retrieve the stored validator set
+	storedValidators := providerKeeper.GetLastProviderConsensusValSet(ctx)
+	require.Equal(t, nextValidators, storedValidators, "stored validator set does not match")
+}
+
+func TestDeleteLastProviderConsensusValidator(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	validator := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr"),
+		Power:             2,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	providerKeeper.SetLastProviderConsensusValidator(ctx, validator)
+
+	// Delete the stored validator
+	providerKeeper.DeleteLastProviderConsensusValidator(ctx, types.NewProviderConsAddress(validator.ProviderConsAddr))
+
+	// Ensure the validator is deleted
+	storedValidators := providerKeeper.GetLastProviderConsensusValSet(ctx)
+	require.Empty(t, storedValidators, "validator set should be empty")
+}
+
+func TestDeleteLastProviderConsensusValSet(t *testing.T) {
+	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
+	defer ctrl.Finish()
+
+	validator1 := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr1"),
+		Power:             2,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	validator2 := types.ConsumerValidator{
+		ProviderConsAddr:  []byte("providerConsAddr2"),
+		Power:             3,
+		ConsumerPublicKey: &crypto.PublicKey{},
+	}
+
+	nextValidators := []types.ConsumerValidator{validator1, validator2}
+
+	providerKeeper.SetLastProviderConsensusValSet(ctx, nextValidators)
+
+	// Delete the stored validator set
+	providerKeeper.DeleteLastProviderConsensusValSet(ctx)
+
+	// Ensure the validator set is empty
+	storedValidators := providerKeeper.GetLastProviderConsensusValSet(ctx)
+	require.Empty(t, storedValidators, "validator set should be empty")
+}