feat: consensus module

baseapp/abci_test.go

@@ -2,6 +2,7 @@ package baseapp
 
 import (
 	"encoding/json"
+	"errors"
 	"os"
 	"testing"
 
@@ -177,35 +178,41 @@ type paramStore struct {
 	db *dbm.MemDB
 }
 
-func (ps *paramStore) Set(_ sdk.Context, key []byte, value interface{}) {
+var ParamstoreKey = []byte("paramstore")
+
+func (ps *paramStore) Set(_ sdk.Context, value *tmproto.ConsensusParams) {
 	bz, err := json.Marshal(value)
 	if err != nil {
 		panic(err)
 	}
 
-	ps.db.Set(key, bz)
+	ps.db.Set(ParamstoreKey, bz)
 }
 
-func (ps *paramStore) Has(_ sdk.Context, key []byte) bool {
-	ok, err := ps.db.Has(key)
+func (ps *paramStore) Has(_ sdk.Context) bool {
+	ok, err := ps.db.Has(ParamstoreKey)
 	if err != nil {
 		panic(err)
 	}
 
 	return ok
 }
 
-func (ps *paramStore) Get(_ sdk.Context, key []byte, ptr interface{}) {
-	bz, err := ps.db.Get(key)
+func (ps paramStore) Get(_ sdk.Context) (*tmproto.ConsensusParams, error) {
+	bz, err := ps.db.Get(ParamstoreKey)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
 
 	if len(bz) == 0 {
-		return
+		return nil, errors.New("no consensus params")
 	}
 
-	if err := json.Unmarshal(bz, ptr); err != nil {
+	var params tmproto.ConsensusParams
+
+	if err := json.Unmarshal(bz, &params); err != nil {
 		panic(err)
 	}
+
+	return &params, nil
 }

baseapp/baseapp.go

@@ -5,15 +5,14 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/cosmos/gogoproto/proto"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/log"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	dbm "github.com/tendermint/tm-db"
 	"golang.org/x/exp/maps"
 
-	"github.com/cosmos/gogoproto/proto"
-
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/snapshots"
 	"github.com/cosmos/cosmos-sdk/store"
@@ -407,39 +406,14 @@ func (app *BaseApp) GetConsensusParams(ctx sdk.Context) *tmproto.ConsensusParams
 		return nil
 	}
 
-	cp := new(tmproto.ConsensusParams)
-
-	if app.paramStore.Has(ctx, ParamStoreKeyBlockParams) {
-		var bp tmproto.BlockParams
-
-		app.paramStore.Get(ctx, ParamStoreKeyBlockParams, &bp)
-		cp.Block = &bp
-	}
-
-	if app.paramStore.Has(ctx, ParamStoreKeyEvidenceParams) {
-		var ep tmproto.EvidenceParams
-
-		app.paramStore.Get(ctx, ParamStoreKeyEvidenceParams, &ep)
-		cp.Evidence = &ep
-	}
-
-	if app.paramStore.Has(ctx, ParamStoreKeyValidatorParams) {
-		var vp tmproto.ValidatorParams
-
-		app.paramStore.Get(ctx, ParamStoreKeyValidatorParams, &vp)
-		cp.Validator = &vp
+	cp, err := app.paramStore.Get(ctx)
+	if err != nil {
+		panic(err)
 	}
 
 	return cp
 }
 
-// AddRunTxRecoveryHandler adds custom app.runTx method panic handlers.
-func (app *BaseApp) AddRunTxRecoveryHandler(handlers ...RecoveryHandler) {
-	for _, h := range handlers {
-		app.runTxRecoveryMiddleware = newRecoveryMiddleware(h, app.runTxRecoveryMiddleware)
-	}
-}
-
 // StoreConsensusParams sets the consensus parameters to the baseapp's param store.
 func (app *BaseApp) StoreConsensusParams(ctx sdk.Context, cp *tmproto.ConsensusParams) {
 	if app.paramStore == nil {
@@ -450,13 +424,18 @@ func (app *BaseApp) StoreConsensusParams(ctx sdk.Context, cp *tmproto.ConsensusP
 		return
 	}
 
-	app.paramStore.Set(ctx, ParamStoreKeyBlockParams, cp.Block)
-	app.paramStore.Set(ctx, ParamStoreKeyEvidenceParams, cp.Evidence)
-	app.paramStore.Set(ctx, ParamStoreKeyValidatorParams, cp.Validator)
+	app.paramStore.Set(ctx, cp)
 	// We're explicitly not storing the Tendermint app_version in the param store. It's
 	// stored instead in the x/upgrade store, with its own bump logic.
 }
 
+// AddRunTxRecoveryHandler adds custom app.runTx method panic handlers.
+func (app *BaseApp) AddRunTxRecoveryHandler(handlers ...RecoveryHandler) {
+	for _, h := range handlers {
+		app.runTxRecoveryMiddleware = newRecoveryMiddleware(h, app.runTxRecoveryMiddleware)
+	}
+}
+
 // getMaximumBlockGas gets the maximum gas from the consensus params. It panics
 // if maximum block gas is less than negative one and returns zero if negative
 // one.

baseapp/block_gas_test.go

@@ -32,8 +32,6 @@ import (
 	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
-	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
-	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
 )
 
 var blockMaxGas = uint64(simtestutil.DefaultConsensusParams.Block.MaxGas)
@@ -73,8 +71,6 @@ func TestBaseApp_BlockGas(t *testing.T) {
 		var (
 			bankKeeper        bankkeeper.Keeper
 			accountKeeper     authkeeper.AccountKeeper
-			paramsKeeper      paramskeeper.Keeper
-			stakingKeeper     *stakingkeeper.Keeper
 			appBuilder        *runtime.AppBuilder
 			txConfig          client.TxConfig
 			cdc               codec.Codec
@@ -88,8 +84,6 @@ func TestBaseApp_BlockGas(t *testing.T) {
 		err = depinject.Inject(appConfig,
 			&bankKeeper,
 			&accountKeeper,
-			&paramsKeeper,
-			&stakingKeeper,
 			&interfaceRegistry,
 			&txConfig,
 			&cdc,

baseapp/deliver_tx_test.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math/rand"
 	"net/url"
@@ -2152,35 +2153,41 @@ type paramStore struct {
 	db *dbm.MemDB
 }
 
-func (ps *paramStore) Set(_ sdk.Context, key []byte, value interface{}) {
+var ParamstoreKey = []byte("paramstore")
+
+func (ps *paramStore) Set(_ sdk.Context, value *tmproto.ConsensusParams) {
 	bz, err := json.Marshal(value)
 	if err != nil {
 		panic(err)
 	}
 
-	ps.db.Set(key, bz)
+	ps.db.Set(ParamstoreKey, bz)
 }
 
-func (ps *paramStore) Has(_ sdk.Context, key []byte) bool {
-	ok, err := ps.db.Has(key)
+func (ps *paramStore) Has(_ sdk.Context) bool {
+	ok, err := ps.db.Has(ParamstoreKey)
 	if err != nil {
 		panic(err)
 	}
 
 	return ok
 }
 
-func (ps *paramStore) Get(_ sdk.Context, key []byte, ptr interface{}) {
-	bz, err := ps.db.Get(key)
+func (ps paramStore) Get(ctx sdk.Context) (*tmproto.ConsensusParams, error) {
+	bz, err := ps.db.Get(ParamstoreKey)
 	if err != nil {
 		panic(err)
 	}
 
 	if len(bz) == 0 {
-		return
+		return nil, errors.New("params not found")
 	}
 
-	if err := json.Unmarshal(bz, ptr); err != nil {
+	var params tmproto.ConsensusParams
+
+	if err := json.Unmarshal(bz, &params); err != nil {
 		panic(err)
 	}
+
+	return &params, nil
 }

baseapp/grpcrouter.go

@@ -114,8 +114,5 @@ func (qrt *GRPCQueryRouter) SetInterfaceRegistry(interfaceRegistry codectypes.In
 	qrt.cdc = codec.NewProtoCodec(interfaceRegistry).GRPCCodec()
 	// Once we have an interface registry, we can register the interface
 	// registry reflection gRPC service.
-	reflection.RegisterReflectionServiceServer(
-		qrt,
-		reflection.NewReflectionServiceServer(interfaceRegistry),
-	)
+	reflection.RegisterReflectionServiceServer(qrt, reflection.NewReflectionServiceServer(interfaceRegistry))
 }

baseapp/params.go

@@ -1,85 +1,15 @@
 package baseapp
 
 import (
-	"errors"
-	"fmt"
-
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-// Paramspace defines the parameter subspace to be used for the paramstore.
-const Paramspace = "baseapp"
-
-// Parameter store keys for all the consensus parameter types.
-var (
-	ParamStoreKeyBlockParams     = []byte("BlockParams")
-	ParamStoreKeyEvidenceParams  = []byte("EvidenceParams")
-	ParamStoreKeyValidatorParams = []byte("ValidatorParams")
-)
-
 // ParamStore defines the interface the parameter store used by the BaseApp must
 // fulfill.
 type ParamStore interface {
-	Get(ctx sdk.Context, key []byte, ptr interface{})
-	Has(ctx sdk.Context, key []byte) bool
-	Set(ctx sdk.Context, key []byte, param interface{})
-}
-
-// ValidateBlockParams defines a stateless validation on BlockParams. This function
-// is called whenever the parameters are updated or stored.
-func ValidateBlockParams(i interface{}) error {
-	v, ok := i.(tmproto.BlockParams)
-	if !ok {
-		return fmt.Errorf("invalid parameter type: %T", i)
-	}
-
-	if v.MaxBytes <= 0 {
-		return fmt.Errorf("block maximum bytes must be positive: %d", v.MaxBytes)
-	}
-
-	if v.MaxGas < -1 {
-		return fmt.Errorf("block maximum gas must be greater than or equal to -1: %d", v.MaxGas)
-	}
-
-	return nil
-}
-
-// ValidateEvidenceParams defines a stateless validation on EvidenceParams. This
-// function is called whenever the parameters are updated or stored.
-func ValidateEvidenceParams(i interface{}) error {
-	v, ok := i.(tmproto.EvidenceParams)
-	if !ok {
-		return fmt.Errorf("invalid parameter type: %T", i)
-	}
-
-	if v.MaxAgeNumBlocks <= 0 {
-		return fmt.Errorf("evidence maximum age in blocks must be positive: %d", v.MaxAgeNumBlocks)
-	}
-
-	if v.MaxAgeDuration <= 0 {
-		return fmt.Errorf("evidence maximum age time duration must be positive: %v", v.MaxAgeDuration)
-	}
-
-	if v.MaxBytes < 0 {
-		return fmt.Errorf("maximum evidence bytes must be non-negative: %v", v.MaxBytes)
-	}
-
-	return nil
-}
-
-// ValidateValidatorParams defines a stateless validation on ValidatorParams. This
-// function is called whenever the parameters are updated or stored.
-func ValidateValidatorParams(i interface{}) error {
-	v, ok := i.(tmproto.ValidatorParams)
-	if !ok {
-		return fmt.Errorf("invalid parameter type: %T", i)
-	}
-
-	if len(v.PubKeyTypes) == 0 {
-		return errors.New("validator allowed pubkey types must not be empty")
-	}
-
-	return nil
+	Get(ctx sdk.Context) (*tmproto.ConsensusParams, error)
+	Has(ctx sdk.Context) bool
+	Set(ctx sdk.Context, cp *tmproto.ConsensusParams)
 }