diff --git a/types/validator_set.go b/types/validator_set.go
index 5ef9a1be58..99592ce74a 100644
--- a/types/validator_set.go
+++ b/types/validator_set.go
@@ -2,15 +2,29 @@ package types
 
 import (
 	abci "github.com/tendermint/abci/types"
+	"github.com/tendermint/go-crypto"
 )
 
-type Validator = abci.Validator
+type Validator interface {
+	GetAddress() Address
+	GetPubKey() crypto.PubKey
+	GetPower() Rat
+}
+
+func ABCIValidator(v Validator) abci.Validator {
+	return abci.Validator{
+		PubKey: v.GetPubKey().Bytes(),
+		Power:  v.GetPower().Evaluate(),
+	}
+}
+
+type ValidatorSet interface {
+	Iterate(func(int, Validator))
+	Size() int
+}
 
 type ValidatorSetKeeper interface {
-	Validators(Context) []*Validator
-	Size(Context) int
-	IsValidator(Context, Address) bool
-	GetByAddress(Context, Address) (int, *Validator)
-	GetByIndex(Context, int) *Validator
+	ValidatorSet(Context) ValidatorSet
+	GetByAddress(Context, Address) Validator
 	TotalPower(Context) Rat
 }
diff --git a/x/stake/keeper.go b/x/stake/keeper.go
index be62134c92..7a810a351a 100644
--- a/x/stake/keeper.go
+++ b/x/stake/keeper.go
@@ -505,50 +505,20 @@ func (k Keeper) setPool(ctx sdk.Context, p Pool) {
 
 var _ sdk.ValidatorSetKeeper = Keeper{}
 
-func (k Keeper) Validators(ctx sdk.Context) []*sdk.Validator {
+func (k Keeper) ValidatorSet(ctx sdk.Context) sdk.ValidatorSet {
 	vals := k.GetValidators(ctx)
-	res := make([]*sdk.Validator, len(vals))
-
-	for i, val := range vals {
-		abcival := val.abciValidator(k.cdc)
-		res[i] = &abcival
-	}
-
-	return res
+	return ValidatorSet(vals)
 }
 
-func (k Keeper) Size(ctx sdk.Context) int {
-	return len(k.GetValidators(ctx))
-}
-
-func (k Keeper) IsValidator(ctx sdk.Context, addr sdk.Address) bool {
-	for _, v := range k.GetValidators(ctx) {
-		if bytes.Equal(v.Address, addr) {
-			return true
-		}
-	}
-	return false
-}
-
-func (k Keeper) GetByAddress(ctx sdk.Context, addr sdk.Address) (int, *sdk.Validator) {
-	for i, v := range k.GetValidators(ctx) {
-		if bytes.Equal(v.Address, addr) {
-			val := v.abciValidator(k.cdc)
-			return i, &val
-		}
-	}
-	return -1, nil
-}
-
-func (k Keeper) GetByIndex(ctx sdk.Context, index int) *sdk.Validator {
-	valset := k.GetValidators(ctx)
-
-	if index < 0 || index >= len(valset) {
+func (k Keeper) GetByAddress(ctx sdk.Context, addr sdk.Address) sdk.Validator {
+	can, ok := k.GetCandidate(ctx, addr)
+	if !ok {
 		return nil
 	}
-
-	val := valset[index].abciValidator(k.cdc)
-	return &val
+	if can.Status != Bonded {
+		return nil
+	}
+	return can.validator()
 }
 
 func (k Keeper) TotalPower(ctx sdk.Context) sdk.Rat {
diff --git a/x/stake/types.go b/x/stake/types.go
index 0ff7531d8f..f9f6b4a23e 100644
--- a/x/stake/types.go
+++ b/x/stake/types.go
@@ -4,9 +4,9 @@ import (
 	"bytes"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	crypto "github.com/tendermint/go-crypto"
-
 	"github.com/cosmos/cosmos-sdk/wire"
+	abci "github.com/tendermint/abci/types"
+	crypto "github.com/tendermint/go-crypto"
 )
 
 // GenesisState - all staking state that must be provided at genesis
@@ -292,8 +292,8 @@ func (v Validator) equal(v2 Validator) bool {
 }
 
 // abci validator from stake validator type
-func (v Validator) abciValidator(cdc *wire.Codec) sdk.Validator {
-	return sdk.Validator{
+func (v Validator) abciValidator(cdc *wire.Codec) abci.Validator {
+	return abci.Validator{
 		PubKey: v.PubKey.Bytes(),
 		Power:  v.Power.Evaluate(),
 	}
@@ -301,19 +301,40 @@ func (v Validator) abciValidator(cdc *wire.Codec) sdk.Validator {
 
 // abci validator from stake validator type
 // with zero power used for validator updates
-func (v Validator) abciValidatorZero(cdc *wire.Codec) sdk.Validator {
-	return sdk.Validator{
+func (v Validator) abciValidatorZero(cdc *wire.Codec) abci.Validator {
+	return abci.Validator{
 		PubKey: v.PubKey.Bytes(),
 		Power:  0,
 	}
 }
 
-// sortable validator list for testing
-type validators []Validator
+var _ sdk.Validator = Validator{}
 
-func (v validators) Len() int           { return len(v) }
-func (v validators) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
-func (v validators) Less(i, j int) bool { return v[i].Power.LT(v[j].Power) }
+func (v Validator) GetAddress() sdk.Address {
+	return v.Address
+}
+
+func (v Validator) GetPubKey() crypto.PubKey {
+	return v.PubKey
+}
+
+func (v Validator) GetPower() sdk.Rat {
+	return v.Power
+}
+
+type ValidatorSet []Validator
+
+var _ sdk.ValidatorSet = ValidatorSet{}
+
+func (vs ValidatorSet) Iterate(fn func(int, sdk.Validator)) {
+	for i, v := range vs {
+		fn(i, v)
+	}
+}
+
+func (vs ValidatorSet) Size() int {
+	return len(vs)
+}
 
 //_________________________________________________________________________