Slashing v2

CHANGELOG.md

@@ -21,6 +21,12 @@ BREAKING CHANGES
     * `gaiacli stake complete-unbonding`
     * `gaiacli stake begin-redelegation`
     * `gaiacli stake complete-redelegation`
+* [slashing] update slashing for unbonding period
+  * Slash according to power at time of infraction instead of power at
+    time of discovery
+  * Iterate through unbonding delegations & redelegations which contributed
+    to an infraction, slash them proportional to their stake at the time
+  * Add REST endpoint to unrevoke a validator previously revoked for downtime
 
 FEATURES
 * [gaiacli] You can now attach a simple text-only memo to any transaction, with the `--memo` flag

client/lcd/lcd_test.go

@@ -25,6 +25,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/gov"
+	"github.com/cosmos/cosmos-sdk/x/slashing"
 	"github.com/cosmos/cosmos-sdk/x/stake"
 	stakerest "github.com/cosmos/cosmos-sdk/x/stake/client/rest"
 )
@@ -519,6 +520,20 @@ func TestVote(t *testing.T) {
 	assert.Equal(t, gov.VoteOptionToString(gov.OptionYes), vote.Option)
 }
 
+func TestUnrevoke(t *testing.T) {
+	_, password := "test", "1234567890"
+	addr, _ := CreateAddr(t, "test", password, GetKB(t))
+	cleanup, pks, port := InitializeTestLCD(t, 1, []sdk.Address{addr})
+	defer cleanup()
+
+	signingInfo := getSigningInfo(t, port, pks[0].Address())
+	tests.WaitForHeight(4, port)
+	require.Equal(t, int64(2), signingInfo.StartHeight)
+	require.Equal(t, int64(3), signingInfo.IndexOffset)
+	require.Equal(t, int64(0), signingInfo.JailedUntil)
+	require.Equal(t, int64(3), signingInfo.SignedBlocksCounter)
+}
+
 func TestProposalsQuery(t *testing.T) {
 	name, password1 := "test", "1234567890"
 	name2, password2 := "test2", "1234567890"
@@ -677,6 +692,16 @@ func doIBCTransfer(t *testing.T, port, seed, name, password string, addr sdk.Add
 	return resultTx
 }
 
+func getSigningInfo(t *testing.T, port string, validatorAddr sdk.Address) slashing.ValidatorSigningInfo {
+	validatorAddrBech := sdk.MustBech32ifyVal(validatorAddr)
+	res, body := Request(t, port, "GET", "/slashing/signing_info/"+validatorAddrBech, nil)
+	require.Equal(t, http.StatusOK, res.StatusCode, body)
+	var signingInfo slashing.ValidatorSigningInfo
+	err := cdc.UnmarshalJSON([]byte(body), &signingInfo)
+	require.Nil(t, err)
+	return signingInfo
+}
+
 func getDelegation(t *testing.T, port string, delegatorAddr, validatorAddr sdk.Address) stake.Delegation {
 
 	delegatorAddrBech := sdk.MustBech32ifyAcc(delegatorAddr)

client/lcd/root.go

@@ -22,6 +22,7 @@ import (
 	bank "github.com/cosmos/cosmos-sdk/x/bank/client/rest"
 	gov "github.com/cosmos/cosmos-sdk/x/gov/client/rest"
 	ibc "github.com/cosmos/cosmos-sdk/x/ibc/client/rest"
+	slashing "github.com/cosmos/cosmos-sdk/x/slashing/client/rest"
 	stake "github.com/cosmos/cosmos-sdk/x/stake/client/rest"
 )
 
@@ -81,6 +82,7 @@ func createHandler(cdc *wire.Codec) http.Handler {
 	bank.RegisterRoutes(ctx, r, cdc, kb)
 	ibc.RegisterRoutes(ctx, r, cdc, kb)
 	stake.RegisterRoutes(ctx, r, cdc, kb)
+	slashing.RegisterRoutes(ctx, r, cdc, kb)
 	gov.RegisterRoutes(ctx, r, cdc, kb)
 	return r
 }

docs/spec/slashing/end_block.md

@@ -16,32 +16,27 @@ where `evidence.Timestamp` is the timestamp in the block at height
 `evidence.Height` and `block.Timestamp` is the current block timestamp.
 
 If valid evidence is included in a block, the validator's stake is reduced by `SLASH_PROPORTION` of 
-what their stake was when the equivocation occurred (rather than when the evidence was discovered):
+what their stake was when the infraction occurred (rather than when the evidence was discovered).
+We want to "follow the stake": the stake which contributed to the infraction should be
+slashed, even if it has since been redelegated or started unbonding. 
 
-```
-curVal := validator
-oldVal := loadValidator(evidence.Height, evidence.Address)
-
-slashAmount := SLASH_PROPORTION * oldVal.Shares
+We first need to loop through the unbondings and redelegations from the slashed validator
+and track how much stake has since moved:
 
-curVal.Shares = max(0, curVal.Shares - slashAmount)
 ```
+slashAmountUnbondings := 0
+slashAmountRedelegations := 0
 
-This ensures that offending validators are punished the same amount whether they
-act as a single validator with X stake or as N validators with collectively X
-stake.
-
-We also need to loop through the unbondings and redelegations to slash them as
-well:
-
-```
 unbondings := getUnbondings(validator.Address)
 for unbond in unbondings {
-    if was not bonded before evidence.Height {
+
+    if was not bonded before evidence.Height or started unbonding before unbonding period ago {
         continue
     }
-    unbond.InitialTokens
+
     burn := unbond.InitialTokens * SLASH_PROPORTION
+    slashAmountUnbondings += burn
+
     unbond.Tokens = max(0, unbond.Tokens - burn)
 }
 
@@ -51,17 +46,35 @@ for unbond in unbondings {
 redels := getRedelegationsBySource(validator.Address)
 for redel in redels {
 
-    if was not bonded before evidence.Height {
+    if was not bonded before evidence.Height or started redelegating before unbonding period ago {
         continue
     }
 
     burn := redel.InitialTokens * SLASH_PROPORTION
+    slashAmountRedelegations += burn
 
     amount := unbondFromValidator(redel.Destination, burn)
     destroy(amount)
 }
 ```
 
+We then slash the validator:
+
+```
+curVal := validator
+oldVal := loadValidator(evidence.Height, evidence.Address)
+
+slashAmount := SLASH_PROPORTION * oldVal.Shares
+slashAmount -= slashAmountUnbondings
+slashAmount -= slashAmountRedelegations
+
+curVal.Shares = max(0, curVal.Shares - slashAmount)
+```
+
+This ensures that offending validators are punished the same amount whether they
+act as a single validator with X stake or as N validators with collectively X
+stake.
+
 ## Automatic Unbonding
 
 At the beginning of each block, we update the signing info for each validator and check if they should be automatically unbonded:

examples/democoin/mock/validator.go

@@ -38,6 +38,11 @@ func (v Validator) GetDelegatorShares() sdk.Rat {
 	return sdk.ZeroRat()
 }
 
+// Implements sdk.Validator
+func (v Validator) GetRevoked() bool {
+	return false
+}
+
 // Implements sdk.Validator
 func (v Validator) GetBondHeight() int64 {
 	return 0
@@ -107,7 +112,7 @@ func (vs *ValidatorSet) RemoveValidator(addr sdk.Address) {
 }
 
 // Implements sdk.ValidatorSet
-func (vs *ValidatorSet) Slash(ctx sdk.Context, pubkey crypto.PubKey, height int64, amt sdk.Rat) {
+func (vs *ValidatorSet) Slash(ctx sdk.Context, pubkey crypto.PubKey, height int64, power int64, amt sdk.Rat) {
 	panic("not implemented")
 }
 

types/stake.go

@@ -32,6 +32,7 @@ func BondStatusToString(b BondStatus) string {
 
 // validator for a delegated proof of stake system
 type Validator interface {
+	GetRevoked() bool         // whether the validator is revoked
 	GetMoniker() string       // moniker of the validator
 	GetStatus() BondStatus    // status of the validator
 	GetOwner() Address        // owner address to receive/return validators coins
@@ -62,9 +63,10 @@ type ValidatorSet interface {
 	Validator(Context, Address) Validator // get a particular validator by owner address
 	TotalPower(Context) Rat               // total power of the validator set
 
-	Slash(Context, crypto.PubKey, int64, Rat) // slash the validator and delegators of the validator, specifying offence height & slash fraction
-	Revoke(Context, crypto.PubKey)            // revoke a validator
-	Unrevoke(Context, crypto.PubKey)          // unrevoke a validator
+	// slash the validator and delegators of the validator, specifying offence height, offence power, and slash fraction
+	Slash(Context, crypto.PubKey, int64, int64, Rat)
+	Revoke(Context, crypto.PubKey)   // revoke a validator
+	Unrevoke(Context, crypto.PubKey) // unrevoke a validator
 }
 
 //_______________________________________________________________________________

x/slashing/client/rest/query.go

@@ -0,0 +1,62 @@
+package rest
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/x/slashing"
+)
+
+func registerQueryRoutes(ctx context.CoreContext, r *mux.Router, cdc *wire.Codec) {
+	r.HandleFunc(
+		"/slashing/signing_info/{validator}",
+		signingInfoHandlerFn(ctx, "slashing", cdc),
+	).Methods("GET")
+}
+
+// http request handler to query signing info
+func signingInfoHandlerFn(ctx context.CoreContext, storeName string, cdc *wire.Codec) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		// read parameters
+		vars := mux.Vars(r)
+		bech32validator := vars["validator"]
+
+		validatorAddr, err := sdk.GetValAddressBech32(bech32validator)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		key := slashing.GetValidatorSigningInfoKey(validatorAddr)
+		res, err := ctx.QueryStore(key, storeName)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("couldn't query signing info. Error: %s", err.Error())))
+			return
+		}
+
+		var signingInfo slashing.ValidatorSigningInfo
+		err = cdc.UnmarshalBinary(res, &signingInfo)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("couldn't decode signing info. Error: %s", err.Error())))
+			return
+		}
+
+		output, err := cdc.MarshalJSON(signingInfo)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		w.Write(output)
+	}
+}

x/slashing/client/rest/rest.go

@@ -0,0 +1,15 @@
+package rest
+
+import (
+	"github.com/gorilla/mux"
+	"github.com/tendermint/go-crypto/keys"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/wire"
+)
+
+// RegisterRoutes registers staking-related REST handlers to a router
+func RegisterRoutes(ctx context.CoreContext, r *mux.Router, cdc *wire.Codec, kb keys.Keybase) {
+	registerQueryRoutes(ctx, r, cdc)
+	registerTxRoutes(ctx, r, cdc, kb)
+}

x/slashing/client/rest/tx.go

@@ -0,0 +1,103 @@
+package rest
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/tendermint/go-crypto/keys"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/wire"
+	"github.com/cosmos/cosmos-sdk/x/slashing"
+)
+
+func registerTxRoutes(ctx context.CoreContext, r *mux.Router, cdc *wire.Codec, kb keys.Keybase) {
+	r.HandleFunc(
+		"/slashing/unrevoke",
+		unrevokeRequestHandlerFn(cdc, kb, ctx),
+	).Methods("POST")
+}
+
+// Unrevoke TX body
+type UnrevokeBody struct {
+	LocalAccountName string `json:"name"`
+	Password         string `json:"password"`
+	ChainID          string `json:"chain_id"`
+	AccountNumber    int64  `json:"account_number"`
+	Sequence         int64  `json:"sequence"`
+	Gas              int64  `json:"gas"`
+	ValidatorAddr    string `json:"validator_addr"`
+}
+
+func unrevokeRequestHandlerFn(cdc *wire.Codec, kb keys.Keybase, ctx context.CoreContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var m UnrevokeBody
+		body, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+		err = json.Unmarshal(body, &m)
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		info, err := kb.Get(m.LocalAccountName)
+		if err != nil {
+			w.WriteHeader(http.StatusUnauthorized)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		validatorAddr, err := sdk.GetAccAddressBech32(m.ValidatorAddr)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(fmt.Sprintf("Couldn't decode validator. Error: %s", err.Error())))
+			return
+		}
+
+		if !bytes.Equal(info.Address(), validatorAddr) {
+			w.WriteHeader(http.StatusUnauthorized)
+			w.Write([]byte("Must use own validator address"))
+			return
+		}
+
+		ctx = ctx.WithGas(m.Gas)
+		ctx = ctx.WithChainID(m.ChainID)
+		ctx = ctx.WithAccountNumber(m.AccountNumber)
+		ctx = ctx.WithSequence(m.Sequence)
+
+		msg := slashing.NewMsgUnrevoke(validatorAddr)
+
+		txBytes, err := ctx.SignAndBuild(m.LocalAccountName, m.Password, []sdk.Msg{msg}, cdc)
+		if err != nil {
+			w.WriteHeader(http.StatusUnauthorized)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		res, err := ctx.BroadcastTx(txBytes)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		output, err := json.MarshalIndent(res, "", "  ")
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		w.Write(output)
+	}
+}

x/slashing/handler.go

@@ -50,7 +50,7 @@ func handleMsgUnrevoke(ctx sdk.Context, msg MsgUnrevoke, k Keeper) sdk.Result {
 	// Unrevoke the validator
 	k.validatorSet.Unrevoke(ctx, validator.GetPubKey())
 
-	tags := sdk.NewTags("action", []byte("unrevoke"), "validator", msg.ValidatorAddr.Bytes())
+	tags := sdk.NewTags("action", []byte("unrevoke"), "validator", []byte(msg.ValidatorAddr.String()))
 
 	return sdk.Result{
 		Tags: tags,