factory: simplify validator and genesis factory functions (#7305)

internal/consensus/byzantine_test.go

@@ -7,6 +7,7 @@ import (
 	"path"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -42,7 +43,8 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 	tickerFunc := newMockTickerFunc(true)
 	appFunc := newKVStore
 
-	genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, 30)
+	valSet, privVals := factory.ValidatorSet(nValidators, 30)
+	genDoc := factory.GenesisDoc(config, time.Now(), valSet.Validators, nil)
 	states := make([]*State, nValidators)
 
 	for i := 0; i < nValidators; i++ {

internal/consensus/common_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
+	cfg "github.com/tendermint/tendermint/config"
 	cstypes "github.com/tendermint/tendermint/internal/consensus/types"
 	"github.com/tendermint/tendermint/internal/eventbus"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
@@ -492,14 +493,11 @@ func loadPrivValidator(t *testing.T, config *config.Config) *privval.FilePV {
 	return privValidator
 }
 
-func randState(
-	ctx context.Context,
-	cfg *config.Config,
-	logger log.Logger,
-	nValidators int,
-) (*State, []*validatorStub, error) {
+func makeState(ctx context.Context, cfg *config.Config, logger log.Logger, nValidators int) (*State, []*validatorStub, error) {
 	// Get State
-	state, privVals := randGenesisState(cfg, nValidators, false, 10)
+	state, privVals := makeGenesisState(cfg, genesisStateArgs{
+		Validators: nValidators,
+	})
 
 	vss := make([]*validatorStub, nValidators)
 
@@ -764,7 +762,7 @@ func consensusLogger() log.Logger {
 	return log.TestingLogger().With("module", "consensus")
 }
 
-func randConsensusState(
+func makeConsensusState(
 	ctx context.Context,
 	t *testing.T,
 	cfg *config.Config,
@@ -776,7 +774,8 @@ func randConsensusState(
 ) ([]*State, cleanupFunc) {
 	t.Helper()
 
-	genDoc, privVals := factory.RandGenesisDoc(cfg, nValidators, false, 30)
+	valSet, privVals := factory.ValidatorSet(nValidators, 30)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
 	css := make([]*State, nValidators)
 	logger := consensusLogger()
 
@@ -834,7 +833,8 @@ func randConsensusNetWithPeers(
 	tickerFunc func() TimeoutTicker,
 	appFunc func(string) abci.Application,
 ) ([]*State, *types.GenesisDoc, *config.Config, cleanupFunc) {
-	genDoc, privVals := factory.RandGenesisDoc(cfg, nValidators, false, testMinPower)
+	valSet, privVals := factory.ValidatorSet(nValidators, testMinPower)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
 	css := make([]*State, nPeers)
 	t.Helper()
 	logger := consensusLogger()
@@ -891,13 +891,28 @@ func randConsensusNetWithPeers(
 	}
 }
 
-func randGenesisState(
-	cfg *config.Config,
-	numValidators int,
-	randPower bool,
-	minPower int64) (sm.State, []types.PrivValidator) {
+type genesisStateArgs struct {
+	Validators int
+	Power      int64
+	Params     *types.ConsensusParams
+	Time       time.Time
+}
 
-	genDoc, privValidators := factory.RandGenesisDoc(cfg, numValidators, randPower, minPower)
+func makeGenesisState(config *cfg.Config, args genesisStateArgs) (sm.State, []types.PrivValidator) {
+	if args.Power == 0 {
+		args.Power = 1
+	}
+	if args.Validators == 0 {
+		args.Power = 4
+	}
+	valSet, privValidators := factory.ValidatorSet(args.Validators, args.Power)
+	if args.Params == nil {
+		args.Params = types.DefaultConsensusParams()
+	}
+	if args.Time.IsZero() {
+		args.Time = time.Now()
+	}
+	genDoc := factory.GenesisDoc(config, args.Time, valSet.Validators, args.Params)
 	s0, _ := sm.MakeGenesisState(genDoc)
 	return s0, privValidators
 }

internal/consensus/invalid_test.go

@@ -23,7 +23,7 @@ func TestReactorInvalidPrecommit(t *testing.T) {
 	config := configSetup(t)
 
 	n := 4
-	states, cleanup := randConsensusState(ctx, t,
+	states, cleanup := makeConsensusState(ctx, t,
 		config, n, "consensus_reactor_test",
 		newMockTickerFunc(true), newKVStore)
 	t.Cleanup(cleanup)

internal/consensus/mempool_test.go

@@ -37,7 +37,9 @@ func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
 	config.Consensus.CreateEmptyBlocks = false
-	state, privVals := randGenesisState(baseConfig, 1, false, 10)
+	state, privVals := makeGenesisState(baseConfig, genesisStateArgs{
+		Validators: 1,
+		Power:      10})
 	cs := newStateWithConfig(ctx, log.TestingLogger(), config, state, privVals[0], NewCounterApplication())
 	assertMempool(cs.txNotifier).EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
@@ -62,7 +64,9 @@ func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
 	config.Consensus.CreateEmptyBlocksInterval = ensureTimeout
-	state, privVals := randGenesisState(baseConfig, 1, false, 10)
+	state, privVals := makeGenesisState(baseConfig, genesisStateArgs{
+		Validators: 1,
+		Power:      10})
 	cs := newStateWithConfig(ctx, log.TestingLogger(), config, state, privVals[0], NewCounterApplication())
 
 	assertMempool(cs.txNotifier).EnableTxsAvailable()
@@ -85,7 +89,9 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
 	config.Consensus.CreateEmptyBlocks = false
-	state, privVals := randGenesisState(baseConfig, 1, false, 10)
+	state, privVals := makeGenesisState(baseConfig, genesisStateArgs{
+		Validators: 1,
+		Power:      10})
 	cs := newStateWithConfig(ctx, log.TestingLogger(), config, state, privVals[0], NewCounterApplication())
 	assertMempool(cs.txNotifier).EnableTxsAvailable()
 	height, round := cs.Height, cs.Round
@@ -136,7 +142,9 @@ func TestMempoolTxConcurrentWithCommit(t *testing.T) {
 
 	config := configSetup(t)
 	logger := log.TestingLogger()
-	state, privVals := randGenesisState(config, 1, false, 10)
+	state, privVals := makeGenesisState(config, genesisStateArgs{
+		Validators: 1,
+		Power:      10})
 	stateStore := sm.NewStore(dbm.NewMemDB())
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 
@@ -168,7 +176,9 @@ func TestMempoolRmBadTx(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	state, privVals := randGenesisState(config, 1, false, 10)
+	state, privVals := makeGenesisState(config, genesisStateArgs{
+		Validators: 1,
+		Power:      10})
 	app := NewCounterApplication()
 	stateStore := sm.NewStore(dbm.NewMemDB())
 	blockStore := store.NewBlockStore(dbm.NewMemDB())

internal/consensus/reactor_test.go

@@ -311,7 +311,7 @@ func TestReactorBasic(t *testing.T) {
 	cfg := configSetup(t)
 
 	n := 4
-	states, cleanup := randConsensusState(ctx, t,
+	states, cleanup := makeConsensusState(ctx, t,
 		cfg, n, "consensus_reactor_test",
 		newMockTickerFunc(true), newKVStore)
 	t.Cleanup(cleanup)
@@ -368,7 +368,8 @@ func TestReactorWithEvidence(t *testing.T) {
 	tickerFunc := newMockTickerFunc(true)
 	appFunc := newKVStore
 
-	genDoc, privVals := factory.RandGenesisDoc(cfg, n, false, 30)
+	valSet, privVals := factory.ValidatorSet(n, 30)
+	genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, nil)
 	states := make([]*State, n)
 	logger := consensusLogger()
 
@@ -470,8 +471,7 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
 	cfg := configSetup(t)
 
 	n := 4
-	states, cleanup := randConsensusState(
-		ctx,
+	states, cleanup := makeConsensusState(ctx,
 		t,
 		cfg,
 		n,
@@ -527,7 +527,7 @@ func TestReactorRecordsVotesAndBlockParts(t *testing.T) {
 	cfg := configSetup(t)
 
 	n := 4
-	states, cleanup := randConsensusState(ctx, t,
+	states, cleanup := makeConsensusState(ctx, t,
 		cfg, n, "consensus_reactor_test",
 		newMockTickerFunc(true), newKVStore)
 	t.Cleanup(cleanup)
@@ -592,8 +592,7 @@ func TestReactorVotingPowerChange(t *testing.T) {
 	cfg := configSetup(t)
 
 	n := 4
-	states, cleanup := randConsensusState(
-		ctx,
+	states, cleanup := makeConsensusState(ctx,
 		t,
 		cfg,
 		n,

internal/consensus/replay_test.go

@@ -1274,7 +1274,8 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	val, _ := factory.RandValidator(true, 10)
+	votePower := 10 + int64(rand.Uint32())
+	val, _ := factory.Validator(votePower)
 	vals := types.NewValidatorSet([]*types.Validator{val})
 	app := &initChainApp{vals: types.TM2PB.ValidatorUpdates(vals)}
 	clientCreator := abciclient.NewLocalCreator(app)

internal/consensus/state_test.go

@@ -66,10 +66,10 @@ func TestStateProposerSelection0(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	config := configSetup(t)
+	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
-
 	height, round := cs1.Height, cs1.Round
 
 	newRoundCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryNewRound)
@@ -118,13 +118,12 @@ func TestStateProposerSelection0(t *testing.T) {
 // Now let's do it all again, but starting from round 2 instead of 0
 func TestStateProposerSelection2(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4) // test needs more work for more than 3 validators
+	cs1, vss, err := makeState(ctx, config, logger, 4) // test needs more work for more than 3 validators
 	require.NoError(t, err)
-
 	height := cs1.Height
 	newRoundCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryNewRound)
 
@@ -161,10 +160,12 @@ func TestStateProposerSelection2(t *testing.T) {
 // a non-validator should timeout into the prevote round
 func TestStateEnterProposeNoPrivValidator(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs, _, err := randState(ctx, config, log.TestingLogger(), 1)
+	cs, _, err := makeState(ctx, config, logger, 1)
+	require.NoError(t, err)
 	require.NoError(t, err)
 	cs.SetPrivValidator(nil)
 	height, round := cs.Height, cs.Round
@@ -185,10 +186,11 @@ func TestStateEnterProposeNoPrivValidator(t *testing.T) {
 // a validator should not timeout of the prevote round (TODO: unless the block is really big!)
 func TestStateEnterProposeYesPrivValidator(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs, _, err := randState(ctx, config, log.TestingLogger(), 1)
+	cs, _, err := makeState(ctx, config, logger, 1)
 	require.NoError(t, err)
 	height, round := cs.Height, cs.Round
 
@@ -220,10 +222,11 @@ func TestStateEnterProposeYesPrivValidator(t *testing.T) {
 
 func TestStateBadProposal(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs1, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 	height, round := cs1.Height, cs1.Round
 	vs2 := vss[1]
@@ -283,10 +286,11 @@ func TestStateBadProposal(t *testing.T) {
 
 func TestStateOversizedBlock(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs1, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 	cs1.state.ConsensusParams.Block.MaxBytes = 2000
 	height, round := cs1.Height, cs1.Round
@@ -354,7 +358,7 @@ func TestStateFullRound1(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs, vss, err := randState(ctx, config, logger, 1)
+	cs, vss, err := makeState(ctx, config, logger, 1)
 	require.NoError(t, err)
 	height, round := cs.Height, cs.Round
 
@@ -396,10 +400,11 @@ func TestStateFullRound1(t *testing.T) {
 // nil is proposed, so prevote and precommit nil
 func TestStateFullRoundNil(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs, vss, err := randState(ctx, config, log.TestingLogger(), 1)
+	cs, vss, err := makeState(ctx, config, logger, 1)
 	require.NoError(t, err)
 	height, round := cs.Height, cs.Round
 
@@ -419,10 +424,11 @@ func TestStateFullRoundNil(t *testing.T) {
 // where the first validator has to wait for votes from the second
 func TestStateFullRound2(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs1, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 	vs2 := vss[1]
 	height, round := cs1.Height, cs1.Round
@@ -464,10 +470,11 @@ func TestStateFullRound2(t *testing.T) {
 // two vals take turns proposing. val1 locks on first one, precommits nil on everything else
 func TestStateLock_NoPOL(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs1, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 	vs2 := vss[1]
 	height, round := cs1.Height, cs1.Round
@@ -605,8 +612,7 @@ func TestStateLock_NoPOL(t *testing.T) {
 
 	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
 
-	// needed so generated block is different than locked block
-	cs2, _, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs2, _, err := makeState(ctx, config, logger, 2) // needed so generated block is different than locked block
 	require.NoError(t, err)
 	// before we time out into new round, set next proposal block
 	prop, propBlock := decideProposal(ctx, t, cs2, vs2, vs2.Height, vs2.Round+1)
@@ -666,7 +672,7 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -770,8 +776,9 @@ func TestStateLock_POLRelock(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	config := configSetup(t)
+	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -871,8 +878,9 @@ func TestStateLock_PrevoteNilWhenLockedAndMissProposal(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	config := configSetup(t)
+	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -960,7 +968,7 @@ func TestStateLock_PrevoteNilWhenLockedAndDifferentProposal(t *testing.T) {
 		state.
 	*/
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1062,7 +1070,7 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 		state.
 	*/
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1199,7 +1207,7 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1285,8 +1293,9 @@ func TestStateLock_DoesNotLockOnOldProposal(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	config := configSetup(t)
+	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1364,7 +1373,7 @@ func TestStateLock_POLSafety1(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1486,7 +1495,7 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1585,7 +1594,7 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 	config := configSetup(t)
 	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, logger, 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1724,10 +1733,11 @@ func TestState_PrevotePOLFromPreviousRound(t *testing.T) {
 // P0 proposes B0 at R3.
 func TestProposeValidBlock(t *testing.T) {
 	cfg := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, cfg, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, cfg, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1818,10 +1828,11 @@ func TestProposeValidBlock(t *testing.T) {
 // P0 miss to lock B but set valid block to B after receiving delayed prevote.
 func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1885,10 +1896,11 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 // receiving delayed Block Proposal.
 func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1945,12 +1957,12 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 // What we want:
 // P0 waits for timeoutPrecommit before starting next round
 func TestWaitingTimeoutOnNilPolka(t *testing.T) {
-	config := configSetup(t)
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	config := configSetup(t)
+	logger := log.TestingLogger()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -1973,10 +1985,11 @@ func TestWaitingTimeoutOnNilPolka(t *testing.T) {
 // P0 waits for timeoutPropose in the next round before entering prevote
 func TestWaitingTimeoutProposeOnNewRound(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -2014,10 +2027,11 @@ func TestWaitingTimeoutProposeOnNewRound(t *testing.T) {
 // P0 jump to higher round, precommit and start precommit wait
 func TestRoundSkipOnNilPolkaFromHigherRound(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -2055,10 +2069,11 @@ func TestRoundSkipOnNilPolkaFromHigherRound(t *testing.T) {
 // P0 wait for timeoutPropose to expire before sending prevote.
 func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, int32(1)
@@ -2087,10 +2102,11 @@ func TestWaitTimeoutProposeOnNilPolkaForTheCurrentRound(t *testing.T) {
 // P0 emit NewValidBlock event upon receiving 2/3+ Precommit for B but hasn't received block B yet
 func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, int32(1)
@@ -2126,10 +2142,11 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) {
 // After receiving block, it executes block and moves to the next height.
 func TestCommitFromPreviousRound(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, int32(1)
@@ -2184,11 +2201,12 @@ func (n *fakeTxNotifier) Notify() {
 // start of the next round
 func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	config.Consensus.SkipTimeoutCommit = false
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	cs1.txNotifier = &fakeTxNotifier{ch: make(chan struct{})}
 
@@ -2250,11 +2268,12 @@ func TestStartNextHeightCorrectlyAfterTimeout(t *testing.T) {
 
 func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	config.Consensus.SkipTimeoutCommit = false
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
@@ -2397,10 +2416,11 @@ func TestStateSlashing_Precommits(t *testing.T) {
 // we receive a final precommit after going into next round, but others might have gone to commit already!
 func TestStateHalt1(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs1, vss, err := randState(ctx, config, log.TestingLogger(), 4)
+	cs1, vss, err := makeState(ctx, config, logger, 4)
 	require.NoError(t, err)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
@@ -2468,14 +2488,14 @@ func TestStateHalt1(t *testing.T) {
 
 func TestStateOutputsBlockPartsStats(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	// create dummy peer
-	cs, _, err := randState(ctx, config, log.TestingLogger(), 1)
+	cs, _, err := makeState(ctx, config, logger, 1)
 	require.NoError(t, err)
 	peerID, err := types.NewNodeID("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
-	require.NoError(t, err)
 
 	// 1) new block part
 	parts := types.NewPartSetFromData(tmrand.Bytes(100), 10)
@@ -2517,10 +2537,11 @@ func TestStateOutputsBlockPartsStats(t *testing.T) {
 
 func TestStateOutputVoteStats(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cs, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	cs, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 	// create dummy peer
 	peerID, err := types.NewNodeID("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
@@ -2556,10 +2577,11 @@ func TestStateOutputVoteStats(t *testing.T) {
 
 func TestSignSameVoteTwice(t *testing.T) {
 	config := configSetup(t)
+	logger := log.TestingLogger()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	_, vss, err := randState(ctx, config, log.TestingLogger(), 2)
+	_, vss, err := makeState(ctx, config, logger, 2)
 	require.NoError(t, err)
 
 	randBytes := tmrand.Bytes(tmhash.Size)

internal/consensus/types/height_vote_set_test.go

@@ -32,7 +32,7 @@ func TestPeerCatchupRounds(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	valSet, privVals := factory.RandValidatorSet(10, 1)
+	valSet, privVals := factory.ValidatorSet(10, 1)
 
 	hvs := NewHeightVoteSet(cfg.ChainID(), 1, valSet)