ADR 17 Implementation: Historical Module

x/staking/abci.go

@@ -0,0 +1,31 @@
+package staking
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+// BeginBlocker will
+func BeginBlocker(ctx sdk.Context, k Keeper) {
+	entryNum := k.HistoricalEntries(ctx)
+	// if there is no need to persist historicalInfo, return
+	if entryNum == 0 {
+		return
+	}
+
+	// Create HistoricalInfo struct
+	lastVals := k.GetLastValidators(ctx)
+	types.Validators(lastVals).Sort()
+	historicalEntry := types.HistoricalInfo{
+		Header: ctx.BlockHeader(),
+		ValSet: lastVals,
+	}
+
+	// Set latest HistoricalInfo at current height
+	k.SetHistoricalInfo(ctx, ctx.BlockHeight(), historicalEntry)
+
+	// prune store to ensure we only have parameter-defined historical entries
+	if ctx.BlockHeight() > int64(entryNum) {
+		k.DeleteHistoricalInfo(ctx, ctx.BlockHeight()-int64(entryNum))
+	}
+}

x/staking/keeper/historical_info.go

@@ -0,0 +1,35 @@
+package keeper
+
+import (
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+)
+
+func (k Keeper) GetHistoricalInfo(ctx sdk.Context, height int64) (hi types.HistoricalInfo, found bool) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetHistoricalInfoKey(height)
+
+	value := store.Get(key)
+
+	if value == nil {
+		return types.HistoricalInfo{}, false
+	}
+
+	hi = types.MustUnmarshalHistoricalInfo(k.cdc, value)
+	return hi, true
+}
+
+func (k Keeper) SetHistoricalInfo(ctx sdk.Context, height int64, hi types.HistoricalInfo) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetHistoricalInfoKey(height)
+
+	value := types.MustMarshalHistoricalInfo(k.cdc, hi)
+	store.Set(key, value)
+}
+
+func (k Keeper) DeleteHistoricalInfo(ctx sdk.Context, height int64) {
+	store := ctx.KVStore(k.storeKey)
+	key := types.GetHistoricalInfoKey(height)
+
+	store.Delete(key)
+}

x/staking/keeper/historical_info_test.go

@@ -0,0 +1,34 @@
+package keeper
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/cosmos/cosmos-sdk/x/staking/types"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestHistoricalInfo(t *testing.T) {
+	ctx, _, keeper, _ := CreateTestInput(t, false, 10)
+	var validators []types.Validator
+
+	for i, valAddr := range addrVals {
+		validators = append(validators, types.NewValidator(valAddr, PKs[i], types.Description{}))
+	}
+
+	hi := types.NewHistoricalInfo(ctx.BlockHeader(), validators)
+
+	keeper.SetHistoricalInfo(ctx, 2, hi)
+
+	recv, found := keeper.GetHistoricalInfo(ctx, 2)
+	require.True(t, found, "HistoricalInfo not found after set")
+	require.Equal(t, hi, recv, "HistoricalInfo not equal")
+	require.True(t, sort.IsSorted(types.Validators(recv.ValSet)), "HistoricalInfo validators is not sorted")
+
+	keeper.DeleteHistoricalInfo(ctx, 2)
+
+	recv, found = keeper.GetHistoricalInfo(ctx, 2)
+	require.False(t, found, "HistoricalInfo found after delete")
+	require.Equal(t, types.HistoricalInfo{}, recv, "HistoricalInfo is not empty")
+}

x/staking/keeper/params.go

@@ -37,6 +37,13 @@ func (k Keeper) MaxEntries(ctx sdk.Context) (res uint16) {
 	return
 }
 
+// HistoricalEntries = number of historical info entries
+// to persist in store
+func (k Keeper) HistoricalEntries(ctx sdk.Context) (res uint16) {
+	k.paramstore.Get(ctx, types.KeyHistoricalEntries, &res)
+	return
+}
+
 // BondDenom - Bondable coin denomination
 func (k Keeper) BondDenom(ctx sdk.Context) (res string) {
 	k.paramstore.Get(ctx, types.KeyBondDenom, &res)
@@ -49,6 +56,7 @@ func (k Keeper) GetParams(ctx sdk.Context) types.Params {
 		k.UnbondingTime(ctx),
 		k.MaxValidators(ctx),
 		k.MaxEntries(ctx),
+		k.HistoricalEntries(ctx),
 		k.BondDenom(ctx),
 	)
 }

x/staking/keeper/querier.go

@@ -327,6 +327,17 @@ func queryRedelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byt
 	return res, nil
 }
 
+func queryHistoricalInfo(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, sdk.Error) {
+	var params types.QueryHistoricalInfoParams
+
+	err := types.ModuleCdc.UnmarshalJSON(req.Data, &params)
+	if err != nil {
+		return nil, sdk.ErrUnknownRequest(string(req.Data))
+	}
+	return nil, nil
+
+}
+
 func queryPool(ctx sdk.Context, k Keeper) ([]byte, sdk.Error) {
 	bondDenom := k.BondDenom(ctx)
 	bondedPool := k.GetBondedPool(ctx)

x/staking/module.go

@@ -165,7 +165,9 @@ func (am AppModule) ExportGenesis(ctx sdk.Context) json.RawMessage {
 }
 
 // BeginBlock returns the begin blocker for the staking module.
-func (AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+func (am AppModule) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
+	BeginBlocker(ctx, am.keeper)
+}
 
 // EndBlock returns the end blocker for the staking module. It returns no validator
 // updates.

x/staking/simulation/genesis.go

@@ -50,7 +50,7 @@ func RandomizedGenState(simState *module.SimulationState) {
 	// NewSimulationManager constructor for this to work
 	simState.UnbondTime = unbondTime
 
-	params := types.NewParams(simState.UnbondTime, maxValidators, 7, sdk.DefaultBondDenom)
+	params := types.NewParams(simState.UnbondTime, maxValidators, 7, 3, sdk.DefaultBondDenom)
 
 	// validators & delegations
 	var (

x/staking/types/errors.go

@@ -14,14 +14,15 @@ type CodeType = sdk.CodeType
 const (
 	DefaultCodespace sdk.CodespaceType = ModuleName
 
-	CodeInvalidValidator  CodeType = 101
-	CodeInvalidDelegation CodeType = 102
-	CodeInvalidInput      CodeType = 103
-	CodeValidatorJailed   CodeType = 104
-	CodeInvalidAddress    CodeType = sdk.CodeInvalidAddress
-	CodeUnauthorized      CodeType = sdk.CodeUnauthorized
-	CodeInternal          CodeType = sdk.CodeInternal
-	CodeUnknownRequest    CodeType = sdk.CodeUnknownRequest
+	CodeInvalidValidator      CodeType = 101
+	CodeInvalidDelegation     CodeType = 102
+	CodeInvalidInput          CodeType = 103
+	CodeValidatorJailed       CodeType = 104
+	CodeInvalidHistoricalInfo CodeType = 105
+	CodeInvalidAddress        CodeType = sdk.CodeInvalidAddress
+	CodeUnauthorized          CodeType = sdk.CodeUnauthorized
+	CodeInternal              CodeType = sdk.CodeInternal
+	CodeUnknownRequest        CodeType = sdk.CodeUnknownRequest
 )
 
 //validator
@@ -212,3 +213,7 @@ func ErrNeitherShareMsgsGiven(codespace sdk.CodespaceType) sdk.Error {
 func ErrMissingSignature(codespace sdk.CodespaceType) sdk.Error {
 	return sdk.NewError(codespace, CodeInvalidValidator, "missing signature")
 }
+
+func ErrInvalidHistoricalInfo(codespace sdk.CodespaceType) sdk.Error {
+	return sdk.NewError(codespace, CodeInvalidHistoricalInfo, "invalid historical info")
+}

x/staking/types/historical_info.go

@@ -0,0 +1,49 @@
+package types
+
+import (
+	"sort"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+type HistoricalInfo struct {
+	Header abci.Header
+	ValSet []Validator
+}
+
+func NewHistoricalInfo(header abci.Header, valSet []Validator) HistoricalInfo {
+	return HistoricalInfo{
+		Header: header,
+		ValSet: valSet,
+	}
+}
+
+func MustMarshalHistoricalInfo(cdc *codec.Codec, hi HistoricalInfo) []byte {
+	return cdc.MustMarshalBinaryLengthPrefixed(hi)
+}
+
+func MustUnmarshalHistoricalInfo(cdc *codec.Codec, value []byte) HistoricalInfo {
+	hi, err := UnmarshalHistoricalInfo(cdc, value)
+	if err != nil {
+		panic(err)
+	}
+	return hi
+}
+
+func UnmarshalHistoricalInfo(cdc *codec.Codec, value []byte) (hi HistoricalInfo, err error) {
+	err = cdc.UnmarshalBinaryLengthPrefixed(value, &hi)
+	return hi, err
+}
+
+func ValidateHistoricalInfo(hi HistoricalInfo) error {
+	if hi.ValSet != nil {
+		return sdkerrors.Wrap(ErrInvalidHistoricalInfo(DefaultCodespace), "ValidatorSer is nil")
+	}
+	if !sort.IsSorted(Validators(hi.ValSet)) {
+		return sdkerrors.Wrap(ErrInvalidHistoricalInfo(DefaultCodespace), "ValidatorSet is not sorted by address")
+	}
+	return nil
+}

x/staking/types/keys.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"encoding/binary"
+	"fmt"
 	"time"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -45,6 +46,8 @@ var (
 	UnbondingQueueKey    = []byte{0x41} // prefix for the timestamps in unbonding queue
 	RedelegationQueueKey = []byte{0x42} // prefix for the timestamps in redelegations queue
 	ValidatorQueueKey    = []byte{0x43} // prefix for the timestamps in validator queue
+
+	HistoricalInfoKey = []byte{0x50} // prefix for the historical info
 )
 
 // gets the key for the validator with address
@@ -278,3 +281,10 @@ func GetREDsByDelToValDstIndexKey(delAddr sdk.AccAddress, valDstAddr sdk.ValAddr
 		GetREDsToValDstIndexKey(valDstAddr),
 		delAddr.Bytes()...)
 }
+
+//________________________________________________________________________________
+
+// gets the key for historicalinfo
+func GetHistoricalInfoKey(height int64) []byte {
+	return append(HistoricalInfoKey, []byte(fmt.Sprintf("%d", height))...)
+}

x/staking/types/params.go

@@ -22,36 +22,41 @@ const (
 
 	// Default maximum entries in a UBD/RED pair
 	DefaultMaxEntries uint16 = 7
+
+	DefaultHistoricalEntries uint16 = 0
 )
 
 // nolint - Keys for parameter access
 var (
-	KeyUnbondingTime = []byte("UnbondingTime")
-	KeyMaxValidators = []byte("MaxValidators")
-	KeyMaxEntries    = []byte("KeyMaxEntries")
-	KeyBondDenom     = []byte("BondDenom")
+	KeyUnbondingTime     = []byte("UnbondingTime")
+	KeyMaxValidators     = []byte("MaxValidators")
+	KeyMaxEntries        = []byte("KeyMaxEntries")
+	KeyBondDenom         = []byte("BondDenom")
+	KeyHistoricalEntries = []byte("HistoricalEntries")
 )
 
 var _ params.ParamSet = (*Params)(nil)
 
 // Params defines the high level settings for staking
 type Params struct {
-	UnbondingTime time.Duration `json:"unbonding_time" yaml:"unbonding_time"` // time duration of unbonding
-	MaxValidators uint16        `json:"max_validators" yaml:"max_validators"` // maximum number of validators (max uint16 = 65535)
-	MaxEntries    uint16        `json:"max_entries" yaml:"max_entries"`       // max entries for either unbonding delegation or redelegation (per pair/trio)
+	UnbondingTime     time.Duration `json:"unbonding_time" yaml:"unbonding_time"`         // time duration of unbonding
+	MaxValidators     uint16        `json:"max_validators" yaml:"max_validators"`         // maximum number of validators (max uint16 = 65535)
+	MaxEntries        uint16        `json:"max_entries" yaml:"max_entries"`               // max entries for either unbonding delegation or redelegation (per pair/trio)
+	HistoricalEntries uint16        `json:"historical_entries" yaml:"historical_entries"` // number of historical entries to persist
 	// note: we need to be a bit careful about potential overflow here, since this is user-determined
 	BondDenom string `json:"bond_denom" yaml:"bond_denom"` // bondable coin denomination
 }
 
 // NewParams creates a new Params instance
-func NewParams(unbondingTime time.Duration, maxValidators, maxEntries uint16,
+func NewParams(unbondingTime time.Duration, maxValidators, maxEntries, historicalEntries uint16,
 	bondDenom string) Params {
 
 	return Params{
-		UnbondingTime: unbondingTime,
-		MaxValidators: maxValidators,
-		MaxEntries:    maxEntries,
-		BondDenom:     bondDenom,
+		UnbondingTime:     unbondingTime,
+		MaxValidators:     maxValidators,
+		MaxEntries:        maxEntries,
+		HistoricalEntries: historicalEntries,
+		BondDenom:         bondDenom,
 	}
 }
 
@@ -61,6 +66,7 @@ func (p *Params) ParamSetPairs() params.ParamSetPairs {
 		{Key: KeyUnbondingTime, Value: &p.UnbondingTime},
 		{Key: KeyMaxValidators, Value: &p.MaxValidators},
 		{Key: KeyMaxEntries, Value: &p.MaxEntries},
+		{Key: KeyHistoricalEntries, Value: &p.HistoricalEntries},
 		{Key: KeyBondDenom, Value: &p.BondDenom},
 	}
 }
@@ -75,17 +81,18 @@ func (p Params) Equal(p2 Params) bool {
 
 // DefaultParams returns a default set of parameters.
 func DefaultParams() Params {
-	return NewParams(DefaultUnbondingTime, DefaultMaxValidators, DefaultMaxEntries, sdk.DefaultBondDenom)
+	return NewParams(DefaultUnbondingTime, DefaultMaxValidators, DefaultMaxEntries, DefaultHistoricalEntries, sdk.DefaultBondDenom)
 }
 
 // String returns a human readable string representation of the parameters.
 func (p Params) String() string {
 	return fmt.Sprintf(`Params:
-  Unbonding Time:    %s
-  Max Validators:    %d
-  Max Entries:       %d
-  Bonded Coin Denom: %s`, p.UnbondingTime,
-		p.MaxValidators, p.MaxEntries, p.BondDenom)
+  Unbonding Time:     %s
+  Max Validators:     %d
+  Max Entries:        %d
+  Historical Entries: %d
+  Bonded Coin Denom:  %s`, p.UnbondingTime,
+		p.MaxValidators, p.MaxEntries, p.HistoricalEntries, p.BondDenom)
 }
 
 // unmarshal the current staking params value from store key or panic

x/staking/types/querier.go

@@ -20,6 +20,7 @@ const (
 	QueryDelegatorValidator            = "delegatorValidator"
 	QueryPool                          = "pool"
 	QueryParameters                    = "parameters"
+	QueryHistoricalInfo                = "historicalInfo"
 )
 
 // defines the params for the following queries:
@@ -96,3 +97,13 @@ type QueryValidatorsParams struct {
 func NewQueryValidatorsParams(page, limit int, status string) QueryValidatorsParams {
 	return QueryValidatorsParams{page, limit, status}
 }
+
+// QueryHistoricalInfoParams defines the params for the following queries:
+// - 'custom/staking/historicalInfo'
+type QueryHistoricalInfoParams struct {
+	Height int
+}
+
+func NewQueryHistoricalInfoParams(height int) QueryHistoricalInfoParams {
+	return QueryHistoricalInfoParams{height}
+}