From e5da7f4f610ad8d4ad305a5c5b0ec597f21a1e0e Mon Sep 17 00:00:00 2001 From: Alessio Treglia Date: Wed, 22 Aug 2018 15:27:17 +0100 Subject: [PATCH] Rename revoke/unrevoke to jail/unjail Closes: #1305 --- cmd/gaia/app/sim_test.go | 2 +- cmd/gaia/cmd/gaiacli/main.go | 2 +- examples/basecoin/cmd/basecli/main.go | 2 +- examples/democoin/mock/validator.go | 6 +++--- types/stake.go | 6 +++--- x/gov/tally_test.go | 4 ++-- x/slashing/app_test.go | 4 ++-- x/slashing/client/cli/tx.go | 10 ++++----- x/slashing/client/rest/tx.go | 14 ++++++------- x/slashing/errors.go | 12 +++++------ x/slashing/handler.go | 22 ++++++++++---------- x/slashing/handler_test.go | 8 +++---- x/slashing/keeper.go | 14 ++++++------- x/slashing/keeper_test.go | 30 +++++++++++++-------------- x/slashing/msg.go | 18 ++++++++-------- x/slashing/msg_test.go | 2 +- x/slashing/simulation/msgs.go | 10 ++++----- x/slashing/tick_test.go | 2 +- x/slashing/wire.go | 2 +- x/stake/handler.go | 4 ++-- x/stake/handler_test.go | 10 ++++----- x/stake/keeper/delegation.go | 6 +++--- x/stake/keeper/key.go | 2 +- x/stake/keeper/slash.go | 24 ++++++++++----------- x/stake/keeper/slash_test.go | 12 +++++------ x/stake/keeper/validator.go | 14 ++++++------- x/stake/stake.go | 2 +- x/stake/types/errors.go | 2 +- x/stake/types/validator.go | 18 ++++++++-------- 29 files changed, 132 insertions(+), 132 deletions(-) diff --git a/cmd/gaia/app/sim_test.go b/cmd/gaia/app/sim_test.go index 051508e1a926..5fa75a93135a 100644 --- a/cmd/gaia/app/sim_test.go +++ b/cmd/gaia/app/sim_test.go @@ -98,7 +98,7 @@ func testAndRunTxs(app *GaiaApp) []simulation.TestAndRunTx { stakesim.SimulateMsgCompleteUnbonding(app.stakeKeeper), stakesim.SimulateMsgBeginRedelegate(app.accountMapper, app.stakeKeeper), stakesim.SimulateMsgCompleteRedelegate(app.stakeKeeper), - slashingsim.SimulateMsgUnrevoke(app.slashingKeeper), + slashingsim.SimulateMsgUnjail(app.slashingKeeper), } } diff --git a/cmd/gaia/cmd/gaiacli/main.go b/cmd/gaia/cmd/gaiacli/main.go index 25c670bdd6c6..df0fd3c1138e 100644 --- a/cmd/gaia/cmd/gaiacli/main.go +++ b/cmd/gaia/cmd/gaiacli/main.go @@ -95,7 +95,7 @@ func main() { stakecmd.GetCmdDelegate(cdc), stakecmd.GetCmdUnbond("stake", cdc), stakecmd.GetCmdRedelegate("stake", cdc), - slashingcmd.GetCmdUnrevoke(cdc), + slashingcmd.GetCmdUnjail(cdc), )...) rootCmd.AddCommand( stakeCmd, diff --git a/examples/basecoin/cmd/basecli/main.go b/examples/basecoin/cmd/basecli/main.go index 15bfd8035b32..23183c87a4d3 100644 --- a/examples/basecoin/cmd/basecli/main.go +++ b/examples/basecoin/cmd/basecli/main.go @@ -72,7 +72,7 @@ func main() { stakecmd.GetCmdDelegate(cdc), stakecmd.GetCmdUnbond("stake", cdc), stakecmd.GetCmdRedelegate("stake", cdc), - slashingcmd.GetCmdUnrevoke(cdc), + slashingcmd.GetCmdUnjail(cdc), )...) // add proxy, version and key info diff --git a/examples/democoin/mock/validator.go b/examples/democoin/mock/validator.go index f76f14803e96..bb936097ccb4 100644 --- a/examples/democoin/mock/validator.go +++ b/examples/democoin/mock/validator.go @@ -44,7 +44,7 @@ func (v Validator) GetDelegatorShares() sdk.Dec { } // Implements sdk.Validator -func (v Validator) GetRevoked() bool { +func (v Validator) GetJailed() bool { return false } @@ -127,11 +127,11 @@ func (vs *ValidatorSet) Slash(ctx sdk.Context, pubkey crypto.PubKey, height int6 } // Implements sdk.ValidatorSet -func (vs *ValidatorSet) Revoke(ctx sdk.Context, pubkey crypto.PubKey) { +func (vs *ValidatorSet) Jail(ctx sdk.Context, pubkey crypto.PubKey) { panic("not implemented") } // Implements sdk.ValidatorSet -func (vs *ValidatorSet) Unrevoke(ctx sdk.Context, pubkey crypto.PubKey) { +func (vs *ValidatorSet) Unjail(ctx sdk.Context, pubkey crypto.PubKey) { panic("not implemented") } diff --git a/types/stake.go b/types/stake.go index 69efed2c99ad..d872277256df 100644 --- a/types/stake.go +++ b/types/stake.go @@ -37,7 +37,7 @@ func (b BondStatus) Equal(b2 BondStatus) bool { // validator for a delegated proof of stake system type Validator interface { - GetRevoked() bool // whether the validator is revoked + GetJailed() bool // whether the validator is jailed GetMoniker() string // moniker of the validator GetStatus() BondStatus // status of the validator GetOperator() AccAddress // owner AccAddress to receive/return validators coins @@ -73,8 +73,8 @@ type ValidatorSet interface { // slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction Slash(Context, crypto.PubKey, int64, int64, Dec) - Revoke(Context, crypto.PubKey) // revoke a validator - Unrevoke(Context, crypto.PubKey) // unrevoke a validator + Jail(Context, crypto.PubKey) // jail a validator + Unjail(Context, crypto.PubKey) // unjail a validator } //_______________________________________________________________________________ diff --git a/x/gov/tally_test.go b/x/gov/tally_test.go index 730885266f84..a3e6b8558623 100644 --- a/x/gov/tally_test.go +++ b/x/gov/tally_test.go @@ -354,7 +354,7 @@ func TestTallyDelgatorMultipleInherit(t *testing.T) { require.False(t, tallyResults.Equals(EmptyTallyResult())) } -func TestTallyRevokedValidator(t *testing.T) { +func TestTallyUnjailedValidator(t *testing.T) { mapp, keeper, sk, addrs, _, _ := getMockApp(t, 10) mapp.BeginBlock(abci.RequestBeginBlock{}) ctx := mapp.BaseApp.NewContext(false, abci.Header{}) @@ -368,7 +368,7 @@ func TestTallyRevokedValidator(t *testing.T) { val2, found := sk.GetValidator(ctx, addrs[1]) require.True(t, found) - sk.Revoke(ctx, val2.PubKey) + sk.Unjail(ctx, val2.PubKey) proposal := keeper.NewTextProposal(ctx, "Test", "description", ProposalTypeText) proposalID := proposal.GetProposalID() diff --git a/x/slashing/app_test.go b/x/slashing/app_test.go index e018c43e8b8e..a5f0a8ba8f0b 100644 --- a/x/slashing/app_test.go +++ b/x/slashing/app_test.go @@ -110,12 +110,12 @@ func TestSlashingMsgs(t *testing.T) { require.Equal(t, addr1, validator.Operator) require.Equal(t, sdk.Bonded, validator.Status) require.True(sdk.DecEq(t, sdk.NewDec(10), validator.BondedTokens())) - unrevokeMsg := MsgUnrevoke{ValidatorAddr: sdk.AccAddress(validator.PubKey.Address())} + unrevokeMsg := MsgUnjail{ValidatorAddr: sdk.AccAddress(validator.PubKey.Address())} // no signing info yet checkValidatorSigningInfo(t, mapp, keeper, sdk.ValAddress(addr1), false) // unrevoke should fail with unknown validator res := mock.SignCheckDeliver(t, mapp.BaseApp, []sdk.Msg{unrevokeMsg}, []int64{0}, []int64{1}, false, priv1) - require.Equal(t, sdk.ToABCICode(DefaultCodespace, CodeValidatorNotRevoked), res.Code) + require.Equal(t, sdk.ToABCICode(DefaultCodespace, CodeValidatorNotJailed), res.Code) } diff --git a/x/slashing/client/cli/tx.go b/x/slashing/client/cli/tx.go index 5085f5aacce8..5831ef310035 100644 --- a/x/slashing/client/cli/tx.go +++ b/x/slashing/client/cli/tx.go @@ -14,12 +14,12 @@ import ( "github.com/spf13/cobra" ) -// GetCmdUnrevoke implements the create unrevoke validator command. -func GetCmdUnrevoke(cdc *wire.Codec) *cobra.Command { +// GetCmdUnjail implements the create unjail validator command. +func GetCmdUnjail(cdc *wire.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "unrevoke", + Use: "unjail", Args: cobra.ExactArgs(0), - Short: "unrevoke validator previously revoked for downtime", + Short: "unjail validator previously jailed for downtime", RunE: func(cmd *cobra.Command, args []string) error { txCtx := authctx.NewTxContextFromCLI().WithCodec(cdc) cliCtx := context.NewCLIContext(). @@ -32,7 +32,7 @@ func GetCmdUnrevoke(cdc *wire.Codec) *cobra.Command { return err } - msg := slashing.NewMsgUnrevoke(validatorAddr) + msg := slashing.NewMsgUnjail(validatorAddr) return utils.SendTx(txCtx, cliCtx, []sdk.Msg{msg}) }, diff --git a/x/slashing/client/rest/tx.go b/x/slashing/client/rest/tx.go index 2ecec51ea851..6e45230b01b8 100644 --- a/x/slashing/client/rest/tx.go +++ b/x/slashing/client/rest/tx.go @@ -19,13 +19,13 @@ import ( func registerTxRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *wire.Codec, kb keys.Keybase) { r.HandleFunc( - "/slashing/unrevoke", - unrevokeRequestHandlerFn(cdc, kb, cliCtx), + "/slashing/unjail", + unjailRequestHandlerFn(cdc, kb, cliCtx), ).Methods("POST") } -// Unrevoke TX body -type UnrevokeBody struct { +// Unjail TX body +type UnjailBody struct { LocalAccountName string `json:"name"` Password string `json:"password"` ChainID string `json:"chain_id"` @@ -35,9 +35,9 @@ type UnrevokeBody struct { ValidatorAddr string `json:"validator_addr"` } -func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc { +func unjailRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx context.CLIContext) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { - var m UnrevokeBody + var m UnjailBody body, err := ioutil.ReadAll(r.Body) if err != nil { w.WriteHeader(http.StatusBadRequest) @@ -79,7 +79,7 @@ func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, cliCtx context.C Gas: m.Gas, } - msg := slashing.NewMsgUnrevoke(validatorAddr) + msg := slashing.NewMsgUnjail(validatorAddr) txBytes, err := txCtx.BuildAndSign(m.LocalAccountName, m.Password, []sdk.Msg{msg}) if err != nil { diff --git a/x/slashing/errors.go b/x/slashing/errors.go index 3139c1662f85..58614b506e0b 100644 --- a/x/slashing/errors.go +++ b/x/slashing/errors.go @@ -12,9 +12,9 @@ const ( // Default slashing codespace DefaultCodespace sdk.CodespaceType = 10 - CodeInvalidValidator CodeType = 101 - CodeValidatorJailed CodeType = 102 - CodeValidatorNotRevoked CodeType = 103 + CodeInvalidValidator CodeType = 101 + CodeValidatorJailed CodeType = 102 + CodeValidatorNotJailed CodeType = 103 ) func ErrNoValidatorForAddress(codespace sdk.CodespaceType) sdk.Error { @@ -24,8 +24,8 @@ func ErrBadValidatorAddr(codespace sdk.CodespaceType) sdk.Error { return sdk.NewError(codespace, CodeInvalidValidator, "validator does not exist for that address") } func ErrValidatorJailed(codespace sdk.CodespaceType) sdk.Error { - return sdk.NewError(codespace, CodeValidatorJailed, "validator jailed, cannot yet be unrevoked") + return sdk.NewError(codespace, CodeValidatorJailed, "validator jailed, cannot yet be unjailed") } -func ErrValidatorNotRevoked(codespace sdk.CodespaceType) sdk.Error { - return sdk.NewError(codespace, CodeValidatorNotRevoked, "validator not revoked, cannot be unrevoked") +func ErrValidatorNotJailed(codespace sdk.CodespaceType) sdk.Error { + return sdk.NewError(codespace, CodeValidatorNotJailed, "validator not jailed, cannot be unjailed") } diff --git a/x/slashing/handler.go b/x/slashing/handler.go index 0cb64ab40904..bbb1804b7ea1 100644 --- a/x/slashing/handler.go +++ b/x/slashing/handler.go @@ -8,17 +8,17 @@ func NewHandler(k Keeper) sdk.Handler { return func(ctx sdk.Context, msg sdk.Msg) sdk.Result { // NOTE msg already has validate basic run switch msg := msg.(type) { - case MsgUnrevoke: - return handleMsgUnrevoke(ctx, msg, k) + case MsgUnjail: + return handleMsgUnjail(ctx, msg, k) default: return sdk.ErrTxDecode("invalid message parse in staking module").Result() } } } -// Validators must submit a transaction to unrevoke itself after -// having been revoked (and thus unbonded) for downtime -func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result { +// Validators must submit a transaction to unjail itself after +// having been unjailed (and thus unbonded) for downtime +func handleMsgUnjail(ctx sdk.Context, msg MsgUnjail, k Keeper) sdk.Result { // Validator must exist validator := k.validatorSet.Validator(ctx, msg.ValidatorAddr) @@ -26,8 +26,8 @@ func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result { return ErrNoValidatorForAddress(k.codespace).Result() } - if !validator.GetRevoked() { - return ErrValidatorNotRevoked(k.codespace).Result() + if !validator.GetJailed() { + return ErrValidatorNotJailed(k.codespace).Result() } addr := sdk.ValAddress(validator.GetPubKey().Address()) @@ -38,17 +38,17 @@ func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result { return ErrNoValidatorForAddress(k.codespace).Result() } - // Cannot be unrevoked until out of jail + // Cannot be unjailed until out of jail if ctx.BlockHeader().Time.Before(info.JailedUntil) { return ErrValidatorJailed(k.codespace).Result() } - // Update the starting height (so the validator can't be immediately revoked again) + // Update the starting height (so the validator can't be immediately unjailed again) info.StartHeight = ctx.BlockHeight() k.setValidatorSigningInfo(ctx, addr, info) - // Unrevoke the validator - k.validatorSet.Unrevoke(ctx, validator.GetPubKey()) + // Unjail the validator + k.validatorSet.Unjail(ctx, validator.GetPubKey()) tags := sdk.NewTags("action", []byte("unrevoke"), "validator", []byte(msg.ValidatorAddr.String())) diff --git a/x/slashing/handler_test.go b/x/slashing/handler_test.go index 41cb5d19968c..233395921c5c 100644 --- a/x/slashing/handler_test.go +++ b/x/slashing/handler_test.go @@ -22,8 +22,8 @@ func TestCannotUnrevokeUnlessRevoked(t *testing.T) { require.Equal(t, ck.GetCoins(ctx, addr), sdk.Coins{{sk.GetParams(ctx).BondDenom, initCoins.Sub(amt)}}) require.True(t, sdk.NewDecFromInt(amt).Equal(sk.Validator(ctx, addr).GetPower())) - // assert non-revoked validator can't be unrevoked - got = slh(ctx, NewMsgUnrevoke(addr)) - require.False(t, got.IsOK(), "allowed unrevoke of non-revoked validator") - require.Equal(t, sdk.ToABCICode(DefaultCodespace, CodeValidatorNotRevoked), got.Code) + // assert non-jailed validator can't be unjailed + got = slh(ctx, NewMsgUnjail(addr)) + require.False(t, got.IsOK(), "allowed unrevoke of non-jailed validator") + require.Equal(t, sdk.ToABCICode(DefaultCodespace, CodeValidatorNotJailed), got.Code) } diff --git a/x/slashing/keeper.go b/x/slashing/keeper.go index 373423b2d719..8253f3713caf 100644 --- a/x/slashing/keeper.go +++ b/x/slashing/keeper.go @@ -59,8 +59,8 @@ func (k Keeper) handleDoubleSign(ctx sdk.Context, addr crypto.Address, infractio // Slash validator k.validatorSet.Slash(ctx, pubkey, infractionHeight, power, k.SlashFractionDoubleSign(ctx)) - // Revoke validator - k.validatorSet.Revoke(ctx, pubkey) + // Jail validator + k.validatorSet.Jail(ctx, pubkey) // Jail validator signInfo, found := k.getValidatorSigningInfo(ctx, address) @@ -113,16 +113,16 @@ 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.ValidatorByPubKey(ctx, pubkey) - if validator != nil && !validator.GetRevoked() { - // Downtime confirmed, slash, revoke, and jail the validator + if validator != nil && !validator.GetJailed() { + // Downtime confirmed, slash, jail, 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.Revoke(ctx, pubkey) + k.validatorSet.Jail(ctx, pubkey) signInfo.JailedUntil = ctx.BlockHeader().Time.Add(k.DowntimeUnbondDuration(ctx)) } else { - // Validator was (a) not found or (b) already revoked, don't slash - logger.Info(fmt.Sprintf("Validator %s would have been slashed for downtime, but was either not found in store or already revoked", + // Validator was (a) not found or (b) already jailed, don't slash + logger.Info(fmt.Sprintf("Validator %s would have been slashed for downtime, but was either not found in store or already jailed", pubkey.Address())) } } diff --git a/x/slashing/keeper_test.go b/x/slashing/keeper_test.go index 5ebfec21ad77..baf3b327ec46 100644 --- a/x/slashing/keeper_test.go +++ b/x/slashing/keeper_test.go @@ -39,10 +39,10 @@ func TestHandleDoubleSign(t *testing.T) { // double sign less than max age keeper.handleDoubleSign(ctx, val.Address(), 0, time.Unix(0, 0), amtInt) - // should be revoked - require.True(t, sk.Validator(ctx, addr).GetRevoked()) - // unrevoke to measure power - sk.Unrevoke(ctx, val) + // should be jailed + require.True(t, sk.Validator(ctx, addr).GetJailed()) + // unjail to measure power + sk.Unjail(ctx, val) // power should be reduced require.Equal(t, sdk.NewDecFromInt(amt).Mul(sdk.NewDec(19).Quo(sdk.NewDec(20))), sk.Validator(ctx, addr).GetPower()) ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.MaxEvidenceAge(ctx))}) @@ -112,17 +112,17 @@ func TestHandleAbsentValidator(t *testing.T) { require.Equal(t, int64(0), info.StartHeight) require.Equal(t, keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)-1, info.SignedBlocksCounter) - // validator should have been revoked + // validator should have been jailed validator, _ = sk.GetValidatorByPubKey(ctx, val) require.Equal(t, sdk.Unbonded, validator.GetStatus()) - // unrevocation should fail prior to jail expiration - got = slh(ctx, NewMsgUnrevoke(addr)) + // unjail should fail prior to jail expiration + got = slh(ctx, NewMsgUnjail(addr)) require.False(t, got.IsOK()) - // unrevocation should succeed after jail expiration + // unjail should succeed after jail expiration ctx = ctx.WithBlockHeader(abci.Header{Time: time.Unix(1, 0).Add(keeper.DowntimeUnbondDuration(ctx))}) - got = slh(ctx, NewMsgUnrevoke(addr)) + got = slh(ctx, NewMsgUnjail(addr)) require.True(t, got.IsOK()) // validator should be rebonded now @@ -140,7 +140,7 @@ func TestHandleAbsentValidator(t *testing.T) { require.Equal(t, height, info.StartHeight) require.Equal(t, keeper.SignedBlocksWindow(ctx)-keeper.MinSignedPerWindow(ctx)-1, info.SignedBlocksCounter) - // validator should not be immediately revoked again + // validator should not be immediately jailed again height++ ctx = ctx.WithBlockHeight(height) keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false) @@ -154,7 +154,7 @@ func TestHandleAbsentValidator(t *testing.T) { keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false) } - // validator should be revoked again after 500 unsigned blocks + // validator should be jailed again after 500 unsigned blocks nextHeight = height + keeper.MinSignedPerWindow(ctx) + 1 for ; height <= nextHeight; height++ { ctx = ctx.WithBlockHeight(height) @@ -166,7 +166,7 @@ func TestHandleAbsentValidator(t *testing.T) { // Test a new validator entering the validator set // Ensure that SigningInfo.StartHeight is set correctly -// and that they are not immediately revoked +// and that they are not immediately jailed func TestHandleNewValidator(t *testing.T) { // initial setup ctx, ck, sk, _, keeper := createTestInput(t) @@ -194,14 +194,14 @@ func TestHandleNewValidator(t *testing.T) { require.Equal(t, int64(1), info.SignedBlocksCounter) require.Equal(t, time.Unix(0, 0).UTC(), info.JailedUntil) - // validator should be bonded still, should not have been revoked or slashed + // validator should be bonded still, should not have been jailed or slashed validator, _ := sk.GetValidatorByPubKey(ctx, val) require.Equal(t, sdk.Bonded, validator.GetStatus()) pool := sk.GetPool(ctx) require.Equal(t, int64(100), pool.BondedTokens.RoundInt64()) } -// Test a revoked validator being "down" twice +// Test a jailed validator being "down" twice // Ensure that they're only slashed once func TestHandleAlreadyRevoked(t *testing.T) { @@ -228,7 +228,7 @@ func TestHandleAlreadyRevoked(t *testing.T) { keeper.handleValidatorSignature(ctx, val.Address(), amtInt, false) } - // validator should have been revoked and slashed + // validator should have been jailed and slashed validator, _ := sk.GetValidatorByPubKey(ctx, val) require.Equal(t, sdk.Unbonded, validator.GetStatus()) diff --git a/x/slashing/msg.go b/x/slashing/msg.go index 4b1483dce905..4324b257f9fd 100644 --- a/x/slashing/msg.go +++ b/x/slashing/msg.go @@ -11,25 +11,25 @@ var cdc = wire.NewCodec() const MsgType = "slashing" // verify interface at compile time -var _ sdk.Msg = &MsgUnrevoke{} +var _ sdk.Msg = &MsgUnjail{} -// MsgUnrevoke - struct for unrevoking revoked validator -type MsgUnrevoke struct { +// MsgUnjail - struct for unrevoking jailed validator +type MsgUnjail struct { ValidatorAddr sdk.AccAddress `json:"address"` // address of the validator owner } -func NewMsgUnrevoke(validatorAddr sdk.AccAddress) MsgUnrevoke { - return MsgUnrevoke{ +func NewMsgUnjail(validatorAddr sdk.AccAddress) MsgUnjail { + return MsgUnjail{ ValidatorAddr: validatorAddr, } } //nolint -func (msg MsgUnrevoke) Type() string { return MsgType } -func (msg MsgUnrevoke) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.ValidatorAddr} } +func (msg MsgUnjail) Type() string { return MsgType } +func (msg MsgUnjail) GetSigners() []sdk.AccAddress { return []sdk.AccAddress{msg.ValidatorAddr} } // get the bytes for the message signer to sign on -func (msg MsgUnrevoke) GetSignBytes() []byte { +func (msg MsgUnjail) GetSignBytes() []byte { b, err := cdc.MarshalJSON(msg) if err != nil { panic(err) @@ -38,7 +38,7 @@ func (msg MsgUnrevoke) GetSignBytes() []byte { } // quick validity check -func (msg MsgUnrevoke) ValidateBasic() sdk.Error { +func (msg MsgUnjail) ValidateBasic() sdk.Error { if msg.ValidatorAddr == nil { return ErrBadValidatorAddr(DefaultCodespace) } diff --git a/x/slashing/msg_test.go b/x/slashing/msg_test.go index 287eb6c5c5fe..a0cacda1d1f5 100644 --- a/x/slashing/msg_test.go +++ b/x/slashing/msg_test.go @@ -10,7 +10,7 @@ import ( func TestMsgUnrevokeGetSignBytes(t *testing.T) { addr := sdk.AccAddress("abcd") - msg := NewMsgUnrevoke(addr) + msg := NewMsgUnjail(addr) bytes := msg.GetSignBytes() require.Equal(t, string(bytes), `{"address":"cosmosaccaddr1v93xxeqhyqz5v"}`) } diff --git a/x/slashing/simulation/msgs.go b/x/slashing/simulation/msgs.go index b6a093674b6b..8ef24493be7d 100644 --- a/x/slashing/simulation/msgs.go +++ b/x/slashing/simulation/msgs.go @@ -15,20 +15,20 @@ import ( "github.com/cosmos/cosmos-sdk/x/slashing" ) -// SimulateMsgUnrevoke -func SimulateMsgUnrevoke(k slashing.Keeper) simulation.TestAndRunTx { +// SimulateMsgUnjail +func SimulateMsgUnjail(k slashing.Keeper) simulation.TestAndRunTx { return func(t *testing.T, r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, keys []crypto.PrivKey, log string, event func(string)) (action string, err sdk.Error) { key := simulation.RandomKey(r, keys) address := sdk.AccAddress(key.PubKey().Address()) - msg := slashing.NewMsgUnrevoke(address) + msg := slashing.NewMsgUnjail(address) require.Nil(t, msg.ValidateBasic(), "expected msg to pass ValidateBasic: %s", msg.GetSignBytes()) ctx, write := ctx.CacheContext() result := slashing.NewHandler(k)(ctx, msg) if result.IsOK() { write() } - event(fmt.Sprintf("slashing/MsgUnrevoke/%v", result.IsOK())) - action = fmt.Sprintf("TestMsgUnrevoke: ok %v, msg %s", result.IsOK(), msg.GetSignBytes()) + event(fmt.Sprintf("slashing/MsgUnjail/%v", result.IsOK())) + action = fmt.Sprintf("TestMsgUnjail: ok %v, msg %s", result.IsOK(), msg.GetSignBytes()) return action, nil } } diff --git a/x/slashing/tick_test.go b/x/slashing/tick_test.go index b230f9c94004..78d269549462 100644 --- a/x/slashing/tick_test.go +++ b/x/slashing/tick_test.go @@ -77,7 +77,7 @@ func TestBeginBlocker(t *testing.T) { BeginBlocker(ctx, req, keeper) } - // validator should be revoked + // validator should be jailed validator, found := sk.GetValidatorByPubKey(ctx, pk) require.True(t, found) require.Equal(t, sdk.Unbonded, validator.GetStatus()) diff --git a/x/slashing/wire.go b/x/slashing/wire.go index 465a06587e2d..208acda06f7f 100644 --- a/x/slashing/wire.go +++ b/x/slashing/wire.go @@ -6,7 +6,7 @@ import ( // Register concrete types on wire codec func RegisterWire(cdc *wire.Codec) { - cdc.RegisterConcrete(MsgUnrevoke{}, "cosmos-sdk/MsgUnrevoke", nil) + cdc.RegisterConcrete(MsgUnjail{}, "cosmos-sdk/MsgUnjail", nil) } var cdcEmpty = wire.NewCodec() diff --git a/x/stake/handler.go b/x/stake/handler.go index 8f7475de9b79..9cf7a5f454cd 100644 --- a/x/stake/handler.go +++ b/x/stake/handler.go @@ -136,8 +136,8 @@ func handleMsgDelegate(ctx sdk.Context, msg types.MsgDelegate, k keeper.Keeper) if msg.Delegation.Denom != k.GetParams(ctx).BondDenom { return ErrBadDenom(k.Codespace()).Result() } - if validator.Revoked == true { - return ErrValidatorRevoked(k.Codespace()).Result() + if validator.Jailed == true { + return ErrValidatorJailed(k.Codespace()).Result() } _, err := k.Delegate(ctx, msg.DelegatorAddr, msg.Delegation, validator, true) if err != nil { diff --git a/x/stake/handler_test.go b/x/stake/handler_test.go index 9ff72090e114..325f1613d668 100644 --- a/x/stake/handler_test.go +++ b/x/stake/handler_test.go @@ -80,9 +80,9 @@ func TestValidatorByPowerIndex(t *testing.T) { got = handleMsgCreateValidator(ctx, msgCreateValidator, keeper) require.True(t, got.IsOK(), "expected create-validator to be ok, got %v", got) - // slash and revoke the first validator + // slash and jail the first validator keeper.Slash(ctx, keep.PKs[0], 0, initBond, sdk.NewDecWithPrec(5, 1)) - keeper.Revoke(ctx, keep.PKs[0]) + keeper.Jail(ctx, keep.PKs[0]) validator, found = keeper.GetValidator(ctx, validatorAddr) require.True(t, found) require.Equal(t, sdk.Unbonded, validator.Status) // ensure is unbonded @@ -449,7 +449,7 @@ func TestMultipleMsgDelegate(t *testing.T) { } } -func TestRevokeValidator(t *testing.T) { +func TestJailValidator(t *testing.T) { ctx, _, keeper := keep.CreateTestInput(t, false, 1000) validatorAddr, delegatorAddr := keep.Addrs[0], keep.Addrs[1] _ = setInstantUnbondPeriod(keeper, ctx) @@ -476,9 +476,9 @@ func TestRevokeValidator(t *testing.T) { validator, found := keeper.GetValidator(ctx, validatorAddr) require.True(t, found) - require.True(t, validator.Revoked, "%v", validator) + require.True(t, validator.Jailed, "%v", validator) - // test that this address cannot yet be bonded too because is revoked + // test that this address cannot yet be bonded too because is jailed got = handleMsgDelegate(ctx, msgDelegate, keeper) require.False(t, got.IsOK(), "expected error, got %v", got) diff --git a/x/stake/keeper/delegation.go b/x/stake/keeper/delegation.go index 4256df4b5901..2bad79c20f31 100644 --- a/x/stake/keeper/delegation.go +++ b/x/stake/keeper/delegation.go @@ -283,9 +283,9 @@ func (k Keeper) unbond(ctx sdk.Context, delegatorAddr, validatorAddr sdk.AccAddr if delegation.Shares.IsZero() { // if the delegation is the operator of the validator then - // trigger a revoke validator - if bytes.Equal(delegation.DelegatorAddr, validator.Operator) && validator.Revoked == false { - validator.Revoked = true + // trigger a jail validator + if bytes.Equal(delegation.DelegatorAddr, validator.Operator) && validator.Jailed == false { + validator.Jailed = true } k.RemoveDelegation(ctx, delegation) } else { diff --git a/x/stake/keeper/key.go b/x/stake/keeper/key.go index 502ec2654419..a44281cc9d70 100644 --- a/x/stake/keeper/key.go +++ b/x/stake/keeper/key.go @@ -74,7 +74,7 @@ func getValidatorPowerRank(validator types.Validator, pool types.Pool) []byte { powerBytes := []byte(potentialPower.ToLeftPadded(maxDigitsForAccount)) // power big-endian (more powerful validators first) revokedBytes := make([]byte, 1) - if validator.Revoked { + if validator.Jailed { revokedBytes[0] = byte(0x00) } else { revokedBytes[0] = byte(0x01) diff --git a/x/stake/keeper/slash.go b/x/stake/keeper/slash.go index 471886c26b2e..72613ae5aecf 100644 --- a/x/stake/keeper/slash.go +++ b/x/stake/keeper/slash.go @@ -115,31 +115,31 @@ func (k Keeper) Slash(ctx sdk.Context, pubkey crypto.PubKey, infractionHeight in return } -// revoke a validator -func (k Keeper) Revoke(ctx sdk.Context, pubkey crypto.PubKey) { - k.setRevoked(ctx, pubkey, true) +// Jail a validator +func (k Keeper) Jail(ctx sdk.Context, pubkey crypto.PubKey) { + k.setJailed(ctx, pubkey, true) logger := ctx.Logger().With("module", "x/stake") - logger.Info(fmt.Sprintf("Validator %s revoked", pubkey.Address())) + logger.Info(fmt.Sprintf("Validator %s jailed", pubkey.Address())) // TODO Return event(s), blocked on https://github.com/tendermint/tendermint/pull/1803 return } -// unrevoke a validator -func (k Keeper) Unrevoke(ctx sdk.Context, pubkey crypto.PubKey) { - k.setRevoked(ctx, pubkey, false) +// unjail a validator +func (k Keeper) Unjail(ctx sdk.Context, pubkey crypto.PubKey) { + k.setJailed(ctx, pubkey, false) logger := ctx.Logger().With("module", "x/stake") - logger.Info(fmt.Sprintf("Validator %s unrevoked", pubkey.Address())) + logger.Info(fmt.Sprintf("Validator %s unjailed", pubkey.Address())) // TODO Return event(s), blocked on https://github.com/tendermint/tendermint/pull/1803 return } -// set the revoked flag on a validator -func (k Keeper) setRevoked(ctx sdk.Context, pubkey crypto.PubKey, revoked bool) { +// set the jailed flag on a validator +func (k Keeper) setJailed(ctx sdk.Context, pubkey crypto.PubKey, jailed bool) { validator, found := k.GetValidatorByPubKey(ctx, pubkey) if !found { - panic(fmt.Errorf("Validator with pubkey %s not found, cannot set revoked to %v", pubkey, revoked)) + panic(fmt.Errorf("Validator with pubkey %s not found, cannot set jailed to %v", pubkey, jailed)) } - validator.Revoked = revoked + validator.Jailed = jailed k.UpdateValidator(ctx, validator) // update validator, possibly unbonding or bonding it return } diff --git a/x/stake/keeper/slash_test.go b/x/stake/keeper/slash_test.go index 444858f290f5..42b229b1b485 100644 --- a/x/stake/keeper/slash_test.go +++ b/x/stake/keeper/slash_test.go @@ -34,7 +34,7 @@ func setupHelper(t *testing.T, amt int64) (sdk.Context, Keeper, types.Params) { return ctx, keeper, params } -// tests Revoke, Unrevoke +// tests Jail, Unjail func TestRevocation(t *testing.T) { // setup ctx, keeper, _ := setupHelper(t, 10) @@ -44,19 +44,19 @@ func TestRevocation(t *testing.T) { // initial state val, found := keeper.GetValidator(ctx, addr) require.True(t, found) - require.False(t, val.GetRevoked()) + require.False(t, val.GetJailed()) // test revoke - keeper.Revoke(ctx, pk) + keeper.Jail(ctx, pk) val, found = keeper.GetValidator(ctx, addr) require.True(t, found) - require.True(t, val.GetRevoked()) + require.True(t, val.GetJailed()) // test unrevoke - keeper.Unrevoke(ctx, pk) + keeper.Unjail(ctx, pk) val, found = keeper.GetValidator(ctx, addr) require.True(t, found) - require.False(t, val.GetRevoked()) + require.False(t, val.GetJailed()) } diff --git a/x/stake/keeper/validator.go b/x/stake/keeper/validator.go index c828cc38ef63..1c019db9359a 100644 --- a/x/stake/keeper/validator.go +++ b/x/stake/keeper/validator.go @@ -216,7 +216,7 @@ func (k Keeper) UpdateValidator(ctx sdk.Context, validator types.Validator) type // perform the following: // a) update Tendermint // b) check if the cliff validator needs to be updated - case powerIncreasing && !validator.Revoked && + case powerIncreasing && !validator.Jailed && (oldFound && oldValidator.Status == sdk.Bonded): bz := k.cdc.MustMarshalBinary(validator.ABCIValidator()) @@ -293,8 +293,8 @@ func (k Keeper) updateCliffValidator(ctx sdk.Context, affectedVal types.Validato panic(fmt.Sprintf("validator record not found for address: %v\n", ownerAddr)) } - if currVal.Status != sdk.Bonded || currVal.Revoked { - panic(fmt.Sprintf("unexpected revoked or unbonded validator for address: %s\n", ownerAddr)) + if currVal.Status != sdk.Bonded || currVal.Jailed { + panic(fmt.Sprintf("unexpected jailed or unbonded validator for address: %s\n", ownerAddr)) } newCliffVal = currVal @@ -320,7 +320,7 @@ func (k Keeper) updateCliffValidator(ctx sdk.Context, affectedVal types.Validato } func (k Keeper) updateForRevoking(ctx sdk.Context, oldFound bool, oldValidator, newValidator types.Validator) types.Validator { - if newValidator.Revoked && oldFound && oldValidator.Status == sdk.Bonded { + if newValidator.Jailed && oldFound && oldValidator.Status == sdk.Bonded { newValidator = k.unbondValidator(ctx, newValidator) // need to also clear the cliff validator spot because the revoke has @@ -417,7 +417,7 @@ func (k Keeper) UpdateBondedValidators( } // increment bondedValidatorsCount / get the validator to bond - if !validator.Revoked { + if !validator.Jailed { if validator.Status != sdk.Bonded { validatorToBond = validator if newValidatorBonded { @@ -529,11 +529,11 @@ func (k Keeper) UpdateBondedValidatorsFull(ctx sdk.Context) { validator = k.bondValidator(ctx, validator) } - if validator.Revoked { + if validator.Jailed { // we should no longer consider jailed validators as they are ranked // lower than any non-jailed/bonded validators if validator.Status == sdk.Bonded { - panic(fmt.Sprintf("revoked validator cannot be bonded for address: %s\n", ownerAddr)) + panic(fmt.Sprintf("jailed validator cannot be bonded for address: %s\n", ownerAddr)) } break diff --git a/x/stake/stake.go b/x/stake/stake.go index c5185433dc48..288b1ae1e703 100644 --- a/x/stake/stake.go +++ b/x/stake/stake.go @@ -94,7 +94,7 @@ var ( ErrNoValidatorFound = types.ErrNoValidatorFound ErrValidatorOwnerExists = types.ErrValidatorOwnerExists ErrValidatorPubKeyExists = types.ErrValidatorPubKeyExists - ErrValidatorRevoked = types.ErrValidatorRevoked + ErrValidatorJailed = types.ErrValidatorRevoked ErrBadRemoveValidator = types.ErrBadRemoveValidator ErrDescriptionLength = types.ErrDescriptionLength ErrCommissionNegative = types.ErrCommissionNegative diff --git a/x/stake/types/errors.go b/x/stake/types/errors.go index d44ed411c50c..0276d490ecc6 100644 --- a/x/stake/types/errors.go +++ b/x/stake/types/errors.go @@ -45,7 +45,7 @@ func ErrValidatorPubKeyExists(codespace sdk.CodespaceType) sdk.Error { } func ErrValidatorRevoked(codespace sdk.CodespaceType) sdk.Error { - return sdk.NewError(codespace, CodeInvalidValidator, "validator for this address is currently revoked") + return sdk.NewError(codespace, CodeInvalidValidator, "validator for this address is currently jailed") } func ErrBadRemoveValidator(codespace sdk.CodespaceType) sdk.Error { diff --git a/x/stake/types/validator.go b/x/stake/types/validator.go index 4b2cf46a638b..f8404b596363 100644 --- a/x/stake/types/validator.go +++ b/x/stake/types/validator.go @@ -22,7 +22,7 @@ import ( type Validator struct { Operator sdk.AccAddress `json:"operator"` // sender of BondTx - UnbondTx returns here PubKey crypto.PubKey `json:"pub_key"` // pubkey of validator - Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? + Jailed bool `json:"jailed"` // has the validator been jailed from bonded status? Status sdk.BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded) Tokens sdk.Dec `json:"tokens"` // delegated tokens (incl. self-delegation) @@ -47,7 +47,7 @@ func NewValidator(operator sdk.AccAddress, pubKey crypto.PubKey, description Des return Validator{ Operator: operator, PubKey: pubKey, - Revoked: false, + Jailed: false, Status: sdk.Unbonded, Tokens: sdk.ZeroDec(), DelegatorShares: sdk.ZeroDec(), @@ -66,7 +66,7 @@ func NewValidator(operator sdk.AccAddress, pubKey crypto.PubKey, description Des // what's kept in the store value type validatorValue struct { PubKey crypto.PubKey - Revoked bool + Jailed bool Status sdk.BondStatus Tokens sdk.Dec DelegatorShares sdk.Dec @@ -85,7 +85,7 @@ type validatorValue struct { func MustMarshalValidator(cdc *wire.Codec, validator Validator) []byte { val := validatorValue{ PubKey: validator.PubKey, - Revoked: validator.Revoked, + Jailed: validator.Jailed, Status: validator.Status, Tokens: validator.Tokens, DelegatorShares: validator.DelegatorShares, @@ -127,7 +127,7 @@ func UnmarshalValidator(cdc *wire.Codec, operatorAddr, value []byte) (validator return Validator{ Operator: operatorAddr, PubKey: storeValue.PubKey, - Revoked: storeValue.Revoked, + Jailed: storeValue.Jailed, Tokens: storeValue.Tokens, Status: storeValue.Status, DelegatorShares: storeValue.DelegatorShares, @@ -155,7 +155,7 @@ func (v Validator) HumanReadableString() (string, error) { resp := "Validator \n" resp += fmt.Sprintf("Operator: %s\n", v.Operator) resp += fmt.Sprintf("Validator: %s\n", bechVal) - resp += fmt.Sprintf("Revoked: %v\n", v.Revoked) + resp += fmt.Sprintf("Jailed: %v\n", v.Jailed) resp += fmt.Sprintf("Status: %s\n", sdk.BondStatusToString(v.Status)) resp += fmt.Sprintf("Tokens: %s\n", v.Tokens.String()) resp += fmt.Sprintf("Delegator Shares: %s\n", v.DelegatorShares.String()) @@ -177,7 +177,7 @@ func (v Validator) HumanReadableString() (string, error) { type BechValidator struct { Operator sdk.AccAddress `json:"operator"` // in bech32 PubKey string `json:"pub_key"` // in bech32 - Revoked bool `json:"revoked"` // has the validator been revoked from bonded status? + Jailed bool `json:"jailed"` // has the validator been jailed from bonded status? Status sdk.BondStatus `json:"status"` // validator status (bonded/unbonding/unbonded) Tokens sdk.Dec `json:"tokens"` // delegated tokens (incl. self-delegation) @@ -207,7 +207,7 @@ func (v Validator) Bech32Validator() (BechValidator, error) { return BechValidator{ Operator: v.Operator, PubKey: bechValPubkey, - Revoked: v.Revoked, + Jailed: v.Jailed, Status: v.Status, Tokens: v.Tokens, @@ -429,7 +429,7 @@ func (v Validator) BondedTokens() sdk.Dec { var _ sdk.Validator = Validator{} // nolint - for sdk.Validator -func (v Validator) GetRevoked() bool { return v.Revoked } +func (v Validator) GetJailed() bool { return v.Jailed } func (v Validator) GetMoniker() string { return v.Description.Moniker } func (v Validator) GetStatus() sdk.BondStatus { return v.Status } func (v Validator) GetOperator() sdk.AccAddress { return v.Operator }