have a constant define min num of bonded in proposer set

Author: tqin7

tests/integration/staking/keeper/genesis_test.go

@@ -143,10 +143,10 @@ func TestInitGenesis(t *testing.T) {
 }
 
 func TestInitGenesisWithProposerSet(t *testing.T) {
-	f, addrs := bootstrapGenesisTest(t, 3)
+	f, addrs := bootstrapGenesisTest(t, 6)
 
-	validators := make([]types.Validator, 3)
-	for i := 0; i < 3; i++ {
+	validators := make([]types.Validator, 6)
+	for i := 0; i < 6; i++ {
 		pk, err := codectypes.NewAnyWithValue(PKs[i])
 		assert.NilError(t, err)
 
@@ -162,8 +162,11 @@ func TestInitGenesisWithProposerSet(t *testing.T) {
 	params := types.DefaultParams()
 	params.BondDenom = sdk.DefaultBondDenom
 
-	// Set only first two validators as proposers
-	proposers := []string{validators[0].OperatorAddress, validators[1].OperatorAddress}
+	// Set first 5 validators as proposers (meets MIN_BONDED_IN_PROPOSER_SET requirement)
+	proposers := make([]string, 5)
+	for i := 0; i < 5; i++ {
+		proposers[i] = validators[i].OperatorAddress
+	}
 	genesisState := &types.GenesisState{
 		Params:     params,
 		Validators: validators,
@@ -176,7 +179,7 @@ func TestInitGenesisWithProposerSet(t *testing.T) {
 			f.sdkCtx,
 			f.bankKeeper,
 			types.BondedPoolName,
-			sdk.NewCoins(sdk.NewCoin(params.BondDenom, math.NewInt(300))),
+			sdk.NewCoins(sdk.NewCoin(params.BondDenom, math.NewInt(600))),
 		),
 	)
 
@@ -186,19 +189,11 @@ func TestInitGenesisWithProposerSet(t *testing.T) {
 	// Verify proposer set in state.
 	actualProposers, err := f.stakingKeeper.GetProposers(f.sdkCtx)
 	assert.NilError(t, err)
-	assert.DeepEqual(
-		t,
-		[]string{validators[0].OperatorAddress, validators[1].OperatorAddress},
-		actualProposers,
-	)
+	assert.DeepEqual(t, proposers, actualProposers)
 
 	// Verify proposer set in genesis export
 	exportedGenesis := f.stakingKeeper.ExportGenesis(f.sdkCtx)
-	assert.DeepEqual(
-		t,
-		[]string{validators[0].OperatorAddress, validators[1].OperatorAddress},
-		exportedGenesis.Proposers,
-	)
+	assert.DeepEqual(t, proposers, exportedGenesis.Proposers)
 }
 
 func TestInitGenesis_PoolsBalanceMismatch(t *testing.T) {

x/staking/keeper/proposer_set.go

@@ -3,11 +3,16 @@ package keeper
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 
+	errorsmod "cosmossdk.io/errors"
 	"github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
+const (
+	// minimum number of bonded validators required in a proposer set
+	MIN_BONDED_IN_PROPOSER_SET = 5
+)
+
 // GetProposers returns all proposers by their operator addresses.
 // Note: Returns empty array when no proposers are set
 func (k Keeper) GetProposers(ctx context.Context) ([]string, error) {
@@ -49,12 +54,13 @@ func (k Keeper) SetProposers(ctx context.Context, proposers []string) error {
 // checkProposerSetInvariant validates invariants of a proposer set, which are:
 // - all proposers are valid operator addresses
 // - all proposers correspond to existing validators
-// - at least one proposer is bonded
+// - at least MIN_BONDED_IN_PROPOSER_SET proposers are bonded
 func (k Keeper) checkProposerSetInvariants(ctx context.Context, proposers []string) error {
 	if len(proposers) == 0 {
 		return nil // Valid as x/staking will default to all validators being proposers.
 	}
 
+	bonded := 0
 	for _, proposerAddr := range proposers {
 		operatorAddr, err := k.validatorAddressCodec.StringToBytes(proposerAddr)
 		if err != nil {
@@ -65,10 +71,17 @@ func (k Keeper) checkProposerSetInvariants(ctx context.Context, proposers []stri
 		if err != nil {
 			return err
 		}
+
 		if validator.Status == types.Bonded {
-			return nil
+			bonded++
 		}
 	}
 
-	return fmt.Errorf("at least one proposer must be bonded")
+	if bonded < MIN_BONDED_IN_PROPOSER_SET {
+		return errorsmod.Wrapf(types.ErrInsufficientBondedValidators,
+			"proposer set only has %d bonded validators, less than the required %d",
+			bonded, MIN_BONDED_IN_PROPOSER_SET)
+	}
+
+	return nil
 }

x/staking/keeper/proposer_set_test.go

@@ -15,13 +15,13 @@ func (s *KeeperTestSuite) TestGetSetProposers() {
 	require.NoError(err)
 	require.Empty(proposers)
 
-	// Create three bonded validators and one unbonding validator
-	validators := make([]string, 4)
-	for i := 0; i < 4; i++ {
+	// Create six validators: 5 bonded and 1 unbonding
+	validators := make([]string, 6)
+	for i := 0; i < 6; i++ {
 		valPubKey := PKs[i]
 		valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 		validator := testutil.NewValidator(s.T(), valAddr, valPubKey)
-		if i == 3 {
+		if i == 5 {
 			validator.Status = types.Unbonding
 		} else {
 			validator.Status = types.Bonded
@@ -31,25 +31,21 @@ func (s *KeeperTestSuite) TestGetSetProposers() {
 		require.NoError(err)
 	}
 
-	// Set the first validator as a proposer and verify
-	err = keeper.SetProposers(ctx, validators[:1])
+	// Set first 5 validators as proposers and verify
+	err = keeper.SetProposers(ctx, validators[:5])
 	require.NoError(err)
 
 	proposers, err = keeper.GetProposers(ctx)
 	require.NoError(err)
-	require.Equal(validators[:1], proposers)
+	require.Equal(validators[:5], proposers)
 
-	// Set last two validators as proposers and verify
-	// Should succeed as there's at least one bonded proposer
-	err = keeper.SetProposers(ctx, validators[2:])
-	require.NoError(err)
-
-	proposers, err = keeper.GetProposers(ctx)
-	require.NoError(err)
-	require.Equal(validators[2:], proposers)
+	// Set last 5 validators as proposers
+	// Should fail as there are insufficient bonded proposers
+	err = keeper.SetProposers(ctx, validators[1:])
+	require.Error(err)
+	require.ErrorContains(err, "proposer set only has 4 bonded validators, less than the required 5")
 
 	// Set all validators as proposers and verify
-	// Should succeed as there's at least one bonded proposer
 	err = keeper.SetProposers(ctx, validators)
 	require.NoError(err)
 
@@ -74,9 +70,11 @@ func (s *KeeperTestSuite) TestSetProposersErrors() {
 	valPubKey := PKs[0]
 	valAddr := sdk.ValAddress(valPubKey.Address().Bytes())
 	validator := testutil.NewValidator(s.T(), valAddr, valPubKey)
+	err := keeper.SetValidator(ctx, validator)
+	require.NoError(err)
 
 	// Should return error given invalid addresses
-	err := keeper.SetProposers(ctx, []string{"invalid-address"})
+	err = keeper.SetProposers(ctx, []string{"invalid-address"})
 	require.Error(err, "SetProposers with invalid address should return error")
 
 	// Should return error for non-operator addresses (e.g. account and consensus addresses)
@@ -93,11 +91,4 @@ func (s *KeeperTestSuite) TestSetProposersErrors() {
 	nonExistentValAddr := sdk.ValAddress(nonExistentPubKey.Address().Bytes())
 	err = keeper.SetProposers(ctx, []string{nonExistentValAddr.String()})
 	require.ErrorContains(err, "validator does not exist")
-
-	// Should return error if no proposer is bonded.
-	validator.Status = types.Unbonded
-	err = keeper.SetValidator(ctx, validator)
-	require.NoError(err)
-	err = keeper.SetProposers(ctx, []string{validator.OperatorAddress})
-	require.ErrorContains(err, "at least one proposer must be bonded")
 }

x/staking/types/errors.go

@@ -48,4 +48,5 @@ var (
 	ErrInvalidSigner                   = errors.Register(ModuleName, 43, "expected authority account as only signer for proposal message")
 	ErrBadRedelegationSrc              = errors.Register(ModuleName, 44, "redelegation source validator not found")
 	ErrNoUnbondingType                 = errors.Register(ModuleName, 45, "unbonding type not found")
+	ErrInsufficientBondedValidators    = errors.Register(ModuleName, 500, "insufficient number of bonded validators")
 )

x/staking/types/keys.go

@@ -59,7 +59,7 @@ var (
 
 	// key for proposer set
 	// Note: all validators default to being proposers if proposer set is empty
-	ProposerSetKey = []byte("ProposerSet")
+	ProposerSetKey = []byte("PS")
 )
 
 // UnbondingType defines the type of unbonding operation