breakout use of GetValidatorByConsAddr

types/stake.go

@@ -42,6 +42,7 @@ type Validator interface {
 	GetStatus() BondStatus    // status of the validator
 	GetOperator() ValAddress  // operator address to receive/return validators coins
 	GetPubKey() crypto.PubKey // validation pubkey
+	GetConsAddr() ConsAddress // validation consensus address
 	GetPower() Dec            // validation power
 	GetTokens() Dec           // validation tokens
 	GetCommission() Dec       // validator commission rate
@@ -73,9 +74,9 @@ type ValidatorSet interface {
 	TotalPower(Context) Dec                             // total power of the validator set
 
 	// slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction
-	Slash(Context, crypto.PubKey, int64, int64, Dec)
-	Jail(Context, crypto.PubKey)   // jail a validator
-	Unjail(Context, crypto.PubKey) // unjail a validator
+	Slash(Context, ConsAddress, int64, int64, Dec)
+	Jail(Context, ConsAddress)   // jail a validator
+	Unjail(Context, ConsAddress) // unjail a validator
 
 	// Delegation allows for getting a particular delegation for a given validator
 	// and delegator outside the scope of the staking module.

x/gov/handler.go

@@ -155,7 +155,7 @@ func EndBlocker(ctx sdk.Context, keeper Keeper) (resTags sdk.Tags) {
 		for _, valAddr := range nonVotingVals {
 			val := keeper.ds.GetValidatorSet().Validator(ctx, valAddr)
 			keeper.ds.GetValidatorSet().Slash(ctx,
-				val.GetPubKey(),
+				val.GetConsAddr(),
 				ctx.BlockHeight(),
 				val.GetPower().RoundInt64(),
 				keeper.GetTallyingProcedure(ctx).GovernancePenalty)

x/slashing/handler.go

@@ -34,9 +34,9 @@ func handleMsgUnjail(ctx sdk.Context, msg MsgUnjail, k Keeper) sdk.Result {
 		return ErrValidatorNotJailed(k.codespace).Result()
 	}
 
-	addr := sdk.ConsAddress(validator.GetPubKey().Address())
+	consAddr := sdk.ConsAddress(validator.GetPubKey().Address())
 
-	info, found := k.getValidatorSigningInfo(ctx, addr)
+	info, found := k.getValidatorSigningInfo(ctx, consAddr)
 	if !found {
 		return ErrNoValidatorForAddress(k.codespace).Result()
 	}
@@ -49,9 +49,9 @@ func handleMsgUnjail(ctx sdk.Context, msg MsgUnjail, k Keeper) sdk.Result {
 	// update the starting height so the validator can't be immediately jailed
 	// again
 	info.StartHeight = ctx.BlockHeight()
-	k.setValidatorSigningInfo(ctx, addr, info)
+	k.setValidatorSigningInfo(ctx, consAddr, info)
 
-	k.validatorSet.Unjail(ctx, validator.GetPubKey())
+	k.validatorSet.Unjail(ctx, consAddr)
 
 	tags := sdk.NewTags("action", []byte("unjail"), "validator", []byte(msg.ValidatorAddr.String()))
 

x/slashing/keeper.go

@@ -40,10 +40,10 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
 	logger := ctx.Logger().With("module", "x/slashing")
 	time := ctx.BlockHeader().Time
 	age := time.Sub(timestamp)
-	address := sdk.ConsAddress(addr)
+	consAddr := sdk.ConsAddress(addr)
 	pubkey, err := k.getPubkey(ctx, addr)
 	if err != nil {
-		panic(fmt.Sprintf("Validator address %v not found", addr))
+		panic(fmt.Sprintf("Validator consensus-address %v not found", consAddr))
 	}
 
 	// Double sign too old
@@ -59,37 +59,37 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio
 	// Cap the amount slashed to the penalty for the worst infraction
 	// within the slashing period when this infraction was committed
 	fraction := k.SlashFractionDoubleSign(ctx)
-	revisedFraction := k.capBySlashingPeriod(ctx, address, fraction, infractionHeight)
+	revisedFraction := k.capBySlashingPeriod(ctx, consAddr, fraction, infractionHeight)
 	logger.Info(fmt.Sprintf("Fraction slashed capped by slashing period from %v to %v", fraction, revisedFraction))
 
 	// Slash validator
-	k.validatorSet.Slash(ctx, pubkey, infractionHeight, power, revisedFraction)
+	k.validatorSet.Slash(ctx, consAddr, infractionHeight, power, revisedFraction)
 
 	// Jail validator
-	k.validatorSet.Jail(ctx, pubkey)
+	k.validatorSet.Jail(ctx, consAddr)
 
 	// Set validator jail duration
-	signInfo, found := k.getValidatorSigningInfo(ctx, address)
+	signInfo, found := k.getValidatorSigningInfo(ctx, consAddr)
 	if !found {
-		panic(fmt.Sprintf("Expected signing info for validator %s but not found", address))
+		panic(fmt.Sprintf("Expected signing info for validator %s but not found", consAddr))
 	}
 	signInfo.JailedUntil = time.Add(k.DoubleSignUnbondDuration(ctx))
-	k.setValidatorSigningInfo(ctx, address, signInfo)
+	k.setValidatorSigningInfo(ctx, consAddr, signInfo)
 }
 
 // handle a validator signature, must be called once per validator per block
 // nolint gocyclo
 func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, power int64, signed bool) {
 	logger := ctx.Logger().With("module", "x/slashing")
 	height := ctx.BlockHeight()
-	address := sdk.ConsAddress(addr)
+	consAddr := sdk.ConsAddress(addr)
 	pubkey, err := k.getPubkey(ctx, addr)
 	if err != nil {
-		panic(fmt.Sprintf("Validator address %v not found", addr))
+		panic(fmt.Sprintf("Validator consensus-address %v not found", consAddr))
 	}
 	// Local index, so counts blocks validator *should* have signed
 	// Will use the 0-value default signing info if not present, except for start height
-	signInfo, found := k.getValidatorSigningInfo(ctx, address)
+	signInfo, found := k.getValidatorSigningInfo(ctx, consAddr)
 	if !found {
 		// If this validator has never been seen before, construct a new SigningInfo with the correct start height
 		signInfo = NewValidatorSigningInfo(height, 0, time.Unix(0, 0), 0)
@@ -100,16 +100,16 @@ func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, p
 	// Update signed block bit array & counter
 	// This counter just tracks the sum of the bit array
 	// That way we avoid needing to read/write the whole array each time
-	previous := k.getValidatorSigningBitArray(ctx, address, index)
+	previous := k.getValidatorSigningBitArray(ctx, consAddr, index)
 	if previous == signed {
 		// Array value at this index has not changed, no need to update counter
 	} else if previous && !signed {
 		// Array value has changed from signed to unsigned, decrement counter
-		k.setValidatorSigningBitArray(ctx, address, index, false)
+		k.setValidatorSigningBitArray(ctx, consAddr, index, false)
 		signInfo.SignedBlocksCounter--
 	} else if !previous && signed {
 		// Array value has changed from unsigned to signed, increment counter
-		k.setValidatorSigningBitArray(ctx, address, index, true)
+		k.setValidatorSigningBitArray(ctx, consAddr, index, true)
 		signInfo.SignedBlocksCounter++
 	}
 
@@ -118,13 +118,13 @@ func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, p
 	}
 	minHeight := signInfo.StartHeight + k.SignedBlocksWindow(ctx)
 	if height > minHeight && signInfo.SignedBlocksCounter < k.MinSignedPerWindow(ctx) {
-		validator := k.validatorSet.ValidatorByConsAddr(ctx, address)
+		validator := k.validatorSet.ValidatorByConsAddr(ctx, consAddr)
 		if validator != nil && !validator.GetJailed() {
 			// Downtime confirmed: slash and jail the validator
 			logger.Info(fmt.Sprintf("Validator %s past min height of %d and below signed blocks threshold of %d",
 				pubkey.Address(), minHeight, k.MinSignedPerWindow(ctx)))
-			k.validatorSet.Slash(ctx, pubkey, height, power, k.SlashFractionDowntime(ctx))
-			k.validatorSet.Jail(ctx, pubkey)
+			k.validatorSet.Slash(ctx, consAddr, height, power, k.SlashFractionDowntime(ctx))
+			k.validatorSet.Jail(ctx, consAddr)
 			signInfo.JailedUntil = ctx.BlockHeader().Time.Add(k.DowntimeUnbondDuration(ctx))
 		} else {
 			// Validator was (a) not found or (b) already jailed, don't slash
@@ -134,7 +134,7 @@ func (k Keeper) handleValidatorSignature(ctx sdk.Context, addr crypto.Address, p
 	}
 
 	// Set the updated signing info
-	k.setValidatorSigningInfo(ctx, address, signInfo)
+	k.setValidatorSigningInfo(ctx, consAddr, signInfo)
 }
 
 // AddValidators adds the validators to the keepers validator addr to pubkey mapping.

x/stake/handler.go

@@ -68,7 +68,7 @@ func handleMsgCreateValidator(ctx sdk.Context, msg types.MsgCreateValidator, k k
 	if found {
 		return ErrValidatorOwnerExists(k.Codespace()).Result()
 	}
-	_, found = k.GetValidatorByConsAddr(ctx, sdk.ConsAddress(msg.PubKey.Address()))
+	_, found = k.GetValidatorByConsPubKey(ctx, msg.PubKey)
 	if found {
 		return ErrValidatorPubKeyExists(k.Codespace()).Result()
 	}

x/stake/keeper/sdk_types.go

@@ -5,6 +5,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/stake/types"
+	"github.com/tendermint/tendermint/crypto"
 )
 
 // Implements ValidatorSet
@@ -66,6 +67,15 @@ func (k Keeper) ValidatorByConsAddr(ctx sdk.Context, addr sdk.ConsAddress) sdk.V
 	return val
 }
 
+// get the sdk.validator for a particular pubkey
+func (k Keeper) ValidatorByConsPubKey(ctx sdk.Context, consPubKey crypto.PubKey) sdk.Validator {
+	val, found := k.GetValidatorByConsPubKey(ctx, consPubKey)
+	if !found {
+		return nil
+	}
+	return val
+}
+
 // total power from the bond
 func (k Keeper) TotalPower(ctx sdk.Context) sdk.Dec {
 	pool := k.GetPool(ctx)

x/stake/keeper/slash.go

@@ -5,7 +5,6 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	types "github.com/cosmos/cosmos-sdk/x/stake/types"
-	"github.com/tendermint/tendermint/crypto"
 )
 
 // Slash a validator for an infraction committed at a known height
@@ -24,7 +23,7 @@ import (
 //    not at a height in the future
 //
 // nolint: gocyclo
-func (k Keeper) Slash(ctx sdk.Context, pubkey crypto.PubKey, infractionHeight int64, power int64, slashFactor sdk.Dec) {
+func (k Keeper) Slash(ctx sdk.Context, consAddr sdk.ConsAddress, infractionHeight int64, power int64, slashFactor sdk.Dec) {
 	logger := ctx.Logger().With("module", "x/stake")
 
 	if slashFactor.LT(sdk.ZeroDec()) {
@@ -36,15 +35,15 @@ func (k Keeper) Slash(ctx sdk.Context, pubkey crypto.PubKey, infractionHeight in
 	// ref https://github.com/cosmos/cosmos-sdk/issues/1348
 	// ref https://github.com/cosmos/cosmos-sdk/issues/1471
 
-	validator, found := k.GetValidatorByConsAddr(ctx, sdk.ConsAddress(pubkey.Address()))
+	validator, found := k.GetValidatorByConsAddr(ctx, consAddr)
 	if !found {
 		// If not found, the validator must have been overslashed and removed - so we don't need to do anything
 		// NOTE:  Correctness dependent on invariant that unbonding delegations / redelegations must also have been completely
 		//        slashed in this case - which we don't explicitly check, but should be true.
 		// Log the slash attempt for future reference (maybe we should tag it too)
 		logger.Error(fmt.Sprintf(
 			"WARNING: Ignored attempt to slash a nonexistent validator with address %s, we recommend you investigate immediately",
-			pubkey.Address()))
+			consAddr))
 		return
 	}
 
@@ -125,36 +124,28 @@ func (k Keeper) Slash(ctx sdk.Context, pubkey crypto.PubKey, infractionHeight in
 }
 
 // jail a validator
-func (k Keeper) Jail(ctx sdk.Context, pubkey crypto.PubKey) {
-	k.setJailed(ctx, pubkey, true)
-	validatorAddr, err := sdk.ValAddressFromHex(pubkey.Address().String())
-	if err != nil {
-		panic(err.Error())
-	}
+func (k Keeper) Jail(ctx sdk.Context, consAddr sdk.ConsAddress) {
+	k.setJailed(ctx, consAddr, true)
 	logger := ctx.Logger().With("module", "x/stake")
-	logger.Info(fmt.Sprintf("validator %s jailed", validatorAddr))
+	logger.Info(fmt.Sprintf("validator %s jailed", consAddr))
 	// TODO Return event(s), blocked on https://github.com/tendermint/tendermint/pull/1803
 	return
 }
 
 // unjail a validator
-func (k Keeper) Unjail(ctx sdk.Context, pubkey crypto.PubKey) {
-	k.setJailed(ctx, pubkey, false)
-	validatorAddr, err := sdk.ValAddressFromHex(pubkey.Address().String())
-	if err != nil {
-		panic(err.Error())
-	}
+func (k Keeper) Unjail(ctx sdk.Context, consAddr sdk.ConsAddress) {
+	k.setJailed(ctx, consAddr, false)
 	logger := ctx.Logger().With("module", "x/stake")
-	logger.Info(fmt.Sprintf("validator %s unjailed", validatorAddr))
+	logger.Info(fmt.Sprintf("validator %s unjailed", consAddr))
 	// TODO Return event(s), blocked on https://github.com/tendermint/tendermint/pull/1803
 	return
 }
 
 // set the jailed flag on a validator
-func (k Keeper) setJailed(ctx sdk.Context, pubkey crypto.PubKey, isJailed bool) {
-	validator, found := k.GetValidatorByConsAddr(ctx, sdk.ConsAddress(pubkey.Address()))
+func (k Keeper) setJailed(ctx sdk.Context, consAddr sdk.ConsAddress, isJailed bool) {
+	validator, found := k.GetValidatorByConsAddr(ctx, sdk.ConsAddress(consAddr))
 	if !found {
-		panic(fmt.Errorf("validator with pubkey %s not found, cannot set jailed to %v", pubkey, isJailed))
+		panic(fmt.Errorf("validator with consensus-Address %s not found, cannot set jailed to %v", consAddr, isJailed))
 	}
 	validator.Jailed = isJailed
 	k.UpdateValidator(ctx, validator) // update validator, possibly unbonding or bonding it