feat: DASigners change params (#67)

* feat: use gov to manage dasigners params

* feat: evm precompile query func

* test: unit test

* feat: remove epoch and block height hard check

* feat: add params event

app/app.go

@@ -509,7 +509,7 @@ func NewApp(
 		precompiles,
 	)
 	// dasigners keeper
-	app.dasignersKeeper = dasignerskeeper.NewKeeper(keys[dasignerstypes.StoreKey], appCodec, app.stakingKeeper)
+	app.dasignersKeeper = dasignerskeeper.NewKeeper(keys[dasignerstypes.StoreKey], appCodec, app.stakingKeeper, govAuthAddrStr)
 	// precopmiles
 	precompiles := make(map[common.Address]vm.PrecompiledContract)
 	daSignersPrecompile, err := dasignersprecompile.NewDASignersPrecompile(app.dasignersKeeper)

precompiles/dasigners/IDASigners.abi

@@ -268,6 +268,46 @@
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "params",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "tokensPerVote",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "maxVotesPerSigner",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "maxQuorums",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "epochBlocks",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "encodedSlices",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct IDASigners.Params",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

precompiles/dasigners/dasigners.go

@@ -18,6 +18,7 @@ const (
 
 	RequiredGasMax uint64 = 1000_000_000
 
+	DASignersFunctionParams            = "params"
 	DASignersFunctionEpochNumber       = "epochNumber"
 	DASignersFunctionQuorumCount       = "quorumCount"
 	DASignersFunctionGetSigner         = "getSigner"
@@ -32,6 +33,7 @@ const (
 )
 
 var RequiredGasBasic = map[string]uint64{
+	DASignersFunctionParams:            1000,
 	DASignersFunctionEpochNumber:       1000,
 	DASignersFunctionQuorumCount:       1000,
 	DASignersFunctionGetSigner:         100000,
@@ -117,6 +119,8 @@ func (d *DASignersPrecompile) Run(evm *vm.EVM, contract *vm.Contract, readonly b
 	var bz []byte
 	switch method.Name {
 	// queries
+	case DASignersFunctionParams:
+		bz, err = d.Params(ctx, evm, method, args)
 	case DASignersFunctionEpochNumber:
 		bz, err = d.EpochNumber(ctx, evm, method, args)
 	case DASignersFunctionQuorumCount:

precompiles/dasigners/dasigners_test.go

@@ -370,6 +370,25 @@ func (suite *DASignersTestSuite) Test_DASigners() {
 
 }
 
+func (suite *DASignersTestSuite) Test_Params() {
+	input, err := suite.abi.Pack(
+		"params",
+	)
+	suite.Assert().NoError(err)
+
+	bz, err := suite.runTx(input, suite.signerOne, 10000000)
+	suite.Assert().NoError(err)
+	out, err := suite.abi.Methods["params"].Outputs.Unpack(bz)
+	suite.Assert().NoError(err)
+	params := out[0].(dasignersprecompile.IDASignersParams)
+	expected := types.DefaultGenesisState().Params
+	suite.Assert().EqualValues(expected.TokensPerVote, params.TokensPerVote.Uint64())
+	suite.Assert().EqualValues(expected.MaxVotesPerSigner, params.MaxVotesPerSigner.Uint64())
+	suite.Assert().EqualValues(expected.MaxQuorums, params.MaxQuorums.Uint64())
+	suite.Assert().EqualValues(expected.EpochBlocks, params.EpochBlocks.Uint64())
+	suite.Assert().EqualValues(expected.EncodedSlices, params.EncodedSlices.Uint64())
+}
+
 func TestKeeperSuite(t *testing.T) {
 	suite.Run(t, new(DASignersTestSuite))
 }

precompiles/dasigners/query.go

@@ -11,6 +11,17 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 )
 
+func (d *DASignersPrecompile) Params(ctx sdk.Context, _ *vm.EVM, method *abi.Method, _ []interface{}) ([]byte, error) {
+	params := d.dasignersKeeper.GetParams(ctx)
+	return method.Outputs.Pack(IDASignersParams{
+		TokensPerVote:     big.NewInt(int64(params.TokensPerVote)),
+		MaxVotesPerSigner: big.NewInt(int64(params.MaxVotesPerSigner)),
+		MaxQuorums:        big.NewInt(int64(params.MaxQuorums)),
+		EpochBlocks:       big.NewInt(int64(params.EpochBlocks)),
+		EncodedSlices:     big.NewInt(int64(params.EncodedSlices)),
+	})
+}
+
 func (d *DASignersPrecompile) EpochNumber(ctx sdk.Context, _ *vm.EVM, method *abi.Method, _ []interface{}) ([]byte, error) {
 	epochNumber, err := d.dasignersKeeper.GetEpochNumber(ctx)
 	if err != nil {

precompiles/dasigners/types.go

@@ -27,6 +27,14 @@ type IDASignersSignerDetail = struct {
 	PkG2   BN254G2Point   "json:\"pkG2\""
 }
 
+type IDASignersParams = struct {
+	TokensPerVote     *big.Int "json:\"tokensPerVote\""
+	MaxVotesPerSigner *big.Int "json:\"maxVotesPerSigner\""
+	MaxQuorums        *big.Int "json:\"maxQuorums\""
+	EpochBlocks       *big.Int "json:\"epochBlocks\""
+	EncodedSlices     *big.Int "json:\"encodedSlices\""
+}
+
 func NewBN254G1Point(b []byte) BN254G1Point {
 	return BN254G1Point{
 		X: new(big.Int).SetBytes(b[:32]),

proto/zgc/dasigners/v1/query.proto

@@ -7,12 +7,16 @@ import "google/api/annotations.proto";
 import "google/protobuf/any.proto";
 import "google/protobuf/timestamp.proto";
 import "zgc/dasigners/v1/dasigners.proto";
+import "zgc/dasigners/v1/genesis.proto";
 
 option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types";
 option (gogoproto.goproto_getters_all) = false;
 
 // Query defines the gRPC querier service for the dasigners module
 service Query {
+  rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
+    option (google.api.http).get = "/0g/dasigners/v1/params";
+  }
   rpc EpochNumber(QueryEpochNumberRequest) returns (QueryEpochNumberResponse) {
     option (google.api.http).get = "/0g/dasigners/v1/epoch-number";
   }
@@ -33,6 +37,12 @@ service Query {
   }
 }
 
+message QueryParamsRequest {}
+
+message QueryParamsResponse {
+  Params params = 1;
+}
+
 message QuerySignerRequest {
   repeated string accounts = 1;
 }

proto/zgc/dasigners/v1/tx.proto

@@ -5,17 +5,26 @@ import "cosmos_proto/cosmos.proto";
 import "gogoproto/gogo.proto";
 import "google/protobuf/any.proto";
 import "zgc/dasigners/v1/dasigners.proto";
+import "zgc/dasigners/v1/genesis.proto";
 
 option go_package = "github.com/0glabs/0g-chain/x/dasigners/v1/types";
 option (gogoproto.goproto_getters_all) = false;
 
 // Msg defines the dasigners Msg service
 service Msg {
+  rpc ChangeParams(MsgChangeParams) returns (MsgChangeParamsResponse);
   rpc RegisterSigner(MsgRegisterSigner) returns (MsgRegisterSignerResponse);
   rpc UpdateSocket(MsgUpdateSocket) returns (MsgUpdateSocketResponse);
   rpc RegisterNextEpoch(MsgRegisterNextEpoch) returns (MsgRegisterNextEpochResponse);
 }
 
+message MsgChangeParams {
+  string authority = 1;
+  Params params = 2;
+}
+
+message MsgChangeParamsResponse {}
+
 message MsgRegisterSigner {
   Signer signer = 1;
   bytes signature = 2;

x/dasigners/v1/keeper/abci.go

@@ -17,22 +17,17 @@ type Ballot struct {
 	content []byte
 }
 
-// generateOneEpoch generate one epoch and returns true if there is a new epoch generated
+func (k Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
-func (k Keeper) generateOneEpoch(ctx sdk.Context) bool {
+	params := k.GetParams(ctx)
+	if uint64(ctx.BlockHeight())%params.EpochBlocks != 0 {
+		return
+	}
 	epochNumber, err := k.GetEpochNumber(ctx)
 	if err != nil {
 		k.Logger(ctx).Error("[BeginBlock] cannot get epoch number")
 		panic(err)
 	}
-	params := k.GetParams(ctx)
+	expectedEpoch := epochNumber + 1
-	expectedEpoch := uint64(ctx.BlockHeight()) / params.EpochBlocks
-	if expectedEpoch == epochNumber {
-		return false
-	}
-	if expectedEpoch < epochNumber {
-		panic("block height is not continuous")
-	}
-	expectedEpoch = epochNumber + 1
 	// new epoch
 	k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] generating epoch %v", expectedEpoch))
 	registrations := []Ballot{}
@@ -110,11 +105,6 @@ func (k Keeper) generateOneEpoch(ctx sdk.Context) bool {
 	// save to store
 	k.SetEpochQuorums(ctx, expectedEpoch, quorums)
 	k.SetEpochNumber(ctx, expectedEpoch)
-	k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] epoch %v generated, with %v quorums", expectedEpoch, len(quorums.Quorums)))
+	k.Logger(ctx).Info(fmt.Sprintf("[BeginBlock] epoch %v generated at block height %v, with %v quorums", expectedEpoch, ctx.BlockHeight(), len(quorums.Quorums)))
-	return true
+	return
-}
-
-func (k Keeper) BeginBlock(ctx sdk.Context, _ abci.RequestBeginBlock) {
-	for k.generateOneEpoch(ctx) {
-	}
 }

x/dasigners/v1/keeper/abci_test.go

@@ -31,11 +31,7 @@ func (suite *AbciTestSuite) TestBeginBlock_NotContinuous() {
 	})
 	epoch, err = suite.Keeper.GetEpochNumber(suite.Ctx)
 	suite.Require().NoError(err)
-	suite.Assert().EqualValues(epoch, 10)
+	suite.Assert().EqualValues(epoch, 1)
-
-	suite.Assert().Panics(func() {
-		suite.Keeper.BeginBlock(suite.Ctx.WithBlockHeight(int64(params.EpochBlocks*9)), abci.RequestBeginBlock{})
-	}, "block height is not continuous")
 }
 
 func (suite *AbciTestSuite) TestBeginBlock_Success() {

x/dasigners/v1/keeper/grpc_query.go

@@ -11,6 +11,17 @@ import (
 
 var _ types.QueryServer = Keeper{}
 
+func (k Keeper) Params(
+	c context.Context,
+	request *types.QueryParamsRequest,
+) (*types.QueryParamsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	params := k.GetParams(ctx)
+	return &types.QueryParamsResponse{
+		Params: &params,
+	}, nil
+}
+
 func (k Keeper) Signer(
 	c context.Context,
 	request *types.QuerySignerRequest,

x/dasigners/v1/keeper/keeper.go

@@ -2,18 +2,21 @@ package keeper
 
 import (
 	"encoding/hex"
+	"fmt"
 	"math/big"
 
 	"cosmossdk.io/math"
 	"github.com/cometbft/cometbft/libs/log"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/store/prefix"
+
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 
 	"github.com/0glabs/0g-chain/chaincfg"
 	"github.com/0glabs/0g-chain/x/dasigners/v1/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 )
 
 var BondedConversionRate = math.NewIntFromBigInt(big.NewInt(0).Exp(big.NewInt(10), big.NewInt(chaincfg.GasDenomUnit), nil))
@@ -22,6 +25,7 @@ type Keeper struct {
 	storeKey      storetypes.StoreKey
 	cdc           codec.BinaryCodec
 	stakingKeeper types.StakingKeeper
+	authority     string // the address capable of changing signers params. Should be the gov module account
 }
 
 // NewKeeper creates a new das Keeper instance
@@ -29,11 +33,13 @@ func NewKeeper(
 	storeKey storetypes.StoreKey,
 	cdc codec.BinaryCodec,
 	stakingKeeper types.StakingKeeper,
+	authority string,
 ) Keeper {
 	return Keeper{
 		storeKey:      storeKey,
 		cdc:           cdc,
 		stakingKeeper: stakingKeeper,
+		authority:     authority,
 	}
 }
 
@@ -54,6 +60,17 @@ func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshal(&params)
 	store.Set(types.ParamsKey, bz)
+
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeUpdateParams,
+			sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprint(ctx.BlockHeader().Height)),
+			sdk.NewAttribute(types.AttributeKeyTokensPerVote, fmt.Sprint(params.TokensPerVote)),
+			sdk.NewAttribute(types.AttributeKeyMaxQuorums, fmt.Sprint(params.MaxQuorums)),
+			sdk.NewAttribute(types.AttributeKeyEpochBlocks, fmt.Sprint(params.EpochBlocks)),
+			sdk.NewAttribute(types.AttributeKeyEncodedSlices, fmt.Sprint(params.EncodedSlices)),
+		),
+	)
 }
 
 func (k Keeper) GetEpochNumber(ctx sdk.Context) (uint64, error) {

x/dasigners/v1/keeper/msg_server.go

@@ -3,15 +3,28 @@ package keeper
 import (
 	"context"
 
+	errorsmod "cosmossdk.io/errors"
 	"github.com/0glabs/0g-chain/crypto/bn254util"
 	"github.com/0glabs/0g-chain/x/dasigners/v1/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	gov "github.com/cosmos/cosmos-sdk/x/gov/types"
 	"github.com/ethereum/go-ethereum/common"
 	etherminttypes "github.com/evmos/ethermint/types"
 )
 
 var _ types.MsgServer = &Keeper{}
 
+func (k Keeper) ChangeParams(goCtx context.Context, msg *types.MsgChangeParams) (*types.MsgChangeParamsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	// validate authority
+	if k.authority != msg.Authority {
+		return nil, errorsmod.Wrapf(gov.ErrInvalidSigner, "expected %s got %s", k.authority, msg.Authority)
+	}
+	// save params
+	k.SetParams(ctx, *msg.Params)
+	return &types.MsgChangeParamsResponse{}, nil
+}
+
 func (k Keeper) RegisterSigner(goCtx context.Context, msg *types.MsgRegisterSigner) (*types.MsgRegisterSignerResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	// validate sender

x/dasigners/v1/keeper/msg_server_test.go

@@ -0,0 +1,87 @@
+package keeper_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/0glabs/0g-chain/x/dasigners/v1/testutil"
+	"github.com/0glabs/0g-chain/x/dasigners/v1/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/suite"
+)
+
+type MsgServerTestSuite struct {
+	testutil.Suite
+}
+
+func (suite *MsgServerTestSuite) TestChangeParams() {
+	govAccAddr := suite.GovKeeper.GetGovernanceAccount(suite.Ctx).GetAddress().String()
+
+	testCases := []struct {
+		name      string
+		req       *types.MsgChangeParams
+		expectErr bool
+		errMsg    string
+	}{
+		{
+			name: "invalid signer",
+			req: &types.MsgChangeParams{
+				Authority: suite.Addresses[0].String(),
+				Params: &types.Params{
+					TokensPerVote:     10,
+					MaxVotesPerSigner: 1024,
+					MaxQuorums:        10,
+					EpochBlocks:       5760,
+					EncodedSlices:     3072,
+				},
+			},
+			expectErr: true,
+			errMsg:    "expected gov account as only signer for proposal message",
+		},
+		{
+			name: "success",
+			req: &types.MsgChangeParams{
+				Authority: govAccAddr,
+				Params: &types.Params{
+					TokensPerVote:     1,
+					MaxVotesPerSigner: 2048,
+					MaxQuorums:        1,
+					EpochBlocks:       100,
+					EncodedSlices:     2048 * 3,
+				},
+			},
+			expectErr: false,
+		},
+	}
+	for _, tc := range testCases {
+		suite.Run(tc.name, func() {
+			oldEventNum := len(suite.Ctx.EventManager().Events())
+			_, err := suite.Keeper.ChangeParams(suite.Ctx, tc.req)
+			if tc.expectErr {
+				suite.Require().Error(err)
+				suite.Require().Contains(err.Error(), tc.errMsg)
+			} else {
+				suite.Require().NoError(err)
+				params := suite.Keeper.GetParams(suite.Ctx)
+				suite.Require().EqualValues(*tc.req.Params, params)
+				suite.Assert().NoError(err)
+
+				events := suite.Ctx.EventManager().Events()
+				suite.Assert().EqualValues(len(events), oldEventNum+1)
+				suite.Assert().EqualValues(events[len(events)-1], sdk.NewEvent(
+					types.EventTypeUpdateParams,
+					sdk.NewAttribute(types.AttributeKeyBlockHeight, fmt.Sprint(suite.Ctx.BlockHeader().Height)),
+					sdk.NewAttribute(types.AttributeKeyTokensPerVote, fmt.Sprint(params.TokensPerVote)),
+					sdk.NewAttribute(types.AttributeKeyMaxQuorums, fmt.Sprint(params.MaxQuorums)),
+					sdk.NewAttribute(types.AttributeKeyEpochBlocks, fmt.Sprint(params.EpochBlocks)),
+					sdk.NewAttribute(types.AttributeKeyEncodedSlices, fmt.Sprint(params.EncodedSlices)),
+				),
+				)
+			}
+		})
+	}
+}
+
+func TestMsgServerSuite(t *testing.T) {
+	suite.Run(t, new(MsgServerTestSuite))
+}

x/dasigners/v1/testutil/suite.go

@@ -14,6 +14,7 @@ import (
 	"github.com/0glabs/0g-chain/chaincfg"
 	"github.com/0glabs/0g-chain/x/dasigners/v1/keeper"
 	"github.com/0glabs/0g-chain/x/dasigners/v1/types"
+	govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper"
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	"github.com/evmos/ethermint/crypto/ethsecp256k1"
 )
@@ -24,6 +25,7 @@ type Suite struct {
 
 	Keeper        keeper.Keeper
 	StakingKeeper *stakingkeeper.Keeper
+	GovKeeper     govkeeper.Keeper
 	App           app.TestApp
 	Ctx           sdk.Context
 	QueryClient   types.QueryClient
@@ -37,6 +39,7 @@ func (suite *Suite) SetupTest() {
 	suite.App.InitializeFromGenesisStates()
 	suite.Keeper = suite.App.GetDASignersKeeper()
 	suite.StakingKeeper = suite.App.GetStakingKeeper()
+	suite.GovKeeper = suite.App.GetGovKeeper()
 
 	// make block header
 	privkey, _ := ethsecp256k1.GenerateKey()

x/dasigners/v1/types/errors.go

@@ -12,4 +12,5 @@ var (
 	ErrQuorumBitmapLengthMismatch = errorsmod.Register(ModuleName, 7, "quorum bitmap length mismatch")
 	ErrInsufficientBonded         = errorsmod.Register(ModuleName, 8, "insufficient bonded amount")
 	ErrRowIndexOutOfBound         = errorsmod.Register(ModuleName, 9, "row index out of bound")
+	ErrInvalidEpochBlocks         = errorsmod.Register(ModuleName, 10, "invalid epoch blocks")
 )

x/dasigners/v1/types/events.go

@@ -3,9 +3,16 @@ package types
 // Module event types
 const (
 	EventTypeUpdateSigner = "update_signer"
+	EventTypeUpdateParams = "update_params"
 
 	AttributeKeySigner            = "signer"
 	AttributeKeySocket            = "socket"
 	AttributeKeyPublicKeyG1       = "pubkey_g1"
 	AttributeKeyPublicKeyG2       = "pubkey_g2"
+	AttributeKeyBlockHeight       = "block_height"
+	AttributeKeyTokensPerVote     = "tokens_per_vote"
+	AttributeKeyMaxVotesPerSigner = "max_votes_per_signer"
+	AttributeKeyMaxQuorums        = "max_quorums"
+	AttributeKeyEpochBlocks       = "epoch_blocks"
+	AttributeKeyEncodedSlices     = "encoded_slices"
 )

x/dasigners/v1/types/msg.go

@@ -4,14 +4,16 @@ import (
 	"encoding/hex"
 	fmt "fmt"
 
+	errorsmod "cosmossdk.io/errors"
+
 	"github.com/0glabs/0g-chain/crypto/bn254util"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-var _, _, _ sdk.Msg = &MsgRegisterSigner{}, &MsgUpdateSocket{}, &MsgRegisterNextEpoch{}
+var _, _, _, _ sdk.Msg = &MsgRegisterSigner{}, &MsgUpdateSocket{}, &MsgRegisterNextEpoch{}, &MsgChangeParams{}
 
-// GetSigners returns the expected signers for a MsgRegister message.
+// GetSigners returns the expected signers for a MsgRegisterSigner message.
 func (msg *MsgRegisterSigner) GetSigners() []sdk.AccAddress {
 	valAddr, err := sdk.ValAddressFromHex(msg.Signer.Account)
 	if err != nil {
@@ -40,7 +42,7 @@ func (msg MsgRegisterSigner) GetSignBytes() []byte {
 	return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
 }
 
-// GetSigners returns the expected signers for a MsgVote message.
+// GetSigners returns the expected signers for a MsgUpdateSocket message.
 func (msg *MsgUpdateSocket) GetSigners() []sdk.AccAddress {
 	valAddr, err := sdk.ValAddressFromHex(msg.Account)
 	if err != nil {
@@ -66,7 +68,7 @@ func (msg MsgUpdateSocket) GetSignBytes() []byte {
 	return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
 }
 
-// GetSigners returns the expected signers for a MsgVote message.
+// GetSigners returns the expected signers for a MsgRegisterNextEpoch message.
 func (msg *MsgRegisterNextEpoch) GetSigners() []sdk.AccAddress {
 	valAddr, err := sdk.ValAddressFromHex(msg.Account)
 	if err != nil {
@@ -94,3 +96,22 @@ func (msg *MsgRegisterNextEpoch) ValidateBasic() error {
 func (msg MsgRegisterNextEpoch) GetSignBytes() []byte {
 	return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
 }
+
+// GetSigners returns the expected signers for a MsgSetParams message.
+func (msg *MsgChangeParams) GetSigners() []sdk.AccAddress {
+	addr, _ := sdk.AccAddressFromBech32(msg.Authority)
+	return []sdk.AccAddress{addr}
+}
+
+// ValidateBasic does a sanity check of the provided data
+func (msg *MsgChangeParams) ValidateBasic() error {
+	if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil {
+		return errorsmod.Wrap(err, "authority")
+	}
+
+	if err := msg.Params.Validate(); err != nil {
+		return errorsmod.Wrap(err, "params")
+	}
+
+	return nil
+}

x/dasigners/v1/types/params.go

@@ -0,0 +1,8 @@
+package types
+
+func (p *Params) Validate() error {
+	if p.EpochBlocks == 0 {
+		return ErrInvalidEpochBlocks
+	}
+	return nil
+}

x/dasigners/v1/types/query.pb.go

@@ -32,6 +32,79 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
+type QueryParamsRequest struct {
+}
+
+func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
+func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryParamsRequest) ProtoMessage()    {}
+func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_991a610b84b5964c, []int{0}
+}
+func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
+}
+func (m *QueryParamsRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryParamsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo
+
+type QueryParamsResponse struct {
+	Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
+func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryParamsResponse) ProtoMessage()    {}
+func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_991a610b84b5964c, []int{1}
+}
+func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
+}
+func (m *QueryParamsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryParamsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo
+
 type QuerySignerRequest struct {
 	Accounts []string `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"`
 }
@@ -40,7 +113,7 @@ func (m *QuerySignerRequest) Reset()         { *m = QuerySignerRequest{} }
 func (m *QuerySignerRequest) String() string { return proto.CompactTextString(m) }
 func (*QuerySignerRequest) ProtoMessage()    {}
 func (*QuerySignerRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{0}
+	return fileDescriptor_991a610b84b5964c, []int{2}
 }
 func (m *QuerySignerRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -77,7 +150,7 @@ func (m *QuerySignerResponse) Reset()         { *m = QuerySignerResponse{} }
 func (m *QuerySignerResponse) String() string { return proto.CompactTextString(m) }
 func (*QuerySignerResponse) ProtoMessage()    {}
 func (*QuerySignerResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{1}
+	return fileDescriptor_991a610b84b5964c, []int{3}
 }
 func (m *QuerySignerResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -113,7 +186,7 @@ func (m *QueryEpochNumberRequest) Reset()         { *m = QueryEpochNumberRequest
 func (m *QueryEpochNumberRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochNumberRequest) ProtoMessage()    {}
 func (*QueryEpochNumberRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{2}
+	return fileDescriptor_991a610b84b5964c, []int{4}
 }
 func (m *QueryEpochNumberRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -150,7 +223,7 @@ func (m *QueryEpochNumberResponse) Reset()         { *m = QueryEpochNumberRespon
 func (m *QueryEpochNumberResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochNumberResponse) ProtoMessage()    {}
 func (*QueryEpochNumberResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{3}
+	return fileDescriptor_991a610b84b5964c, []int{5}
 }
 func (m *QueryEpochNumberResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -187,7 +260,7 @@ func (m *QueryQuorumCountRequest) Reset()         { *m = QueryQuorumCountRequest
 func (m *QueryQuorumCountRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryQuorumCountRequest) ProtoMessage()    {}
 func (*QueryQuorumCountRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{4}
+	return fileDescriptor_991a610b84b5964c, []int{6}
 }
 func (m *QueryQuorumCountRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -224,7 +297,7 @@ func (m *QueryQuorumCountResponse) Reset()         { *m = QueryQuorumCountRespon
 func (m *QueryQuorumCountResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryQuorumCountResponse) ProtoMessage()    {}
 func (*QueryQuorumCountResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{5}
+	return fileDescriptor_991a610b84b5964c, []int{7}
 }
 func (m *QueryQuorumCountResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -262,7 +335,7 @@ func (m *QueryEpochQuorumRequest) Reset()         { *m = QueryEpochQuorumRequest
 func (m *QueryEpochQuorumRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochQuorumRequest) ProtoMessage()    {}
 func (*QueryEpochQuorumRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{6}
+	return fileDescriptor_991a610b84b5964c, []int{8}
 }
 func (m *QueryEpochQuorumRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -299,7 +372,7 @@ func (m *QueryEpochQuorumResponse) Reset()         { *m = QueryEpochQuorumRespon
 func (m *QueryEpochQuorumResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochQuorumResponse) ProtoMessage()    {}
 func (*QueryEpochQuorumResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{7}
+	return fileDescriptor_991a610b84b5964c, []int{9}
 }
 func (m *QueryEpochQuorumResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -338,7 +411,7 @@ func (m *QueryEpochQuorumRowRequest) Reset()         { *m = QueryEpochQuorumRowR
 func (m *QueryEpochQuorumRowRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochQuorumRowRequest) ProtoMessage()    {}
 func (*QueryEpochQuorumRowRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{8}
+	return fileDescriptor_991a610b84b5964c, []int{10}
 }
 func (m *QueryEpochQuorumRowRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -375,7 +448,7 @@ func (m *QueryEpochQuorumRowResponse) Reset()         { *m = QueryEpochQuorumRow
 func (m *QueryEpochQuorumRowResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryEpochQuorumRowResponse) ProtoMessage()    {}
 func (*QueryEpochQuorumRowResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{9}
+	return fileDescriptor_991a610b84b5964c, []int{11}
 }
 func (m *QueryEpochQuorumRowResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -414,7 +487,7 @@ func (m *QueryAggregatePubkeyG1Request) Reset()         { *m = QueryAggregatePub
 func (m *QueryAggregatePubkeyG1Request) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePubkeyG1Request) ProtoMessage()    {}
 func (*QueryAggregatePubkeyG1Request) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{10}
+	return fileDescriptor_991a610b84b5964c, []int{12}
 }
 func (m *QueryAggregatePubkeyG1Request) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -453,7 +526,7 @@ func (m *QueryAggregatePubkeyG1Response) Reset()         { *m = QueryAggregatePu
 func (m *QueryAggregatePubkeyG1Response) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePubkeyG1Response) ProtoMessage()    {}
 func (*QueryAggregatePubkeyG1Response) Descriptor() ([]byte, []int) {
-	return fileDescriptor_991a610b84b5964c, []int{11}
+	return fileDescriptor_991a610b84b5964c, []int{13}
 }
 func (m *QueryAggregatePubkeyG1Response) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -483,6 +556,8 @@ func (m *QueryAggregatePubkeyG1Response) XXX_DiscardUnknown() {
 var xxx_messageInfo_QueryAggregatePubkeyG1Response proto.InternalMessageInfo
 
 func init() {
+	proto.RegisterType((*QueryParamsRequest)(nil), "zgc.dasigners.v1.QueryParamsRequest")
+	proto.RegisterType((*QueryParamsResponse)(nil), "zgc.dasigners.v1.QueryParamsResponse")
 	proto.RegisterType((*QuerySignerRequest)(nil), "zgc.dasigners.v1.QuerySignerRequest")
 	proto.RegisterType((*QuerySignerResponse)(nil), "zgc.dasigners.v1.QuerySignerResponse")
 	proto.RegisterType((*QueryEpochNumberRequest)(nil), "zgc.dasigners.v1.QueryEpochNumberRequest")
@@ -500,54 +575,57 @@ func init() {
 func init() { proto.RegisterFile("zgc/dasigners/v1/query.proto", fileDescriptor_991a610b84b5964c) }
 
 var fileDescriptor_991a610b84b5964c = []byte{
-	// 737 bytes of a gzipped FileDescriptorProto
+	// 788 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xcb, 0x4e, 0xdb, 0x4a,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x4f, 0xdb, 0x4a,
-	0x18, 0xc7, 0x63, 0x2e, 0x11, 0x0c, 0x70, 0x04, 0x03, 0x3a, 0x24, 0x06, 0x4c, 0x30, 0x70, 0x14,
+	0x14, 0x8d, 0xf9, 0x7a, 0x30, 0xc0, 0x13, 0x0c, 0xe8, 0x91, 0x18, 0x30, 0x60, 0xe0, 0x29, 0x3c,
-	0x8e, 0x48, 0x9c, 0x50, 0x75, 0xd7, 0x2e, 0x4a, 0x55, 0x21, 0xa4, 0xb6, 0x2a, 0xee, 0xaa, 0xdd,
+	0x91, 0x38, 0xe1, 0xa9, 0xbb, 0x76, 0x51, 0xaa, 0x0a, 0x21, 0xb5, 0x15, 0xa4, 0xab, 0x76, 0x13,
-	0x44, 0x63, 0x67, 0x3a, 0xb1, 0x8a, 0x3d, 0x8e, 0x3d, 0x26, 0x84, 0x65, 0xd5, 0x5d, 0x37, 0x95,
+	0x4d, 0x9c, 0xe9, 0xc4, 0x2a, 0xf6, 0x38, 0xf6, 0x98, 0x10, 0x96, 0x55, 0x77, 0xdd, 0x54, 0xea,
-	0xba, 0xe9, 0x03, 0xf4, 0x61, 0x58, 0x22, 0x75, 0xd3, 0x65, 0x0b, 0xdd, 0xf5, 0x25, 0x2a, 0xcf,
+	0xa6, 0x3f, 0xa0, 0x3f, 0x86, 0x25, 0x52, 0x37, 0x5d, 0xb6, 0xa4, 0x3f, 0xa4, 0xf2, 0xcc, 0x24,
-	0x4c, 0x2e, 0xc6, 0x49, 0xc8, 0x82, 0x9d, 0xe7, 0xbb, 0xfe, 0xbe, 0xcf, 0xf3, 0xb7, 0xc1, 0xfa,
+	0x8e, 0xe3, 0x38, 0x64, 0xc1, 0xce, 0x73, 0xef, 0xb9, 0xf7, 0x9c, 0xb9, 0xe3, 0x33, 0x36, 0xd8,
-	0x05, 0xb1, 0x8d, 0x3a, 0x0a, 0x1d, 0xe2, 0xe1, 0x20, 0x34, 0xce, 0xaa, 0x46, 0x33, 0xc2, 0x41,
+	0xb8, 0x26, 0xa6, 0x51, 0x47, 0xbe, 0x45, 0x1c, 0xec, 0xf9, 0xc6, 0x65, 0xd9, 0x68, 0x06, 0xd8,
-	0xbb, 0xec, 0x07, 0x94, 0x51, 0xb8, 0x78, 0x41, 0xec, 0x72, 0xd7, 0x5b, 0x3e, 0xab, 0xaa, 0x79,
+	0x6b, 0x17, 0x5d, 0x8f, 0x32, 0x0a, 0x97, 0xae, 0x89, 0x59, 0xec, 0x65, 0x8b, 0x97, 0x65, 0x35,
-	0x9b, 0x86, 0x2e, 0x0d, 0x6b, 0xdc, 0x6f, 0x88, 0x83, 0x08, 0x56, 0x57, 0x08, 0x25, 0x54, 0xd8,
+	0x67, 0x52, 0xdf, 0xa6, 0x7e, 0x95, 0xe7, 0x0d, 0xb1, 0x10, 0x60, 0x75, 0x95, 0x50, 0x42, 0x45,
-	0xe3, 0x27, 0x69, 0x5d, 0x27, 0x94, 0x92, 0x53, 0x6c, 0x20, 0xdf, 0x31, 0x90, 0xe7, 0x51, 0x86,
+	0x3c, 0x7c, 0x92, 0xd1, 0x0d, 0x42, 0x29, 0xb9, 0xc0, 0x06, 0x72, 0x2d, 0x03, 0x39, 0x0e, 0x65,
-	0x98, 0x43, 0xbd, 0x4e, 0x4e, 0x5e, 0x7a, 0xf9, 0xc9, 0x8a, 0xde, 0x19, 0xc8, 0x93, 0xbd, 0xd5,
+	0x88, 0x59, 0xd4, 0xe9, 0xd6, 0xe4, 0x64, 0x96, 0xaf, 0x6a, 0xc1, 0x3b, 0x03, 0x39, 0x92, 0x5b,
-	0xcd, 0xdb, 0x2e, 0xe6, 0xb8, 0x38, 0x64, 0xc8, 0xf5, 0x65, 0x40, 0x21, 0x85, 0xde, 0x23, 0xe5,
+	0xdd, 0x1a, 0x4c, 0x31, 0xcb, 0xc6, 0x3e, 0x43, 0xb6, 0x2b, 0x01, 0xdb, 0x09, 0xe9, 0x91, 0x52,
-	0x11, 0x7a, 0x05, 0xc0, 0x93, 0x78, 0x9a, 0xd7, 0xdc, 0x6a, 0xe2, 0x66, 0x84, 0x43, 0x06, 0x55,
+	0x81, 0xd0, 0x12, 0x08, 0x82, 0x1d, 0xec, 0x5b, 0x32, 0xaf, 0xaf, 0x02, 0x78, 0x1e, 0xee, 0xf6,
-	0x30, 0x83, 0x6c, 0x9b, 0x46, 0x1e, 0x0b, 0x73, 0x4a, 0x61, 0xb2, 0x38, 0x6b, 0x76, 0xcf, 0xfa,
+	0x0c, 0x79, 0xc8, 0xf6, 0x2b, 0xb8, 0x19, 0x60, 0x9f, 0xe9, 0x27, 0x60, 0x25, 0x16, 0xf5, 0x5d,
-	0x11, 0x58, 0x4e, 0x64, 0x84, 0x3e, 0xf5, 0x42, 0x0c, 0x2b, 0x20, 0x2b, 0x2a, 0xf3, 0x84, 0xb9,
+	0xea, 0xf8, 0x18, 0x96, 0xc0, 0x8c, 0xcb, 0x23, 0x59, 0x65, 0x5b, 0xc9, 0xcf, 0x1f, 0x65, 0x8b,
-	0x83, 0x5c, 0xf9, 0xf6, 0x62, 0xca, 0x32, 0x43, 0xc6, 0xe9, 0x79, 0xb0, 0xca, 0x0b, 0x3d, 0xf3,
+	0x83, 0xc3, 0x29, 0xca, 0x0a, 0x89, 0xd3, 0x4b, 0xb2, 0xfd, 0x6b, 0x8e, 0x90, 0xed, 0xa1, 0x0a,
-	0xa9, 0xdd, 0x78, 0x19, 0xb9, 0x56, 0xb7, 0xbf, 0xfe, 0x18, 0xe4, 0xd2, 0x2e, 0xd9, 0x68, 0x0b,
+	0x66, 0x91, 0x69, 0xd2, 0xc0, 0x61, 0x61, 0xa7, 0xc9, 0xfc, 0x5c, 0xa5, 0xb7, 0xee, 0x51, 0x77,
-	0xcc, 0xe3, 0xd8, 0x5c, 0xf3, 0xb8, 0x3d, 0xa7, 0x14, 0x94, 0xe2, 0x94, 0x39, 0x87, 0x7b, 0xa1,
+	0x2b, 0x22, 0x6a, 0xc1, 0xc2, 0x0b, 0x86, 0x52, 0xcb, 0x0a, 0x89, 0xd3, 0x73, 0x60, 0x8d, 0x37,
-	0xfa, 0x23, 0x59, 0xf9, 0x24, 0xa2, 0x41, 0xe4, 0x3e, 0x8d, 0xb9, 0x3b, 0x93, 0x8d, 0x91, 0xdd,
+	0x7a, 0xee, 0x52, 0xb3, 0xf1, 0x2a, 0xb0, 0x6b, 0x3d, 0x7e, 0xfd, 0x09, 0xc8, 0x26, 0x53, 0x92,
-	0x69, 0x9e, 0xc8, 0xee, 0x35, 0x6f, 0x72, 0x73, 0x8d, 0x6f, 0xa3, 0x93, 0xde, 0xec, 0x85, 0xea,
+	0x68, 0x07, 0x2c, 0xe0, 0x30, 0x5c, 0x75, 0x78, 0x9c, 0xef, 0x74, 0xaa, 0x32, 0x8f, 0x23, 0xa8,
-	0x6f, 0xfa, 0xc7, 0x12, 0x35, 0xc6, 0x6f, 0x0e, 0xd7, 0xc0, 0xac, 0x6c, 0xe0, 0xd4, 0x73, 0x13,
+	0xfe, 0x58, 0x76, 0x3e, 0x0f, 0xa8, 0x17, 0xd8, 0xcf, 0x42, 0xdd, 0xdd, 0x9d, 0x8d, 0x51, 0xdd,
-	0xdc, 0x3f, 0x23, 0x0c, 0xc7, 0x75, 0xfd, 0x79, 0xff, 0x5a, 0x3a, 0xa5, 0x7b, 0xfb, 0x17, 0x71,
+	0x25, 0x8f, 0x55, 0x47, 0xe4, 0x4d, 0x1e, 0xae, 0xf2, 0x69, 0x74, 0xcb, 0x9b, 0x11, 0x54, 0x7f,
-	0xbc, 0xea, 0xc0, 0xfd, 0xcb, 0x0c, 0x19, 0xa7, 0xb7, 0x81, 0x9a, 0xaa, 0x46, 0x5b, 0xf7, 0xc4,
+	0xd3, 0xbf, 0x2d, 0xd1, 0x63, 0x7c, 0x72, 0xb8, 0x0e, 0xe6, 0x24, 0x81, 0x55, 0xcf, 0x4e, 0xf0,
-	0x1a, 0x3b, 0x03, 0xda, 0xaa, 0x39, 0x5e, 0x1d, 0x9f, 0xe7, 0x26, 0x0b, 0x4a, 0x71, 0xc1, 0x9c,
+	0xfc, 0xac, 0x08, 0x9c, 0xd6, 0xf5, 0x17, 0xfd, 0x63, 0xe9, 0xb6, 0x8e, 0xe6, 0x2f, 0x70, 0xe9,
-	0x09, 0x68, 0xeb, 0x38, 0x3e, 0xeb, 0x0f, 0xc1, 0xda, 0xc0, 0xd6, 0x72, 0x96, 0x7f, 0xfb, 0xee,
+	0x47, 0x2f, 0x2b, 0x24, 0x4e, 0x6f, 0x03, 0x35, 0xd1, 0x8d, 0xb6, 0x1e, 0x48, 0x6b, 0x98, 0xf4,
-	0x92, 0x52, 0x9c, 0xed, 0xde, 0x98, 0x8f, 0x0a, 0xd8, 0xe0, 0x79, 0x4f, 0x08, 0x09, 0x30, 0x41,
+	0x68, 0xab, 0x6a, 0x39, 0x75, 0x7c, 0x95, 0x9d, 0xdc, 0x56, 0xf2, 0x8b, 0x95, 0x59, 0x8f, 0xb6,
-	0x0c, 0xbf, 0x8a, 0xac, 0xf7, 0xb8, 0x7d, 0x54, 0xbd, 0x2f, 0xea, 0x6d, 0xb0, 0x20, 0x9d, 0x96,
+	0x4e, 0xc3, 0xb5, 0xfe, 0x08, 0xac, 0x0f, 0xa5, 0x96, 0x7b, 0xf9, 0xa7, 0xef, 0x5d, 0x52, 0xf2,
-	0xc3, 0x5c, 0xe4, 0x73, 0xf2, 0x79, 0x53, 0xbe, 0xf4, 0x43, 0x6e, 0xd3, 0xcf, 0x81, 0x36, 0x8c,
+	0x73, 0xbd, 0x37, 0xe6, 0xa3, 0x02, 0x36, 0x79, 0xdd, 0x53, 0x42, 0x3c, 0x4c, 0x10, 0xc3, 0x67,
-	0x42, 0x0e, 0x50, 0x06, 0xcb, 0xa8, 0xe3, 0xac, 0xf9, 0xdc, 0x5b, 0x23, 0x55, 0x4e, 0x33, 0x6f,
+	0x41, 0xed, 0x3d, 0x6e, 0x9f, 0x94, 0x1f, 0x4a, 0xf5, 0x2e, 0x58, 0x94, 0xc9, 0x9a, 0xc5, 0x6c,
-	0x2e, 0xa1, 0xdb, 0x79, 0x70, 0x05, 0x4c, 0x33, 0xca, 0xd0, 0xa9, 0xe4, 0x11, 0x07, 0xb8, 0x08,
+	0xe4, 0x72, 0xe5, 0x0b, 0x15, 0x79, 0xe8, 0xc7, 0x3c, 0xa6, 0x5f, 0x01, 0x2d, 0x4d, 0x85, 0xdc,
-	0x26, 0x1b, 0x0e, 0xe3, 0x08, 0x53, 0x66, 0xfc, 0x78, 0xf0, 0x27, 0x0b, 0xa6, 0x79, 0x6b, 0xf8,
+	0x40, 0x11, 0xac, 0xa0, 0x6e, 0xb2, 0xea, 0xf2, 0x6c, 0x95, 0x94, 0xb9, 0x9a, 0x85, 0xca, 0x32,
-	0x49, 0x01, 0x73, 0x7d, 0xea, 0x80, 0x7b, 0x83, 0x5e, 0xf7, 0x40, 0x71, 0xa9, 0xff, 0x8f, 0x13,
+	0x1a, 0xac, 0x83, 0xab, 0x60, 0x9a, 0x51, 0x86, 0x2e, 0xa4, 0x1e, 0xb1, 0x80, 0x4b, 0x60, 0xb2,
-	0x2a, 0x06, 0xd1, 0x77, 0x3f, 0x7c, 0xff, 0xfd, 0x65, 0x62, 0x13, 0x6e, 0x18, 0x15, 0x92, 0xfc,
+	0x61, 0x31, 0x2e, 0x61, 0xaa, 0x12, 0x3e, 0x1e, 0x75, 0xfe, 0x02, 0xd3, 0x9c, 0x1a, 0x5e, 0x82,
-	0x90, 0xf0, 0x95, 0x96, 0xc4, 0x9a, 0x39, 0x4d, 0x9f, 0x5c, 0x86, 0xd2, 0xa4, 0x05, 0x39, 0x94,
+	0x19, 0xe1, 0x64, 0xb8, 0x37, 0xec, 0xa0, 0x07, 0x2f, 0x0c, 0x75, 0xff, 0x1e, 0x94, 0x10, 0xae,
-	0x66, 0x80, 0xfa, 0x46, 0xd0, 0x88, 0xf7, 0x53, 0xe2, 0xa2, 0xec, 0xed, 0x46, 0xd4, 0x18, 0xbd,
+	0x6f, 0x7d, 0xf8, 0xfe, 0xfb, 0xcb, 0x44, 0x0e, 0xae, 0x19, 0x25, 0x12, 0xbf, 0x95, 0xc4, 0x7d,
-	0x9b, 0x84, 0x42, 0x47, 0xef, 0x26, 0xa9, 0xb8, 0x3b, 0x77, 0x23, 0x98, 0xe0, 0x57, 0x05, 0xfc,
+	0x01, 0x3f, 0x29, 0x60, 0xbe, 0xcf, 0x95, 0xf0, 0x20, 0xa5, 0x6f, 0xd2, 0xd4, 0xea, 0x7f, 0xe3,
-	0x93, 0xbc, 0xe7, 0x70, 0x7f, 0x8c, 0x2e, 0x5d, 0x25, 0xaa, 0xa5, 0x31, 0xa3, 0x25, 0xd6, 0x1e,
+	0x40, 0xa5, 0x8e, 0x7d, 0xae, 0x63, 0x0b, 0x6e, 0x26, 0x74, 0xf0, 0xa3, 0x2c, 0x88, 0xe3, 0xe5,
-	0xc7, 0xda, 0x86, 0x5b, 0x23, 0xb1, 0x4a, 0x01, 0x6d, 0xc1, 0x6f, 0x0a, 0x58, 0x4a, 0x5d, 0x62,
+	0x6a, 0xfa, 0x6c, 0x9a, 0xaa, 0x26, 0x79, 0x11, 0xa4, 0xaa, 0x19, 0xe2, 0xfa, 0x11, 0x6a, 0xc4,
-	0x68, 0x0c, 0xe9, 0x37, 0x4c, 0x74, 0x6a, 0x65, 0xfc, 0x04, 0xc9, 0xb8, 0xcf, 0x19, 0xff, 0x83,
+	0x7b, 0x51, 0xe0, 0x97, 0x41, 0x34, 0x1b, 0xd1, 0x63, 0xf4, 0x6c, 0x62, 0x37, 0xc3, 0xe8, 0xd9,
-	0x3b, 0x29, 0xc6, 0xae, 0x36, 0x4a, 0x42, 0x36, 0x25, 0x52, 0x85, 0x67, 0x20, 0x2b, 0x7e, 0x1d,
+	0xc4, 0x9d, 0x7e, 0xef, 0x6c, 0x84, 0x26, 0xf8, 0x55, 0x01, 0x7f, 0xc7, 0xfd, 0x05, 0x0f, 0xc7,
-	0x70, 0x67, 0x48, 0xa7, 0xc4, 0xdf, 0x4b, 0xdd, 0xbd, 0x23, 0x4a, 0x42, 0x6c, 0x72, 0x88, 0x3c,
+	0x60, 0xe9, 0xdd, 0x00, 0x6a, 0x61, 0x4c, 0xb4, 0x94, 0x75, 0xc0, 0x65, 0xed, 0xc2, 0x9d, 0x91,
-	0x5c, 0x4d, 0x41, 0x88, 0xc7, 0xc3, 0x17, 0x97, 0xbf, 0xb4, 0xcc, 0xe5, 0xb5, 0xa6, 0x5c, 0x5d,
+	0xb2, 0x0a, 0x1e, 0x6d, 0xc1, 0x6f, 0x0a, 0x58, 0x4e, 0x98, 0x07, 0x1a, 0x29, 0x7c, 0x69, 0x66,
-	0x6b, 0xca, 0xcf, 0x6b, 0x4d, 0xf9, 0x7c, 0xa3, 0x65, 0xae, 0x6e, 0xb4, 0xcc, 0x8f, 0x1b, 0x2d,
+	0x57, 0x4b, 0xe3, 0x17, 0x48, 0x8d, 0x87, 0x5c, 0xe3, 0xbf, 0x70, 0x2f, 0xa1, 0xb1, 0xe7, 0xc9,
-	0xf3, 0xd6, 0x20, 0x0e, 0x6b, 0x44, 0x56, 0xd9, 0xa6, 0xae, 0x51, 0x21, 0xa7, 0xc8, 0x0a, 0x8d,
+	0x82, 0xb0, 0x6b, 0x81, 0x94, 0x43, 0x8f, 0x89, 0x4f, 0x56, 0xaa, 0xc7, 0x62, 0x5f, 0xcd, 0x54,
-	0x0a, 0x29, 0xd9, 0x0d, 0xe4, 0x78, 0xc6, 0x79, 0xb2, 0x1e, 0x6b, 0xfb, 0x38, 0xb4, 0xb2, 0xfc,
+	0x8f, 0xc5, 0xbf, 0x94, 0x23, 0x3c, 0x26, 0x1e, 0x8f, 0x5f, 0xde, 0xfc, 0xd2, 0x32, 0x37, 0x77,
-	0x8f, 0xfb, 0xe0, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x50, 0x33, 0x8a, 0x50, 0x08, 0x00,
+	0x9a, 0x72, 0x7b, 0xa7, 0x29, 0x3f, 0xef, 0x34, 0xe5, 0x73, 0x47, 0xcb, 0xdc, 0x76, 0xb4, 0xcc,
-	0x00,
+	0x8f, 0x8e, 0x96, 0x79, 0x6b, 0x10, 0x8b, 0x35, 0x82, 0x5a, 0xd1, 0xa4, 0xb6, 0x51, 0x22, 0x17,
+	0xa8, 0xe6, 0x1b, 0x25, 0x52, 0x30, 0x1b, 0xc8, 0x72, 0x8c, 0xab, 0x78, 0x3f, 0xd6, 0x76, 0xb1,
+	0x5f, 0x9b, 0xe1, 0x3f, 0x12, 0xff, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x6e, 0x10, 0xbe,
+	0x47, 0x09, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -562,6 +640,7 @@ const _ = grpc.SupportPackageIsVersion4
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type QueryClient interface {
+	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
 	EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error)
 	QuorumCount(ctx context.Context, in *QueryQuorumCountRequest, opts ...grpc.CallOption) (*QueryQuorumCountResponse, error)
 	EpochQuorum(ctx context.Context, in *QueryEpochQuorumRequest, opts ...grpc.CallOption) (*QueryEpochQuorumResponse, error)
@@ -578,6 +657,15 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient {
 	return &queryClient{cc}
 }
 
+func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
+	out := new(QueryParamsResponse)
+	err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/Params", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) EpochNumber(ctx context.Context, in *QueryEpochNumberRequest, opts ...grpc.CallOption) (*QueryEpochNumberResponse, error) {
 	out := new(QueryEpochNumberResponse)
 	err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Query/EpochNumber", in, out, opts...)
@@ -634,6 +722,7 @@ func (c *queryClient) Signer(ctx context.Context, in *QuerySignerRequest, opts .
 
 // QueryServer is the server API for Query service.
 type QueryServer interface {
+	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
 	EpochNumber(context.Context, *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error)
 	QuorumCount(context.Context, *QueryQuorumCountRequest) (*QueryQuorumCountResponse, error)
 	EpochQuorum(context.Context, *QueryEpochQuorumRequest) (*QueryEpochQuorumResponse, error)
@@ -646,6 +735,9 @@ type QueryServer interface {
 type UnimplementedQueryServer struct {
 }
 
+func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
 func (*UnimplementedQueryServer) EpochNumber(ctx context.Context, req *QueryEpochNumberRequest) (*QueryEpochNumberResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method EpochNumber not implemented")
 }
@@ -669,6 +761,24 @@ func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
 }
 
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryParamsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Params(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/zgc.dasigners.v1.Query/Params",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_EpochNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryEpochNumberRequest)
 	if err := dec(in); err != nil {
@@ -781,6 +891,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "zgc.dasigners.v1.Query",
 	HandlerType: (*QueryServer)(nil),
 	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Params",
+			Handler:    _Query_Params_Handler,
+		},
 		{
 			MethodName: "EpochNumber",
 			Handler:    _Query_EpochNumber_Handler,
@@ -810,6 +924,64 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 	Metadata: "zgc/dasigners/v1/query.proto",
 }
 
+func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Params != nil {
+		{
+			size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *QuerySignerRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1213,6 +1385,28 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
+func (m *QueryParamsRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *QueryParamsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Params != nil {
+		l = m.Params.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
 func (m *QuerySignerRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1391,6 +1585,142 @@ func sovQuery(x uint64) (n int) {
 func sozQuery(x uint64) (n int) {
 	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
+func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowQuery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Params == nil {
+				m.Params = &Params{}
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *QuerySignerRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

x/dasigners/v1/types/query.pb.gw.go

@@ -33,6 +33,24 @@ var _ = utilities.NewDoubleArray
 var _ = descriptor.ForMessage
 var _ = metadata.Join
 
+func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryParamsRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryParamsRequest
+	var metadata runtime.ServerMetadata
+
+	msg, err := server.Params(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Query_EpochNumber_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryEpochNumberRequest
 	var metadata runtime.ServerMetadata
@@ -237,6 +255,29 @@ func local_request_Query_Signer_0(ctx context.Context, marshaler runtime.Marshal
 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
 func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
 
+	mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_EpochNumber_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -416,6 +457,26 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc
 // "QueryClient" to call the correct interceptors.
 func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
 
+	mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("GET", pattern_Query_EpochNumber_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -540,6 +601,8 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 }
 
 var (
+	pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "params"}, "", runtime.AssumeColonVerbOpt(true)))
+
 	pattern_Query_EpochNumber_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "epoch-number"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_QuorumCount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"0g", "dasigners", "v1", "quorum-count"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -554,6 +617,8 @@ var (
 )
 
 var (
+	forward_Query_Params_0 = runtime.ForwardResponseMessage
+
 	forward_Query_EpochNumber_0 = runtime.ForwardResponseMessage
 
 	forward_Query_QuorumCount_0 = runtime.ForwardResponseMessage

x/dasigners/v1/types/tx.pb.go

@@ -30,6 +30,80 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
+type MsgChangeParams struct {
+	Authority string  `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
+	Params    *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"`
+}
+
+func (m *MsgChangeParams) Reset()         { *m = MsgChangeParams{} }
+func (m *MsgChangeParams) String() string { return proto.CompactTextString(m) }
+func (*MsgChangeParams) ProtoMessage()    {}
+func (*MsgChangeParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{0}
+}
+func (m *MsgChangeParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgChangeParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgChangeParams.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgChangeParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgChangeParams.Merge(m, src)
+}
+func (m *MsgChangeParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgChangeParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgChangeParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgChangeParams proto.InternalMessageInfo
+
+type MsgChangeParamsResponse struct {
+}
+
+func (m *MsgChangeParamsResponse) Reset()         { *m = MsgChangeParamsResponse{} }
+func (m *MsgChangeParamsResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgChangeParamsResponse) ProtoMessage()    {}
+func (*MsgChangeParamsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{1}
+}
+func (m *MsgChangeParamsResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgChangeParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgChangeParamsResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgChangeParamsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgChangeParamsResponse.Merge(m, src)
+}
+func (m *MsgChangeParamsResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgChangeParamsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgChangeParamsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgChangeParamsResponse proto.InternalMessageInfo
+
 type MsgRegisterSigner struct {
 	Signer    *Signer `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
 	Signature []byte  `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
@@ -39,7 +113,7 @@ func (m *MsgRegisterSigner) Reset()         { *m = MsgRegisterSigner{} }
 func (m *MsgRegisterSigner) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterSigner) ProtoMessage()    {}
 func (*MsgRegisterSigner) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{0}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{2}
 }
 func (m *MsgRegisterSigner) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -75,7 +149,7 @@ func (m *MsgRegisterSignerResponse) Reset()         { *m = MsgRegisterSignerResp
 func (m *MsgRegisterSignerResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterSignerResponse) ProtoMessage()    {}
 func (*MsgRegisterSignerResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{1}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{3}
 }
 func (m *MsgRegisterSignerResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -113,7 +187,7 @@ func (m *MsgUpdateSocket) Reset()         { *m = MsgUpdateSocket{} }
 func (m *MsgUpdateSocket) String() string { return proto.CompactTextString(m) }
 func (*MsgUpdateSocket) ProtoMessage()    {}
 func (*MsgUpdateSocket) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{2}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{4}
 }
 func (m *MsgUpdateSocket) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -149,7 +223,7 @@ func (m *MsgUpdateSocketResponse) Reset()         { *m = MsgUpdateSocketResponse
 func (m *MsgUpdateSocketResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgUpdateSocketResponse) ProtoMessage()    {}
 func (*MsgUpdateSocketResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{3}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{5}
 }
 func (m *MsgUpdateSocketResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -187,7 +261,7 @@ func (m *MsgRegisterNextEpoch) Reset()         { *m = MsgRegisterNextEpoch{} }
 func (m *MsgRegisterNextEpoch) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterNextEpoch) ProtoMessage()    {}
 func (*MsgRegisterNextEpoch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{4}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{6}
 }
 func (m *MsgRegisterNextEpoch) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -223,7 +297,7 @@ func (m *MsgRegisterNextEpochResponse) Reset()         { *m = MsgRegisterNextEpo
 func (m *MsgRegisterNextEpochResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgRegisterNextEpochResponse) ProtoMessage()    {}
 func (*MsgRegisterNextEpochResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_8bfa0cc0bd2f98e0, []int{5}
+	return fileDescriptor_8bfa0cc0bd2f98e0, []int{7}
 }
 func (m *MsgRegisterNextEpochResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -253,6 +327,8 @@ func (m *MsgRegisterNextEpochResponse) XXX_DiscardUnknown() {
 var xxx_messageInfo_MsgRegisterNextEpochResponse proto.InternalMessageInfo
 
 func init() {
+	proto.RegisterType((*MsgChangeParams)(nil), "zgc.dasigners.v1.MsgChangeParams")
+	proto.RegisterType((*MsgChangeParamsResponse)(nil), "zgc.dasigners.v1.MsgChangeParamsResponse")
 	proto.RegisterType((*MsgRegisterSigner)(nil), "zgc.dasigners.v1.MsgRegisterSigner")
 	proto.RegisterType((*MsgRegisterSignerResponse)(nil), "zgc.dasigners.v1.MsgRegisterSignerResponse")
 	proto.RegisterType((*MsgUpdateSocket)(nil), "zgc.dasigners.v1.MsgUpdateSocket")
@@ -264,32 +340,37 @@ func init() {
 func init() { proto.RegisterFile("zgc/dasigners/v1/tx.proto", fileDescriptor_8bfa0cc0bd2f98e0) }
 
 var fileDescriptor_8bfa0cc0bd2f98e0 = []byte{
-	// 399 bytes of a gzipped FileDescriptorProto
+	// 466 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0xae, 0xd2, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xc1, 0x6e, 0xd3, 0x40,
-	0x14, 0x87, 0x5b, 0x4c, 0x30, 0x8c, 0x44, 0xa5, 0x21, 0xda, 0x56, 0x32, 0xc1, 0x9a, 0x18, 0x8c,
+	0x10, 0x40, 0x63, 0x2a, 0x05, 0x65, 0x88, 0x80, 0x5a, 0x15, 0xc4, 0xa6, 0x5a, 0x85, 0x20, 0xa1,
-	0xb1, 0x03, 0xf8, 0x06, 0x1a, 0x97, 0x65, 0x51, 0xe2, 0xc6, 0x98, 0x98, 0x76, 0x18, 0x87, 0x06,
+	0x22, 0x84, 0x37, 0x2d, 0x7f, 0x40, 0xc5, 0x31, 0x15, 0x72, 0xc5, 0x05, 0x55, 0x42, 0xeb, 0xed,
-	0xe8, 0x34, 0x9d, 0x29, 0x01, 0x9e, 0xc2, 0x87, 0xf1, 0x21, 0x58, 0xb2, 0x74, 0xe9, 0x85, 0x17,
+	0x32, 0xb6, 0xda, 0x78, 0x2d, 0xef, 0xba, 0x4a, 0xfa, 0x15, 0x88, 0xaf, 0xea, 0xb1, 0x47, 0x8e,
-	0xb9, 0x61, 0xfa, 0x07, 0x6e, 0x4b, 0xb8, 0xec, 0xe6, 0xcc, 0xf9, 0x7a, 0xbe, 0xd3, 0x5f, 0x5a,
+	0x90, 0xfc, 0x08, 0xca, 0xda, 0x71, 0x12, 0xdb, 0xa4, 0xb9, 0xed, 0xcc, 0xbc, 0xcc, 0x9b, 0xc9,
-	0x60, 0x6c, 0x28, 0x46, 0x13, 0x8f, 0x07, 0x34, 0x24, 0x31, 0x47, 0xcb, 0x01, 0x12, 0x2b, 0x3b,
+	0x28, 0x01, 0xe7, 0x16, 0x39, 0xbd, 0x64, 0x2a, 0xc2, 0x58, 0xa4, 0x8a, 0xde, 0x1c, 0x53, 0x3d,
-	0x8a, 0x99, 0x60, 0xda, 0xcb, 0x0d, 0xc5, 0x76, 0xd1, 0xb2, 0x97, 0x03, 0xd3, 0xc0, 0x8c, 0x2f,
+	0xf1, 0x92, 0x54, 0x6a, 0x69, 0x3f, 0xbf, 0x45, 0xee, 0x95, 0x25, 0xef, 0xe6, 0xd8, 0x75, 0xb8,
-	0x18, 0xff, 0x25, 0xfb, 0x28, 0x2d, 0x52, 0xd8, 0x6c, 0x53, 0x46, 0x59, 0x7a, 0x7f, 0x3c, 0x65,
+	0x54, 0x63, 0xa9, 0xbe, 0x9b, 0x3a, 0xcd, 0x83, 0x1c, 0x76, 0x0f, 0x50, 0xa2, 0xcc, 0xf3, 0x8b,
-	0xb7, 0x06, 0x65, 0x8c, 0xce, 0x09, 0x92, 0x95, 0x9f, 0xfc, 0x46, 0x5e, 0xb8, 0xce, 0x5a, 0xdd,
+	0x57, 0x91, 0x75, 0x50, 0x4a, 0xbc, 0x16, 0xd4, 0x44, 0x41, 0xf6, 0x83, 0xb2, 0x78, 0x5a, 0x94,
-	0x8a, 0xf8, 0xa4, 0x92, 0x84, 0x85, 0x41, 0xcb, 0xe1, 0xd4, 0x25, 0x34, 0xe0, 0x82, 0xc4, 0x63,
+	0xfa, 0x35, 0xf1, 0x4a, 0x95, 0x13, 0xa4, 0x46, 0xa0, 0x88, 0x85, 0x8a, 0x8a, 0xfa, 0x80, 0xc1,
-	0xd9, 0xd3, 0xfa, 0xa0, 0x9e, 0x52, 0xba, 0xda, 0x55, 0x7b, 0xcf, 0x86, 0xba, 0x5d, 0xde, 0xd2,
+	0xb3, 0x91, 0xc2, 0xd3, 0x90, 0xc5, 0x28, 0xbe, 0xb0, 0x94, 0x8d, 0x95, 0x7d, 0x08, 0x1d, 0x96,
-	0x4e, 0x49, 0x37, 0xe3, 0xb4, 0x0e, 0x68, 0x1c, 0x4f, 0x9e, 0x48, 0x62, 0xa2, 0xd7, 0xba, 0x6a,
+	0xe9, 0x50, 0xa6, 0x91, 0x9e, 0xf6, 0xac, 0xbe, 0x75, 0xd4, 0xf1, 0x57, 0x09, 0x7b, 0x08, 0xed,
-	0xaf, 0xe9, 0x9e, 0x2e, 0xac, 0x37, 0xc0, 0xa8, 0x48, 0x5c, 0xc2, 0x23, 0x16, 0x72, 0x62, 0x7d,
+	0xc4, 0x70, 0xbd, 0x47, 0x7d, 0xeb, 0xe8, 0xc9, 0x49, 0xcf, 0xab, 0x6e, 0xe8, 0xe5, 0x7d, 0xfc,
-	0x05, 0x2f, 0x1c, 0x4e, 0xbf, 0x47, 0x13, 0x4f, 0x90, 0x31, 0xc3, 0x33, 0x22, 0x34, 0x1d, 0x3c,
+	0x82, 0x1b, 0x38, 0xf0, 0xb2, 0xa2, 0xf0, 0x85, 0x4a, 0x64, 0xac, 0xc4, 0x80, 0xc3, 0xfe, 0x48,
-	0xf5, 0x30, 0x66, 0x49, 0x28, 0xe4, 0x02, 0x0d, 0x37, 0x2f, 0xb5, 0x57, 0xa0, 0xce, 0x25, 0x23,
+	0xa1, 0x2f, 0x30, 0x52, 0x5a, 0xa4, 0xe7, 0xa6, 0xc5, 0xc2, 0x90, 0x37, 0x33, 0xf2, 0x46, 0x43,
-	0x25, 0x0d, 0x37, 0xab, 0x2c, 0x03, 0xbc, 0x2e, 0x0d, 0x29, 0xe6, 0x8f, 0x40, 0xfb, 0x4c, 0x3e,
+	0x4e, 0xfa, 0x05, 0xb7, 0x98, 0x78, 0xf1, 0x62, 0x3a, 0x4b, 0x85, 0x19, 0xab, 0xeb, 0xaf, 0x12,
-	0x22, 0x2b, 0xf1, 0x2d, 0x62, 0x78, 0x7a, 0x45, 0x72, 0xfd, 0x65, 0x20, 0xe8, 0x5c, 0x9a, 0x97,
+	0x83, 0x57, 0xe0, 0xd4, 0x24, 0xe5, 0x04, 0xa7, 0x66, 0xff, 0xaf, 0xc9, 0x25, 0xd3, 0xe2, 0x5c,
-	0xfb, 0x86, 0x7f, 0x6b, 0xe0, 0x89, 0xc3, 0xa9, 0xe6, 0x83, 0xe7, 0xa5, 0x58, 0xdf, 0x55, 0x63,
+	0xf2, 0x2b, 0xa1, 0xed, 0x1e, 0x3c, 0x66, 0x9c, 0xcb, 0x2c, 0xd6, 0xc5, 0xf6, 0xcb, 0xd0, 0x7e,
-	0xac, 0xc4, 0x62, 0x7e, 0xbc, 0x01, 0xca, 0x5d, 0xda, 0x4f, 0xd0, 0x7c, 0x10, 0xdc, 0xdb, 0x8b,
+	0x01, 0x6d, 0x65, 0x18, 0x23, 0xe9, 0xf8, 0x45, 0x54, 0x6c, 0xb8, 0xde, 0xa4, 0xec, 0x7f, 0x06,
-	0x0f, 0x9f, 0x23, 0xe6, 0x87, 0x47, 0x91, 0x62, 0xfa, 0x0c, 0xb4, 0xaa, 0xb1, 0xbd, 0xbf, 0xba,
+	0x07, 0x6b, 0xf2, 0x33, 0x31, 0xd1, 0x9f, 0x13, 0xc9, 0xc3, 0x2d, 0x92, 0xed, 0xcb, 0x10, 0x38,
-	0x5f, 0xc1, 0x99, 0xf6, 0x6d, 0x5c, 0x2e, 0xfb, 0xe2, 0x6c, 0xef, 0xa0, 0xb2, 0xdd, 0x43, 0x75,
+	0x6c, 0xea, 0xb7, 0xf4, 0x9d, 0xfc, 0xda, 0x83, 0xbd, 0x91, 0x42, 0xfb, 0x02, 0xba, 0x1b, 0x47,
-	0xb7, 0x87, 0xea, 0xff, 0x3d, 0x54, 0xff, 0x1c, 0xa0, 0xb2, 0x3b, 0x40, 0xe5, 0xdf, 0x01, 0x2a,
+	0x7d, 0x5d, 0xff, 0x12, 0x2b, 0x47, 0x71, 0xdf, 0x3d, 0x88, 0x2c, 0x2d, 0x76, 0x00, 0x4f, 0x2b,
-	0x3f, 0x10, 0x0d, 0xc4, 0x34, 0xf1, 0x6d, 0xcc, 0x16, 0xa8, 0x4f, 0xe7, 0x9e, 0xcf, 0x51, 0x9f,
+	0x47, 0x7b, 0xd3, 0xf8, 0xe1, 0x4d, 0xc8, 0x7d, 0xbf, 0x03, 0x54, 0x3a, 0x2e, 0xa0, 0xbb, 0x71,
-	0x7e, 0xc2, 0x53, 0x2f, 0x08, 0xd1, 0xaa, 0xf4, 0x6b, 0xad, 0x23, 0xc2, 0xfd, 0xba, 0xfc, 0xbc,
+	0x96, 0xe6, 0x0d, 0xd6, 0x91, 0xff, 0x6c, 0xd0, 0x74, 0x17, 0xfb, 0x0a, 0xf6, 0xeb, 0x47, 0x79,
-	0x3f, 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x5a, 0xce, 0x9a, 0x7b, 0x03, 0x00, 0x00,
+	0xbb, 0x75, 0xbe, 0x92, 0x73, 0xbd, 0xdd, 0xb8, 0xa5, 0xec, 0xd3, 0xe8, 0xee, 0x2f, 0x69, 0xdd,
+	0xcd, 0x88, 0x75, 0x3f, 0x23, 0xd6, 0x9f, 0x19, 0xb1, 0x7e, 0xce, 0x49, 0xeb, 0x7e, 0x4e, 0x5a,
+	0xbf, 0xe7, 0xa4, 0xf5, 0x8d, 0x62, 0xa4, 0xc3, 0x2c, 0xf0, 0xb8, 0x1c, 0xd3, 0x21, 0x5e, 0xb3,
+	0x40, 0xd1, 0x21, 0x7e, 0xe0, 0x21, 0x8b, 0x62, 0x3a, 0xa9, 0xfc, 0xad, 0x4c, 0x13, 0xa1, 0x82,
+	0xb6, 0xf9, 0xe9, 0x7e, 0xfc, 0x17, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x94, 0x58, 0x6f, 0x77, 0x04,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -304,6 +385,7 @@ const _ = grpc.SupportPackageIsVersion4
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type MsgClient interface {
+	ChangeParams(ctx context.Context, in *MsgChangeParams, opts ...grpc.CallOption) (*MsgChangeParamsResponse, error)
 	RegisterSigner(ctx context.Context, in *MsgRegisterSigner, opts ...grpc.CallOption) (*MsgRegisterSignerResponse, error)
 	UpdateSocket(ctx context.Context, in *MsgUpdateSocket, opts ...grpc.CallOption) (*MsgUpdateSocketResponse, error)
 	RegisterNextEpoch(ctx context.Context, in *MsgRegisterNextEpoch, opts ...grpc.CallOption) (*MsgRegisterNextEpochResponse, error)
@@ -317,6 +399,15 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient {
 	return &msgClient{cc}
 }
 
+func (c *msgClient) ChangeParams(ctx context.Context, in *MsgChangeParams, opts ...grpc.CallOption) (*MsgChangeParamsResponse, error) {
+	out := new(MsgChangeParamsResponse)
+	err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Msg/ChangeParams", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) RegisterSigner(ctx context.Context, in *MsgRegisterSigner, opts ...grpc.CallOption) (*MsgRegisterSignerResponse, error) {
 	out := new(MsgRegisterSignerResponse)
 	err := c.cc.Invoke(ctx, "/zgc.dasigners.v1.Msg/RegisterSigner", in, out, opts...)
@@ -346,6 +437,7 @@ func (c *msgClient) RegisterNextEpoch(ctx context.Context, in *MsgRegisterNextEp
 
 // MsgServer is the server API for Msg service.
 type MsgServer interface {
+	ChangeParams(context.Context, *MsgChangeParams) (*MsgChangeParamsResponse, error)
 	RegisterSigner(context.Context, *MsgRegisterSigner) (*MsgRegisterSignerResponse, error)
 	UpdateSocket(context.Context, *MsgUpdateSocket) (*MsgUpdateSocketResponse, error)
 	RegisterNextEpoch(context.Context, *MsgRegisterNextEpoch) (*MsgRegisterNextEpochResponse, error)
@@ -355,6 +447,9 @@ type MsgServer interface {
 type UnimplementedMsgServer struct {
 }
 
+func (*UnimplementedMsgServer) ChangeParams(ctx context.Context, req *MsgChangeParams) (*MsgChangeParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ChangeParams not implemented")
+}
 func (*UnimplementedMsgServer) RegisterSigner(ctx context.Context, req *MsgRegisterSigner) (*MsgRegisterSignerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RegisterSigner not implemented")
 }
@@ -369,6 +464,24 @@ func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
 }
 
+func _Msg_ChangeParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgChangeParams)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).ChangeParams(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/zgc.dasigners.v1.Msg/ChangeParams",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).ChangeParams(ctx, req.(*MsgChangeParams))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_RegisterSigner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgRegisterSigner)
 	if err := dec(in); err != nil {
@@ -427,6 +540,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "zgc.dasigners.v1.Msg",
 	HandlerType: (*MsgServer)(nil),
 	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ChangeParams",
+			Handler:    _Msg_ChangeParams_Handler,
+		},
 		{
 			MethodName: "RegisterSigner",
 			Handler:    _Msg_RegisterSigner_Handler,
@@ -444,6 +561,71 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 	Metadata: "zgc/dasigners/v1/tx.proto",
 }
 
+func (m *MsgChangeParams) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgChangeParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgChangeParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Params != nil {
+		{
+			size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTx(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Authority) > 0 {
+		i -= len(m.Authority)
+		copy(dAtA[i:], m.Authority)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.Authority)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgChangeParamsResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgChangeParamsResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgChangeParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func (m *MsgRegisterSigner) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -640,6 +822,32 @@ func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
+func (m *MsgChangeParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Authority)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	if m.Params != nil {
+		l = m.Params.Size()
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgChangeParamsResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func (m *MsgRegisterSigner) Size() (n int) {
 	if m == nil {
 		return 0
@@ -724,6 +932,174 @@ func sovTx(x uint64) (n int) {
 func sozTx(x uint64) (n int) {
 	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
+func (m *MsgChangeParams) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgChangeParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgChangeParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Authority = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Params == nil {
+				m.Params = &Params{}
+			}
+			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgChangeParamsResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgChangeParamsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgChangeParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgRegisterSigner) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0