types: migrate params to protobuf (#4962)

CHANGELOG_PENDING.md

@@ -17,6 +17,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
   - [types] \#4582 Vote: `ValidatorIndex` & `Round` are now int32
   - [types] \#4582 Proposal: `POLRound` & `Round` are now int32
   - [types] \#4582 Block: `Round` is now int32
+  - [types] \#4962 `ConsensusParams`, `BlockParams`, `EvidenceParams`, `ValidatorParams` & `HashedParams` are now Protobuf types
   - [consensus] \#4582 RoundState: `Round`, `LockedRound` & `CommitRound` are now int32
   - [consensus] \#4582 HeightVoteSet: `round` is now int32
   - [privval] \#4582 `round` in private_validator_state.json is no longer a string in json it is now a number.

abci/types/types.pb.go

@@ -9,7 +9,6 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	_ "github.com/golang/protobuf/ptypes/duration"
 	_ "github.com/golang/protobuf/ptypes/timestamp"
 	merkle "github.com/tendermint/tendermint/crypto/merkle"
 	types "github.com/tendermint/tendermint/proto/types"
@@ -2417,9 +2416,9 @@ func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string {
 // ConsensusParams contains all consensus-relevant parameters
 // that can be adjusted by the abci app
 type ConsensusParams struct {
-	Block     *BlockParams     `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
-	Evidence  *EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
-	Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
+	Block     *BlockParams           `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
+	Evidence  *types.EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
+	Validator *types.ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
 }
 
 func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
@@ -2462,14 +2461,14 @@ func (m *ConsensusParams) GetBlock() *BlockParams {
 	return nil
 }
 
-func (m *ConsensusParams) GetEvidence() *EvidenceParams {
+func (m *ConsensusParams) GetEvidence() *types.EvidenceParams {
 	if m != nil {
 		return m.Evidence
 	}
 	return nil
 }
 
-func (m *ConsensusParams) GetValidator() *ValidatorParams {
+func (m *ConsensusParams) GetValidator() *types.ValidatorParams {
 	if m != nil {
 		return m.Validator
 	}
@@ -2531,112 +2530,6 @@ func (m *BlockParams) GetMaxGas() int64 {
 	return 0
 }
 
-type EvidenceParams struct {
-	// Note: must be greater than 0
-	MaxAgeNumBlocks int64         `protobuf:"varint,1,opt,name=max_age_num_blocks,json=maxAgeNumBlocks,proto3" json:"max_age_num_blocks,omitempty"`
-	MaxAgeDuration  time.Duration `protobuf:"bytes,2,opt,name=max_age_duration,json=maxAgeDuration,proto3,stdduration" json:"max_age_duration"`
-	MaxNum          uint32        `protobuf:"varint,3,opt,name=max_num,json=maxNum,proto3" json:"max_num,omitempty"`
-}
-
-func (m *EvidenceParams) Reset()         { *m = EvidenceParams{} }
-func (m *EvidenceParams) String() string { return proto.CompactTextString(m) }
-func (*EvidenceParams) ProtoMessage()    {}
-func (*EvidenceParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{35}
-}
-func (m *EvidenceParams) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *EvidenceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_EvidenceParams.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 *EvidenceParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EvidenceParams.Merge(m, src)
-}
-func (m *EvidenceParams) XXX_Size() int {
-	return m.Size()
-}
-func (m *EvidenceParams) XXX_DiscardUnknown() {
-	xxx_messageInfo_EvidenceParams.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EvidenceParams proto.InternalMessageInfo
-
-func (m *EvidenceParams) GetMaxAgeNumBlocks() int64 {
-	if m != nil {
-		return m.MaxAgeNumBlocks
-	}
-	return 0
-}
-
-func (m *EvidenceParams) GetMaxAgeDuration() time.Duration {
-	if m != nil {
-		return m.MaxAgeDuration
-	}
-	return 0
-}
-
-func (m *EvidenceParams) GetMaxNum() uint32 {
-	if m != nil {
-		return m.MaxNum
-	}
-	return 0
-}
-
-// ValidatorParams contains limits on validators.
-type ValidatorParams struct {
-	PubKeyTypes []string `protobuf:"bytes,1,rep,name=pub_key_types,json=pubKeyTypes,proto3" json:"pub_key_types,omitempty"`
-}
-
-func (m *ValidatorParams) Reset()         { *m = ValidatorParams{} }
-func (m *ValidatorParams) String() string { return proto.CompactTextString(m) }
-func (*ValidatorParams) ProtoMessage()    {}
-func (*ValidatorParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{36}
-}
-func (m *ValidatorParams) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ValidatorParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ValidatorParams.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 *ValidatorParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ValidatorParams.Merge(m, src)
-}
-func (m *ValidatorParams) XXX_Size() int {
-	return m.Size()
-}
-func (m *ValidatorParams) XXX_DiscardUnknown() {
-	xxx_messageInfo_ValidatorParams.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ValidatorParams proto.InternalMessageInfo
-
-func (m *ValidatorParams) GetPubKeyTypes() []string {
-	if m != nil {
-		return m.PubKeyTypes
-	}
-	return nil
-}
-
 type LastCommitInfo struct {
 	Round int32      `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"`
 	Votes []VoteInfo `protobuf:"bytes,2,rep,name=votes,proto3" json:"votes"`
@@ -2646,7 +2539,7 @@ func (m *LastCommitInfo) Reset()         { *m = LastCommitInfo{} }
 func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) }
 func (*LastCommitInfo) ProtoMessage()    {}
 func (*LastCommitInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{37}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{35}
 }
 func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2700,7 +2593,7 @@ func (m *EventAttribute) Reset()         { *m = EventAttribute{} }
 func (m *EventAttribute) String() string { return proto.CompactTextString(m) }
 func (*EventAttribute) ProtoMessage()    {}
 func (*EventAttribute) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{38}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{36}
 }
 func (m *EventAttribute) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2759,7 +2652,7 @@ func (m *Event) Reset()         { *m = Event{} }
 func (m *Event) String() string { return proto.CompactTextString(m) }
 func (*Event) ProtoMessage()    {}
 func (*Event) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{39}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{37}
 }
 func (m *Event) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2816,7 +2709,7 @@ func (m *TxResult) Reset()         { *m = TxResult{} }
 func (m *TxResult) String() string { return proto.CompactTextString(m) }
 func (*TxResult) ProtoMessage()    {}
 func (*TxResult) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{40}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{38}
 }
 func (m *TxResult) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2882,7 +2775,7 @@ func (m *BlockID) Reset()         { *m = BlockID{} }
 func (m *BlockID) String() string { return proto.CompactTextString(m) }
 func (*BlockID) ProtoMessage()    {}
 func (*BlockID) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{41}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{39}
 }
 func (m *BlockID) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2934,7 +2827,7 @@ func (m *PartSetHeader) Reset()         { *m = PartSetHeader{} }
 func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
 func (*PartSetHeader) ProtoMessage()    {}
 func (*PartSetHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{42}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{40}
 }
 func (m *PartSetHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2988,7 +2881,7 @@ func (m *Validator) Reset()         { *m = Validator{} }
 func (m *Validator) String() string { return proto.CompactTextString(m) }
 func (*Validator) ProtoMessage()    {}
 func (*Validator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{43}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{41}
 }
 func (m *Validator) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3041,7 +2934,7 @@ func (m *ValidatorUpdate) Reset()         { *m = ValidatorUpdate{} }
 func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) }
 func (*ValidatorUpdate) ProtoMessage()    {}
 func (*ValidatorUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{44}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{42}
 }
 func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3094,7 +2987,7 @@ func (m *VoteInfo) Reset()         { *m = VoteInfo{} }
 func (m *VoteInfo) String() string { return proto.CompactTextString(m) }
 func (*VoteInfo) ProtoMessage()    {}
 func (*VoteInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{45}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{43}
 }
 func (m *VoteInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3146,7 +3039,7 @@ func (m *PubKey) Reset()         { *m = PubKey{} }
 func (m *PubKey) String() string { return proto.CompactTextString(m) }
 func (*PubKey) ProtoMessage()    {}
 func (*PubKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{46}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{44}
 }
 func (m *PubKey) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3201,7 +3094,7 @@ func (m *Evidence) Reset()         { *m = Evidence{} }
 func (m *Evidence) String() string { return proto.CompactTextString(m) }
 func (*Evidence) ProtoMessage()    {}
 func (*Evidence) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{47}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{45}
 }
 func (m *Evidence) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3277,7 +3170,7 @@ func (m *Snapshot) Reset()         { *m = Snapshot{} }
 func (m *Snapshot) String() string { return proto.CompactTextString(m) }
 func (*Snapshot) ProtoMessage()    {}
 func (*Snapshot) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9f1eaa49c51fa1ac, []int{48}
+	return fileDescriptor_9f1eaa49c51fa1ac, []int{46}
 }
 func (m *Snapshot) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3380,8 +3273,6 @@ func init() {
 	proto.RegisterType((*ResponseApplySnapshotChunk)(nil), "tendermint.abci.types.ResponseApplySnapshotChunk")
 	proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.types.ConsensusParams")
 	proto.RegisterType((*BlockParams)(nil), "tendermint.abci.types.BlockParams")
-	proto.RegisterType((*EvidenceParams)(nil), "tendermint.abci.types.EvidenceParams")
-	proto.RegisterType((*ValidatorParams)(nil), "tendermint.abci.types.ValidatorParams")
 	proto.RegisterType((*LastCommitInfo)(nil), "tendermint.abci.types.LastCommitInfo")
 	proto.RegisterType((*EventAttribute)(nil), "tendermint.abci.types.EventAttribute")
 	proto.RegisterType((*Event)(nil), "tendermint.abci.types.Event")
@@ -3399,182 +3290,175 @@ func init() {
 func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) }
 
 var fileDescriptor_9f1eaa49c51fa1ac = []byte{
-	// 2788 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x73, 0x23, 0x47,
-	0x15, 0xd7, 0x48, 0xb2, 0xa4, 0x79, 0xb2, 0x3e, 0xb6, 0x77, 0xb3, 0x51, 0x44, 0x62, 0x6f, 0xcd,
-	0x66, 0x37, 0x9b, 0x0f, 0xec, 0x64, 0x53, 0xa1, 0x12, 0x76, 0x81, 0xb2, 0xbc, 0x5e, 0x64, 0xb2,
-	0xeb, 0x75, 0xc6, 0xde, 0x25, 0x81, 0xaa, 0x0c, 0x2d, 0x4d, 0x5b, 0x9a, 0x58, 0x9a, 0x99, 0xcc,
-	0xb4, 0x1c, 0x8b, 0xe2, 0x40, 0x71, 0xa1, 0xb8, 0x85, 0x0b, 0xc5, 0x85, 0x23, 0x77, 0x0e, 0x54,
-	0x85, 0x7f, 0x80, 0xaa, 0x1c, 0x73, 0xe0, 0xc0, 0x29, 0xa1, 0x12, 0x4e, 0x70, 0xe5, 0x0f, 0xa0,
-	0xfa, 0x63, 0xbe, 0x64, 0x49, 0x33, 0x0a, 0xb9, 0x71, 0xb1, 0xa7, 0x7b, 0xde, 0x7b, 0xdd, 0xfd,
-	0xba, 0xfb, 0xf7, 0x7e, 0xef, 0x8d, 0xe0, 0x2a, 0xee, 0xf5, 0xad, 0x6d, 0x3a, 0x75, 0x89, 0x2f,
-	0xfe, 0x6e, 0xb9, 0x9e, 0x43, 0x1d, 0xf4, 0x14, 0x25, 0xb6, 0x49, 0xbc, 0xb1, 0x65, 0xd3, 0x2d,
-	0x26, 0xb2, 0xc5, 0x5f, 0xb6, 0xdb, 0x7d, 0x6f, 0xea, 0x52, 0x67, 0x7b, 0x4c, 0xbc, 0xd3, 0x11,
-	0x91, 0xff, 0x84, 0x4a, 0xfb, 0x69, 0xfe, 0xef, 0xa2, 0xad, 0xf6, 0xc6, 0xc0, 0x71, 0x06, 0x23,
-	0xb2, 0xcd, 0x5b, 0xbd, 0xc9, 0xc9, 0xb6, 0x39, 0xf1, 0x30, 0xb5, 0x1c, 0x5b, 0xbe, 0xdf, 0x9c,
-	0x7d, 0x4f, 0xad, 0x31, 0xf1, 0x29, 0x1e, 0xbb, 0x52, 0xe0, 0x26, 0x1d, 0x5a, 0x9e, 0x69, 0xb8,
-	0xd8, 0xa3, 0x53, 0x21, 0xb5, 0x3d, 0x70, 0x06, 0x4e, 0xf4, 0x24, 0xe4, 0xb4, 0x7f, 0x57, 0xa0,
-	0xac, 0x93, 0x0f, 0x27, 0xc4, 0xa7, 0xe8, 0x4d, 0x28, 0x92, 0xfe, 0xd0, 0x69, 0xe5, 0xaf, 0x29,
-	0xb7, 0xaa, 0xb7, 0xb5, 0xad, 0xb9, 0xeb, 0xd9, 0x92, 0xd2, 0x7b, 0xfd, 0xa1, 0xd3, 0xcd, 0xe9,
-	0x5c, 0x03, 0xdd, 0x81, 0xb5, 0x93, 0xd1, 0xc4, 0x1f, 0xb6, 0x0a, 0x5c, 0xf5, 0xfa, 0x72, 0xd5,
-	0xfb, 0x4c, 0xb4, 0x9b, 0xd3, 0x85, 0x0e, 0x1b, 0xd6, 0xb2, 0x4f, 0x9c, 0x56, 0x31, 0xcb, 0xb0,
-	0xfb, 0xf6, 0x09, 0x1f, 0x96, 0x69, 0xa0, 0x2e, 0x80, 0x4f, 0xa8, 0xe1, 0xb8, 0xcc, 0x33, 0xad,
-	0x35, 0xae, 0xff, 0xc2, 0x72, 0xfd, 0x23, 0x42, 0x1f, 0x71, 0xf1, 0x6e, 0x4e, 0x57, 0xfd, 0xa0,
-	0xc1, 0x2c, 0x59, 0xb6, 0x45, 0x8d, 0xfe, 0x10, 0x5b, 0x76, 0xab, 0x94, 0xc5, 0xd2, 0xbe, 0x6d,
-	0xd1, 0x5d, 0x26, 0xce, 0x2c, 0x59, 0x41, 0x83, 0xb9, 0xe2, 0xc3, 0x09, 0xf1, 0xa6, 0xad, 0x72,
-	0x16, 0x57, 0xbc, 0xc3, 0x44, 0x99, 0x2b, 0xb8, 0x0e, 0x7a, 0x1b, 0xaa, 0x3d, 0x32, 0xb0, 0x6c,
-	0xa3, 0x37, 0x72, 0xfa, 0xa7, 0xad, 0x0a, 0x37, 0x71, 0x6b, 0xb9, 0x89, 0x0e, 0x53, 0xe8, 0x30,
-	0xf9, 0x6e, 0x4e, 0x87, 0x5e, 0xd8, 0x42, 0x1d, 0xa8, 0xf4, 0x87, 0xa4, 0x7f, 0x6a, 0xd0, 0xf3,
-	0x96, 0xca, 0x2d, 0xdd, 0x58, 0x6e, 0x69, 0x97, 0x49, 0x1f, 0x9f, 0x77, 0x73, 0x7a, 0xb9, 0x2f,
-	0x1e, 0x99, 0x5f, 0x4c, 0x32, 0xb2, 0xce, 0x88, 0xc7, 0xac, 0x5c, 0xce, 0xe2, 0x97, 0x7b, 0x42,
-	0x9e, 0xdb, 0x51, 0xcd, 0xa0, 0x81, 0xf6, 0x40, 0x25, 0xb6, 0x29, 0x17, 0x56, 0xe5, 0x86, 0x6e,
-	0xa6, 0x9c, 0x30, 0xdb, 0x0c, 0x96, 0x55, 0x21, 0xf2, 0x19, 0x7d, 0x1f, 0x4a, 0x7d, 0x67, 0x3c,
-	0xb6, 0x68, 0x6b, 0x9d, 0xdb, 0x78, 0x3e, 0x65, 0x49, 0x5c, 0xb6, 0x9b, 0xd3, 0xa5, 0x16, 0x3a,
-	0x86, 0xfa, 0xc8, 0xf2, 0xa9, 0xe1, 0xdb, 0xd8, 0xf5, 0x87, 0x0e, 0xf5, 0x5b, 0x35, 0x6e, 0xe7,
-	0xe5, 0xe5, 0x76, 0x1e, 0x58, 0x3e, 0x3d, 0x0a, 0x54, 0xba, 0x39, 0xbd, 0x36, 0x8a, 0x77, 0x30,
-	0xab, 0xce, 0xc9, 0x09, 0xf1, 0x42, 0xb3, 0xad, 0x7a, 0x16, 0xab, 0x8f, 0x98, 0x4e, 0x60, 0x85,
-	0x59, 0x75, 0xe2, 0x1d, 0x08, 0xc3, 0xe5, 0x91, 0x83, 0xcd, 0xd0, 0xa8, 0xd1, 0x1f, 0x4e, 0xec,
-	0xd3, 0x56, 0x83, 0x9b, 0xde, 0x4e, 0x99, 0xb0, 0x83, 0xcd, 0xc0, 0xd0, 0x2e, 0x53, 0xeb, 0xe6,
-	0xf4, 0x4b, 0xa3, 0xd9, 0x4e, 0x64, 0xc2, 0x15, 0xec, 0xba, 0xa3, 0xe9, 0xec, 0x18, 0x4d, 0x3e,
-	0xc6, 0xab, 0xcb, 0xc7, 0xd8, 0x61, 0x9a, 0xb3, 0x83, 0x20, 0x7c, 0xa1, 0xb7, 0x53, 0x86, 0xb5,
-	0x33, 0x3c, 0x9a, 0x10, 0xed, 0x05, 0xa8, 0xc6, 0xe0, 0x03, 0xb5, 0xa0, 0x3c, 0x26, 0xbe, 0x8f,
-	0x07, 0xa4, 0xa5, 0x5c, 0x53, 0x6e, 0xa9, 0x7a, 0xd0, 0xd4, 0xea, 0xb0, 0x1e, 0x07, 0x0b, 0x6d,
-	0x1c, 0x2a, 0x32, 0x00, 0x60, 0x8a, 0x67, 0xc4, 0xf3, 0xd9, 0xad, 0x97, 0x8a, 0xb2, 0x89, 0xae,
-	0x43, 0x8d, 0x1f, 0x31, 0x23, 0x78, 0xcf, 0xc0, 0xac, 0xa8, 0xaf, 0xf3, 0xce, 0x27, 0x52, 0x68,
-	0x13, 0xaa, 0xee, 0x6d, 0x37, 0x14, 0x29, 0x70, 0x11, 0x70, 0x6f, 0xbb, 0x52, 0x40, 0xfb, 0x2e,
-	0x34, 0x67, 0xf1, 0x02, 0x35, 0xa1, 0x70, 0x4a, 0xa6, 0x72, 0x3c, 0xf6, 0x88, 0xae, 0xc8, 0x65,
-	0xf1, 0x31, 0x54, 0x5d, 0xae, 0xf1, 0x4f, 0xf9, 0x50, 0x39, 0x84, 0x08, 0x86, 0x71, 0x0c, 0xa1,
-	0xb9, 0x76, 0xf5, 0x76, 0x7b, 0x4b, 0xc0, 0xf7, 0x56, 0x00, 0xdf, 0x5b, 0xc7, 0x01, 0x7c, 0x77,
-	0x2a, 0x9f, 0x7e, 0xbe, 0x99, 0xfb, 0xf8, 0x8b, 0x4d, 0x45, 0xe7, 0x1a, 0xe8, 0x19, 0x76, 0x8b,
-	0xb1, 0x65, 0x1b, 0x96, 0x29, 0xc7, 0x29, 0xf3, 0xf6, 0xbe, 0x89, 0xde, 0x81, 0x66, 0xdf, 0xb1,
-	0x7d, 0x62, 0xfb, 0x13, 0x9f, 0x21, 0x3d, 0x1e, 0xfb, 0x12, 0x80, 0x17, 0xdd, 0xac, 0xdd, 0x40,
-	0xfc, 0x90, 0x4b, 0xeb, 0x8d, 0x7e, 0xb2, 0x03, 0x3d, 0x00, 0x38, 0xc3, 0x23, 0xcb, 0xc4, 0xd4,
-	0xf1, 0xfc, 0x56, 0xf1, 0x5a, 0x61, 0x89, 0xb1, 0x27, 0x81, 0xe0, 0x63, 0xd7, 0xc4, 0x94, 0x74,
-	0x8a, 0x6c, 0xe6, 0x7a, 0x4c, 0x1f, 0xdd, 0x84, 0x06, 0x76, 0x5d, 0xc3, 0xa7, 0x98, 0x12, 0xa3,
-	0x37, 0xa5, 0xc4, 0xe7, 0x20, 0xbd, 0xae, 0xd7, 0xb0, 0xeb, 0x1e, 0xb1, 0xde, 0x0e, 0xeb, 0xd4,
-	0xcc, 0x70, 0xb7, 0x39, 0x1e, 0x22, 0x04, 0x45, 0x13, 0x53, 0xcc, 0xbd, 0xb5, 0xae, 0xf3, 0x67,
-	0xd6, 0xe7, 0x62, 0x3a, 0x94, 0x3e, 0xe0, 0xcf, 0xe8, 0x2a, 0x94, 0x86, 0xc4, 0x1a, 0x0c, 0x29,
-	0x5f, 0x76, 0x41, 0x97, 0x2d, 0xb6, 0x31, 0xae, 0xe7, 0x9c, 0x11, 0x1e, 0x52, 0x2a, 0xba, 0x68,
-	0x68, 0xbf, 0xcb, 0xc3, 0xa5, 0x0b, 0x98, 0xc9, 0xec, 0x0e, 0xb1, 0x3f, 0x0c, 0xc6, 0x62, 0xcf,
-	0xe8, 0x2e, 0xb3, 0x8b, 0x4d, 0xe2, 0xc9, 0x50, 0xb8, 0x11, 0xf7, 0x00, 0xdf, 0x33, 0xe9, 0x82,
-	0x2e, 0x97, 0x92, 0x2b, 0x97, 0x3a, 0xe8, 0x31, 0x34, 0x47, 0xd8, 0xa7, 0x86, 0x40, 0x1c, 0x83,
-	0xc7, 0xb6, 0xc2, 0x52, 0xfc, 0x7d, 0x80, 0x03, 0xa4, 0x62, 0xa7, 0x5b, 0x9a, 0xab, 0x8f, 0x12,
-	0xbd, 0xe8, 0x5d, 0xb8, 0xd2, 0x9b, 0xfe, 0x1c, 0xdb, 0xd4, 0xb2, 0x89, 0x71, 0x61, 0x93, 0x36,
-	0x17, 0x98, 0xde, 0x3b, 0xb3, 0x4c, 0x62, 0xf7, 0x83, 0xdd, 0xb9, 0x1c, 0x9a, 0x08, 0x77, 0xcf,
-	0xd7, 0xde, 0x85, 0x7a, 0x32, 0x02, 0xa0, 0x3a, 0xe4, 0xe9, 0xb9, 0x74, 0x49, 0x9e, 0x9e, 0xa3,
-	0xef, 0x40, 0x91, 0x99, 0xe3, 0xee, 0xa8, 0x2f, 0x0c, 0xd1, 0x52, 0xfb, 0x78, 0xea, 0x12, 0x9d,
-	0xcb, 0x6b, 0x5a, 0x78, 0x15, 0xc2, 0xa8, 0x30, 0x6b, 0x5b, 0x7b, 0x11, 0x1a, 0x33, 0x80, 0x1f,
-	0xdb, 0x57, 0x25, 0xbe, 0xaf, 0x5a, 0x03, 0x6a, 0x09, 0x5c, 0xd7, 0xae, 0xc2, 0x95, 0x79, 0x00,
-	0xad, 0xd9, 0x61, 0x7f, 0x02, 0x62, 0xd1, 0x1d, 0xa8, 0x84, 0x08, 0x2d, 0xae, 0xe2, 0x22, 0xbf,
-	0x05, 0x2a, 0x7a, 0xa8, 0xc0, 0x6e, 0x22, 0x3b, 0xcd, 0xfc, 0xb4, 0xe4, 0xf9, 0xf4, 0xcb, 0xd8,
-	0x75, 0xbb, 0xd8, 0x1f, 0x6a, 0x3f, 0x83, 0xd6, 0x22, 0xdc, 0x9d, 0x59, 0x4c, 0x31, 0x3c, 0xa4,
-	0x57, 0xa1, 0x74, 0xe2, 0x78, 0x63, 0x4c, 0xb9, 0xb1, 0x9a, 0x2e, 0x5b, 0xec, 0xf0, 0x0a, 0x0c,
-	0x2e, 0xf0, 0x6e, 0xd1, 0xd0, 0x0c, 0x78, 0x66, 0x21, 0xea, 0x32, 0x15, 0xcb, 0x36, 0x89, 0xf0,
-	0x6a, 0x4d, 0x17, 0x8d, 0xc8, 0x90, 0x98, 0xac, 0x68, 0xb0, 0x61, 0x7d, 0xbe, 0x62, 0x6e, 0x5f,
-	0xd5, 0x65, 0x4b, 0xfb, 0xab, 0x0a, 0x15, 0x9d, 0xf8, 0x2e, 0x03, 0x04, 0xd4, 0x05, 0x95, 0x9c,
-	0xf7, 0x89, 0xe0, 0x55, 0x4a, 0x0a, 0x0b, 0x11, 0x3a, 0x7b, 0x81, 0x3c, 0x0b, 0xfb, 0xa1, 0x32,
-	0x7a, 0x2b, 0xc1, 0x29, 0xaf, 0xa7, 0x19, 0x89, 0x93, 0xca, 0xbb, 0x49, 0x52, 0xf9, 0x7c, 0x8a,
-	0xee, 0x0c, 0xab, 0x7c, 0x2b, 0xc1, 0x2a, 0xd3, 0x06, 0x4e, 0xd0, 0xca, 0xfd, 0x39, 0xb4, 0x32,
-	0x6d, 0xf9, 0x0b, 0x78, 0xe5, 0xfe, 0x1c, 0x5e, 0x79, 0x2b, 0x75, 0x2e, 0x73, 0x89, 0xe5, 0xdd,
-	0x24, 0xb1, 0x4c, 0x73, 0xc7, 0x0c, 0xb3, 0x7c, 0x30, 0x8f, 0x59, 0xbe, 0x98, 0x62, 0x63, 0x21,
-	0xb5, 0xdc, 0xbd, 0x40, 0x2d, 0x6f, 0xa6, 0x98, 0x9a, 0xc3, 0x2d, 0xf7, 0x13, 0xdc, 0x12, 0x32,
-	0xf9, 0x66, 0x01, 0xb9, 0xbc, 0x7f, 0x91, 0x5c, 0xbe, 0x90, 0x76, 0xd4, 0xe6, 0xb1, 0xcb, 0x1f,
-	0xcc, 0xb0, 0xcb, 0x1b, 0x69, 0xab, 0x9a, 0xa5, 0x97, 0x8f, 0x17, 0xd0, 0xcb, 0x57, 0x52, 0x0c,
-	0xa5, 0xf0, 0xcb, 0xc7, 0x0b, 0xf8, 0x65, 0x9a, 0xd9, 0x14, 0x82, 0xd9, 0x5b, 0x46, 0x30, 0x5f,
-	0x4d, 0x9b, 0x72, 0x36, 0x86, 0x49, 0x96, 0x32, 0xcc, 0xd7, 0x52, 0x06, 0x59, 0x9d, 0x62, 0xbe,
-	0xc8, 0x82, 0xfc, 0x0c, 0x24, 0x31, 0x28, 0x24, 0x9e, 0xe7, 0x78, 0x92, 0xbd, 0x89, 0x86, 0x76,
-	0x8b, 0xd1, 0x8e, 0x08, 0x78, 0x96, 0xd0, 0x51, 0x1e, 0x78, 0x62, 0x30, 0xa3, 0xfd, 0x45, 0x89,
-	0x74, 0x79, 0x74, 0x8e, 0x53, 0x16, 0x55, 0x52, 0x96, 0x18, 0x4b, 0xcd, 0x27, 0x59, 0xea, 0x26,
-	0x54, 0x59, 0x28, 0x99, 0x21, 0xa0, 0xd8, 0x0d, 0x08, 0x28, 0x7a, 0x09, 0x2e, 0x71, 0x0e, 0x21,
-	0xb8, 0xac, 0x8c, 0x1f, 0x45, 0x1e, 0x0c, 0x1b, 0xec, 0x85, 0x38, 0xba, 0x22, 0x90, 0x7c, 0x1b,
-	0x2e, 0xc7, 0x64, 0xc3, 0x10, 0x25, 0x98, 0x56, 0x33, 0x94, 0xde, 0x91, 0xb1, 0xea, 0x61, 0xe4,
-	0xa0, 0x88, 0xdc, 0x22, 0x28, 0xf6, 0x1d, 0x93, 0xc8, 0x00, 0xc2, 0x9f, 0x19, 0xe1, 0x1d, 0x39,
-	0x03, 0x19, 0x26, 0xd8, 0x23, 0x93, 0x0a, 0x31, 0x55, 0x15, 0x60, 0xa9, 0xfd, 0x59, 0x89, 0xec,
-	0x45, 0x7c, 0x77, 0x1e, 0x35, 0x55, 0xbe, 0x49, 0x6a, 0x9a, 0xff, 0xdf, 0xa8, 0xa9, 0xf6, 0x1f,
-	0x25, 0xda, 0xd2, 0x90, 0x74, 0x7e, 0x3d, 0x17, 0x44, 0xe1, 0x77, 0x8d, 0x6f, 0x90, 0x0c, 0xbf,
-	0x32, 0x5f, 0x28, 0xf1, 0x6d, 0x48, 0xe6, 0x0b, 0x65, 0x11, 0x90, 0x79, 0x03, 0xbd, 0xc1, 0xc9,
-	0xaa, 0x73, 0x22, 0x31, 0x39, 0x41, 0x48, 0x44, 0xe9, 0x68, 0x4b, 0xd6, 0x8c, 0x0e, 0x99, 0x98,
-	0x2e, 0xa4, 0x63, 0xb4, 0x42, 0x4d, 0x70, 0xdf, 0x67, 0x41, 0x65, 0x53, 0xf7, 0x5d, 0xdc, 0x27,
-	0x1c, 0x54, 0x55, 0x3d, 0xea, 0xd0, 0x4c, 0x40, 0x17, 0xc1, 0x1d, 0x1d, 0x40, 0x89, 0x9c, 0x11,
-	0x9b, 0xb2, 0x3d, 0x62, 0x6e, 0x7d, 0x76, 0x21, 0x99, 0x24, 0x36, 0xed, 0xb4, 0x98, 0x33, 0xff,
-	0xf5, 0xf9, 0x66, 0x53, 0xe8, 0xbc, 0xe2, 0x8c, 0x2d, 0x4a, 0xc6, 0x2e, 0x9d, 0xea, 0xd2, 0x8a,
-	0xf6, 0xeb, 0x3c, 0xe3, 0x74, 0x09, 0xe0, 0x9f, 0xeb, 0xde, 0xe0, 0xd2, 0xe4, 0x63, 0x3c, 0x3f,
-	0x9b, 0xcb, 0x9f, 0x03, 0x18, 0x60, 0xdf, 0xf8, 0x08, 0xdb, 0x94, 0x98, 0xd2, 0xef, 0xea, 0x00,
-	0xfb, 0x3f, 0xe6, 0x1d, 0x8c, 0xaa, 0xb1, 0xd7, 0x13, 0x9f, 0x98, 0x7c, 0x03, 0x0a, 0x7a, 0x79,
-	0x80, 0xfd, 0xc7, 0x3e, 0x31, 0x63, 0x6b, 0x2d, 0x7f, 0x13, 0x6b, 0x4d, 0xfa, 0xbb, 0x32, 0xeb,
-	0xef, 0xdf, 0xe4, 0xa3, 0xdb, 0x11, 0x51, 0xe0, 0xff, 0x4f, 0x5f, 0xfc, 0x81, 0x27, 0xc6, 0xc9,
-	0xe8, 0x8b, 0xde, 0x83, 0x4b, 0xe1, 0xad, 0x34, 0x26, 0xfc, 0xb6, 0x06, 0xa7, 0x70, 0xb5, 0xcb,
-	0xdd, 0x3c, 0x4b, 0x76, 0xfb, 0xe8, 0x7d, 0x78, 0x7a, 0x06, 0x83, 0xc2, 0x01, 0xf2, 0x2b, 0x41,
-	0xd1, 0x53, 0x49, 0x28, 0x0a, 0xec, 0x47, 0xde, 0x2b, 0x7c, 0x23, 0xb7, 0x66, 0x9f, 0xa5, 0x61,
-	0x71, 0x5e, 0x31, 0xf7, 0x4c, 0x5c, 0x87, 0x9a, 0x47, 0x28, 0xb6, 0x6c, 0x23, 0x91, 0xfa, 0xae,
-	0x8b, 0x4e, 0x11, 0x12, 0xb4, 0x27, 0xf0, 0xd4, 0x5c, 0x66, 0x81, 0xbe, 0x07, 0x6a, 0x44, 0x4d,
-	0x94, 0xa5, 0x99, 0x63, 0x98, 0x01, 0x45, 0x1a, 0xda, 0x27, 0x4a, 0x64, 0x38, 0x99, 0x59, 0xbd,
-	0x0d, 0x25, 0x8f, 0xf8, 0x93, 0x91, 0xc8, 0x72, 0xea, 0xb7, 0x5f, 0x5f, 0x85, 0x99, 0xb0, 0xde,
-	0xc9, 0x88, 0xea, 0xd2, 0x84, 0xf6, 0x0e, 0x94, 0x44, 0x0f, 0x02, 0x28, 0xed, 0xec, 0xee, 0xee,
-	0x1d, 0x1e, 0x37, 0x73, 0x48, 0x85, 0xb5, 0x9d, 0xce, 0x23, 0xfd, 0xb8, 0xa9, 0xb0, 0x6e, 0x7d,
-	0xef, 0x47, 0x7b, 0xbb, 0xc7, 0xcd, 0x3c, 0xba, 0x04, 0x35, 0xf1, 0x6c, 0xdc, 0x7f, 0xa4, 0x3f,
-	0xdc, 0x39, 0x6e, 0x16, 0x62, 0x5d, 0x47, 0x7b, 0x07, 0xf7, 0xf6, 0xf4, 0x66, 0x51, 0x7b, 0x8d,
-	0xe5, 0x4f, 0x0b, 0x88, 0x4b, 0x94, 0x29, 0x29, 0xb1, 0x4c, 0x49, 0xfb, 0x6d, 0x1e, 0xda, 0x8b,
-	0x79, 0x08, 0x3a, 0x9c, 0x59, 0xf1, 0x9b, 0x2b, 0x53, 0x99, 0x99, 0x65, 0xa3, 0x1b, 0x50, 0xf7,
-	0xc8, 0x09, 0xa1, 0xfd, 0xa1, 0xe0, 0x48, 0x22, 0xca, 0xd5, 0xf4, 0x9a, 0xec, 0xe5, 0x4a, 0xbe,
-	0x10, 0xfb, 0x80, 0xf4, 0xa9, 0x21, 0x52, 0x37, 0x71, 0xfe, 0x54, 0x26, 0xc6, 0x7a, 0x8f, 0x44,
-	0xa7, 0x76, 0x94, 0xe6, 0x44, 0x15, 0xd6, 0xf4, 0xbd, 0x63, 0xfd, 0xbd, 0x66, 0x1e, 0x21, 0xa8,
-	0xf3, 0x47, 0xe3, 0xe8, 0x60, 0xe7, 0xf0, 0xa8, 0xfb, 0x88, 0x39, 0xf1, 0x32, 0x34, 0x02, 0x27,
-	0x06, 0x9d, 0x45, 0xed, 0x6f, 0x0a, 0x34, 0x66, 0xae, 0x07, 0x7a, 0x13, 0xd6, 0x04, 0xf1, 0x56,
-	0x96, 0x16, 0xf0, 0xf9, 0x7d, 0x97, 0x37, 0x4a, 0x28, 0xa0, 0x1d, 0xa8, 0x10, 0x59, 0x9f, 0x90,
-	0x57, 0xf2, 0x46, 0x4a, 0x19, 0x43, 0xea, 0x87, 0x6a, 0xe8, 0x1e, 0xa8, 0xe1, 0xc5, 0x4f, 0x29,
-	0x7e, 0x85, 0xb8, 0x21, 0x8d, 0x44, 0x8a, 0xda, 0x2e, 0x54, 0x63, 0xd3, 0x43, 0xdf, 0x02, 0x75,
-	0x8c, 0xcf, 0x65, 0xc5, 0x4a, 0x94, 0x20, 0x2a, 0x63, 0x7c, 0xce, 0x8b, 0x55, 0xe8, 0x69, 0x28,
-	0xb3, 0x97, 0x03, 0x2c, 0x60, 0xa4, 0xa0, 0x97, 0xc6, 0xf8, 0xfc, 0x87, 0xd8, 0xd7, 0xfe, 0xa8,
-	0x40, 0x3d, 0x39, 0x4f, 0xf4, 0x32, 0x20, 0x26, 0x8b, 0x07, 0xc4, 0xb0, 0x27, 0x63, 0xc1, 0xd0,
-	0x02, 0x8b, 0x8d, 0x31, 0x3e, 0xdf, 0x19, 0x90, 0x83, 0xc9, 0x98, 0x0f, 0xed, 0xa3, 0x87, 0xd0,
-	0x0c, 0x84, 0x83, 0xaf, 0x3d, 0xd2, 0x2b, 0xcf, 0x5c, 0xa8, 0x17, 0xde, 0x93, 0x02, 0xa2, 0x5c,
-	0xf8, 0xfb, 0x2f, 0x36, 0x15, 0xbd, 0x2e, 0xec, 0x05, 0x6f, 0x82, 0x79, 0xda, 0x93, 0xb1, 0xac,
-	0x24, 0xb0, 0x79, 0x1e, 0x4c, 0xc6, 0xda, 0x1b, 0xd0, 0x98, 0x71, 0x05, 0xd2, 0xa0, 0xe6, 0x4e,
-	0x7a, 0xc6, 0x29, 0x99, 0x1a, 0xdc, 0x57, 0x1c, 0x1a, 0x54, 0xbd, 0xea, 0x4e, 0x7a, 0x6f, 0x93,
-	0xe9, 0x31, 0xeb, 0xd2, 0xfa, 0x50, 0x4f, 0xd6, 0xa9, 0xd8, 0xb5, 0xf1, 0x9c, 0x89, 0x6d, 0xf2,
-	0x05, 0xad, 0xe9, 0xa2, 0x81, 0xee, 0xc0, 0xda, 0x99, 0x23, 0x40, 0x76, 0x19, 0xbc, 0x3c, 0x71,
-	0x28, 0x89, 0x55, 0xbb, 0x84, 0x8e, 0x76, 0xc0, 0x5c, 0x48, 0x6c, 0xba, 0x43, 0xa9, 0x67, 0xf5,
-	0x26, 0x94, 0xc4, 0xcb, 0xae, 0xeb, 0x73, 0xca, 0xae, 0x21, 0x8d, 0x0a, 0x49, 0x58, 0x41, 0xd4,
-	0xfc, 0x78, 0x43, 0xfb, 0xa5, 0x02, 0x6b, 0xdc, 0x20, 0xc3, 0x52, 0x5e, 0xc2, 0x92, 0x04, 0x9d,
-	0x3d, 0xa3, 0x3e, 0x00, 0x0e, 0x06, 0x0a, 0xe6, 0x7b, 0x63, 0x19, 0x8a, 0x87, 0xd3, 0xea, 0x3c,
-	0x2b, 0xe1, 0xfc, 0x4a, 0x64, 0x20, 0x06, 0xe9, 0x31, 0xb3, 0xda, 0xc7, 0x0a, 0x54, 0x8e, 0xcf,
-	0xe5, 0x55, 0x5c, 0x50, 0xd9, 0x62, 0xb3, 0xdf, 0xe7, 0xb3, 0x17, 0xb5, 0x20, 0xd1, 0x90, 0xa5,
-	0xb2, 0x42, 0x58, 0x86, 0xbb, 0x1f, 0x42, 0x4e, 0x71, 0xb5, 0x6c, 0x39, 0xa8, 0x50, 0x4a, 0x7c,
-	0x1d, 0x41, 0x99, 0x9f, 0xb9, 0xfd, 0x7b, 0x73, 0xcb, 0x9f, 0x0f, 0x61, 0xdd, 0xc5, 0x1e, 0xf5,
-	0x8d, 0x44, 0x11, 0x74, 0x51, 0xc1, 0xe1, 0x10, 0x7b, 0xf4, 0x88, 0xd0, 0x44, 0x29, 0xb4, 0xca,
-	0xf5, 0x45, 0x97, 0xf6, 0x16, 0xd4, 0x12, 0x32, 0x6c, 0xb1, 0xd4, 0xa1, 0x78, 0x14, 0x9c, 0x1b,
-	0xde, 0x08, 0x67, 0x92, 0x8f, 0x66, 0xa2, 0xdd, 0x01, 0x35, 0x3c, 0xaa, 0x2c, 0x9d, 0xc2, 0xa6,
-	0xe9, 0x11, 0xdf, 0x97, 0xb3, 0x0d, 0x9a, 0xbc, 0xde, 0xeb, 0x7c, 0x24, 0x4b, 0x5a, 0x05, 0x5d,
-	0x34, 0x34, 0x12, 0x3b, 0xe7, 0x22, 0x66, 0xa3, 0xbb, 0x50, 0x96, 0xe7, 0x5c, 0x82, 0xd5, 0x73,
-	0x8b, 0x16, 0xc5, 0x0f, 0x7e, 0xe0, 0x36, 0x71, 0x0d, 0xa2, 0x61, 0xf2, 0xf1, 0x61, 0x7e, 0x01,
-	0x95, 0xe0, 0x2c, 0x27, 0xd1, 0x48, 0x8c, 0x70, 0x2d, 0x0d, 0x8d, 0xe4, 0x20, 0x91, 0x22, 0x4b,
-	0xfe, 0x7c, 0x6b, 0x60, 0x13, 0xd3, 0x88, 0xf2, 0x3a, 0x3e, 0x66, 0x45, 0x6f, 0x88, 0x17, 0x0f,
-	0x82, 0xa4, 0x4e, 0x7b, 0x15, 0x4a, 0x62, 0xae, 0x73, 0x0f, 0xf8, 0x1c, 0x02, 0xa1, 0xfd, 0x53,
-	0x81, 0x4a, 0x00, 0x53, 0x73, 0x95, 0x12, 0x8b, 0xc8, 0x7f, 0xdd, 0x45, 0x2c, 0xaa, 0xcd, 0x07,
-	0x5f, 0x42, 0x8a, 0x2b, 0x7f, 0x09, 0x79, 0x05, 0x10, 0x3f, 0x29, 0xc6, 0x99, 0x43, 0x2d, 0x7b,
-	0x60, 0x88, 0xbd, 0x10, 0x7c, 0xb7, 0xc9, 0xdf, 0x3c, 0xe1, 0x2f, 0x0e, 0xf9, 0xb6, 0xfc, 0x4a,
-	0x81, 0x4a, 0xc8, 0x4e, 0x56, 0xad, 0xc1, 0x5e, 0x85, 0x92, 0x8c, 0xc0, 0x12, 0x3a, 0x45, 0x2b,
-	0x3c, 0xa3, 0xc5, 0xd8, 0x6d, 0x69, 0x43, 0x65, 0x4c, 0x28, 0xe6, 0x7e, 0x16, 0x39, 0x77, 0xd8,
-	0x7e, 0xe9, 0x3a, 0x54, 0x63, 0x45, 0x71, 0x54, 0x86, 0xc2, 0x01, 0xf9, 0xa8, 0x99, 0x43, 0x55,
-	0x28, 0xeb, 0x84, 0xd7, 0xc1, 0x9a, 0xca, 0xed, 0x4f, 0xaa, 0xd0, 0xd8, 0xe9, 0xec, 0xee, 0x33,
-	0x82, 0x60, 0xf5, 0x05, 0x78, 0x3f, 0x82, 0x22, 0x2f, 0x49, 0x64, 0xf8, 0x08, 0xdf, 0xce, 0x52,
-	0x54, 0x45, 0x3a, 0xac, 0xf1, 0xca, 0x05, 0xca, 0xf2, 0x6d, 0xbe, 0x9d, 0xa9, 0xd6, 0xca, 0x26,
-	0xc9, 0x4f, 0x7d, 0x86, 0x4f, 0xf6, 0xed, 0x2c, 0x05, 0x58, 0xf4, 0x3e, 0xa8, 0x51, 0x49, 0x22,
-	0xeb, 0x87, 0xfc, 0x76, 0xe6, 0xd2, 0x2c, 0xb3, 0x1f, 0x25, 0x61, 0x59, 0x3f, 0x63, 0xb7, 0x33,
-	0xa3, 0x2c, 0x7a, 0x17, 0xca, 0x41, 0xba, 0x9b, 0xed, 0x53, 0x7b, 0x3b, 0x63, 0xd9, 0x94, 0x6d,
-	0x9f, 0xa8, 0x52, 0x64, 0xf9, 0x3d, 0x41, 0x3b, 0x53, 0x6d, 0x18, 0x3d, 0x86, 0x92, 0xcc, 0x33,
-	0x32, 0x7d, 0x44, 0x6f, 0x67, 0x2b, 0x86, 0x32, 0x27, 0x47, 0x75, 0xa0, 0xac, 0xbf, 0xa1, 0x68,
-	0x67, 0x2e, 0x8a, 0x23, 0x0c, 0x10, 0x2b, 0x5d, 0x64, 0xfe, 0x71, 0x44, 0x3b, 0x7b, 0xb1, 0x1b,
-	0xfd, 0x14, 0x2a, 0x61, 0x82, 0x9a, 0xf1, 0x47, 0x0a, 0xed, 0xac, 0xf5, 0x66, 0xf4, 0x01, 0xd4,
-	0x92, 0x39, 0xd9, 0x2a, 0x3f, 0x3d, 0x68, 0xaf, 0x54, 0x48, 0x66, 0x63, 0x25, 0xd3, 0xb4, 0x55,
-	0x7e, 0x90, 0xd0, 0x5e, 0xa9, 0xba, 0x8c, 0xce, 0xe0, 0xd2, 0xc5, 0xcc, 0x6a, 0xd5, 0x5f, 0x29,
-	0xb4, 0x57, 0xae, 0x3a, 0xa3, 0x29, 0xa0, 0x39, 0xd9, 0xd9, 0xca, 0x3f, 0x5d, 0x68, 0xaf, 0x5e,
-	0x8a, 0xee, 0xec, 0x7d, 0xfa, 0xe5, 0x86, 0xf2, 0xd9, 0x97, 0x1b, 0xca, 0x3f, 0xbe, 0xdc, 0x50,
-	0x3e, 0xfe, 0x6a, 0x23, 0xf7, 0xd9, 0x57, 0x1b, 0xb9, 0xbf, 0x7f, 0xb5, 0x91, 0xfb, 0xc9, 0xcb,
-	0x03, 0x8b, 0x0e, 0x27, 0xbd, 0xad, 0xbe, 0x33, 0xde, 0x8e, 0xcc, 0xc6, 0x1f, 0xa3, 0x1f, 0x91,
-	0xf5, 0x4a, 0x3c, 0xf8, 0xbd, 0xfe, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x34, 0xfb, 0xdb,
-	0x59, 0x26, 0x00, 0x00,
+	// 2688 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x73, 0x1b, 0xc7,
+	0x11, 0xc6, 0x02, 0x20, 0x1e, 0x0d, 0x02, 0x04, 0x47, 0xb2, 0x0c, 0x23, 0x36, 0xa9, 0x5a, 0x59,
+	0x2f, 0x5b, 0x21, 0x65, 0xba, 0x92, 0x92, 0x22, 0x25, 0x29, 0x82, 0x82, 0x02, 0x46, 0x0f, 0x52,
+	0x4b, 0x52, 0x91, 0x93, 0x2a, 0x6f, 0x06, 0xd8, 0x21, 0xb0, 0x16, 0xb0, 0xbb, 0xde, 0x1d, 0x50,
+	0x44, 0x2a, 0x87, 0x54, 0x2e, 0xa9, 0xdc, 0x94, 0x4b, 0x6e, 0xf9, 0x0f, 0x39, 0xa4, 0xca, 0xf9,
+	0x03, 0xa9, 0xf2, 0xd1, 0xa7, 0x54, 0x4e, 0x4e, 0x4a, 0xca, 0x29, 0xb9, 0xe6, 0x07, 0xa4, 0xe6,
+	0xb1, 0x2f, 0x10, 0x8f, 0x85, 0xa3, 0x5b, 0x2e, 0xe4, 0xf4, 0x6c, 0x77, 0xcf, 0x4c, 0xcf, 0x4c,
+	0xf7, 0xd7, 0x3d, 0x80, 0x0b, 0xb8, 0xdd, 0x31, 0x37, 0xe9, 0xc8, 0x21, 0x9e, 0xf8, 0xbb, 0xe1,
+	0xb8, 0x36, 0xb5, 0xd1, 0x5b, 0x94, 0x58, 0x06, 0x71, 0x07, 0xa6, 0x45, 0x37, 0x18, 0xcb, 0x06,
+	0xff, 0x58, 0xaf, 0x77, 0xdc, 0x91, 0x43, 0xed, 0xcd, 0x01, 0x71, 0x9f, 0xf7, 0x89, 0xfc, 0x27,
+	0x44, 0xea, 0x6f, 0xf3, 0x7f, 0x67, 0x75, 0xd5, 0x6b, 0xd1, 0x0f, 0x0e, 0x76, 0xf1, 0xc0, 0xff,
+	0xb2, 0xde, 0xb5, 0xed, 0x6e, 0x9f, 0x6c, 0x72, 0xaa, 0x3d, 0x3c, 0xde, 0xa4, 0xe6, 0x80, 0x78,
+	0x14, 0x0f, 0x1c, 0xc9, 0x70, 0x85, 0xf6, 0x4c, 0xd7, 0xd0, 0x1d, 0xec, 0xd2, 0x91, 0xe0, 0xda,
+	0xec, 0xda, 0x5d, 0x3b, 0x6c, 0x09, 0x3e, 0xf5, 0xdf, 0x05, 0xc8, 0x6b, 0xe4, 0xf3, 0x21, 0xf1,
+	0x28, 0xba, 0x05, 0x59, 0xd2, 0xe9, 0xd9, 0xb5, 0xf4, 0x45, 0xe5, 0x5a, 0x69, 0x4b, 0xdd, 0x98,
+	0xb8, 0x92, 0x0d, 0xc9, 0xdd, 0xec, 0xf4, 0xec, 0x56, 0x4a, 0xe3, 0x12, 0xe8, 0x0e, 0x2c, 0x1d,
+	0xf7, 0x87, 0x5e, 0xaf, 0x96, 0xe1, 0xa2, 0x97, 0x66, 0x8b, 0xde, 0x67, 0xac, 0xad, 0x94, 0x26,
+	0x64, 0xd8, 0xb0, 0xa6, 0x75, 0x6c, 0xd7, 0xb2, 0x49, 0x86, 0xdd, 0xb5, 0x8e, 0xf9, 0xb0, 0x4c,
+	0x02, 0xb5, 0x00, 0x3c, 0x42, 0x75, 0xdb, 0xa1, 0xa6, 0x6d, 0xd5, 0x96, 0xb8, 0xfc, 0xd5, 0xd9,
+	0xf2, 0x07, 0x84, 0xee, 0x71, 0xf6, 0x56, 0x4a, 0x2b, 0x7a, 0x3e, 0xc1, 0x34, 0x99, 0x96, 0x49,
+	0xf5, 0x4e, 0x0f, 0x9b, 0x56, 0x2d, 0x97, 0x44, 0xd3, 0xae, 0x65, 0xd2, 0x1d, 0xc6, 0xce, 0x34,
+	0x99, 0x3e, 0xc1, 0x4c, 0xf1, 0xf9, 0x90, 0xb8, 0xa3, 0x5a, 0x3e, 0x89, 0x29, 0x9e, 0x30, 0x56,
+	0x66, 0x0a, 0x2e, 0x83, 0x1e, 0x40, 0xa9, 0x4d, 0xba, 0xa6, 0xa5, 0xb7, 0xfb, 0x76, 0xe7, 0x79,
+	0xad, 0xc0, 0x55, 0x5c, 0x9b, 0xad, 0xa2, 0xc1, 0x04, 0x1a, 0x8c, 0xbf, 0x95, 0xd2, 0xa0, 0x1d,
+	0x50, 0xa8, 0x01, 0x85, 0x4e, 0x8f, 0x74, 0x9e, 0xeb, 0xf4, 0xb4, 0x56, 0xe4, 0x9a, 0x2e, 0xcf,
+	0xd6, 0xb4, 0xc3, 0xb8, 0x0f, 0x4f, 0x5b, 0x29, 0x2d, 0xdf, 0x11, 0x4d, 0x66, 0x17, 0x83, 0xf4,
+	0xcd, 0x13, 0xe2, 0x32, 0x2d, 0xe7, 0x92, 0xd8, 0xe5, 0x9e, 0xe0, 0xe7, 0x7a, 0x8a, 0x86, 0x4f,
+	0xa0, 0x26, 0x14, 0x89, 0x65, 0xc8, 0x85, 0x95, 0xb8, 0xa2, 0x2b, 0x73, 0x4e, 0x98, 0x65, 0xf8,
+	0xcb, 0x2a, 0x10, 0xd9, 0x46, 0x3f, 0x80, 0x5c, 0xc7, 0x1e, 0x0c, 0x4c, 0x5a, 0x5b, 0xe6, 0x3a,
+	0xde, 0x9f, 0xb3, 0x24, 0xce, 0xdb, 0x4a, 0x69, 0x52, 0x0a, 0x1d, 0x42, 0xa5, 0x6f, 0x7a, 0x54,
+	0xf7, 0x2c, 0xec, 0x78, 0x3d, 0x9b, 0x7a, 0xb5, 0x32, 0xd7, 0xf3, 0xe1, 0x6c, 0x3d, 0x0f, 0x4d,
+	0x8f, 0x1e, 0xf8, 0x22, 0xad, 0x94, 0x56, 0xee, 0x47, 0x3b, 0x98, 0x56, 0xfb, 0xf8, 0x98, 0xb8,
+	0x81, 0xda, 0x5a, 0x25, 0x89, 0xd6, 0x3d, 0x26, 0xe3, 0x6b, 0x61, 0x5a, 0xed, 0x68, 0x07, 0xc2,
+	0x70, 0xae, 0x6f, 0x63, 0x23, 0x50, 0xaa, 0x77, 0x7a, 0x43, 0xeb, 0x79, 0x6d, 0x85, 0xab, 0xde,
+	0x9c, 0x33, 0x61, 0x1b, 0x1b, 0xbe, 0xa2, 0x1d, 0x26, 0xd6, 0x4a, 0x69, 0xab, 0xfd, 0xf1, 0x4e,
+	0x64, 0xc0, 0x79, 0xec, 0x38, 0xfd, 0xd1, 0xf8, 0x18, 0x55, 0x3e, 0xc6, 0xcd, 0xd9, 0x63, 0x6c,
+	0x33, 0xc9, 0xf1, 0x41, 0x10, 0x3e, 0xd3, 0xdb, 0xc8, 0xc3, 0xd2, 0x09, 0xee, 0x0f, 0x89, 0x7a,
+	0x15, 0x4a, 0x11, 0xf7, 0x81, 0x6a, 0x90, 0x1f, 0x10, 0xcf, 0xc3, 0x5d, 0x52, 0x53, 0x2e, 0x2a,
+	0xd7, 0x8a, 0x9a, 0x4f, 0xaa, 0x15, 0x58, 0x8e, 0x3a, 0x0b, 0x75, 0x10, 0x08, 0x32, 0x07, 0xc0,
+	0x04, 0x4f, 0x88, 0xeb, 0xb1, 0x5b, 0x2f, 0x05, 0x25, 0x89, 0x2e, 0x41, 0x99, 0x1f, 0x31, 0xdd,
+	0xff, 0xce, 0x9c, 0x59, 0x56, 0x5b, 0xe6, 0x9d, 0x4f, 0x25, 0xd3, 0x3a, 0x94, 0x9c, 0x2d, 0x27,
+	0x60, 0xc9, 0x70, 0x16, 0x70, 0xb6, 0x1c, 0xc9, 0xa0, 0x7e, 0x0f, 0xaa, 0xe3, 0xfe, 0x02, 0x55,
+	0x21, 0xf3, 0x9c, 0x8c, 0xe4, 0x78, 0xac, 0x89, 0xce, 0xcb, 0x65, 0xf1, 0x31, 0x8a, 0x9a, 0x5c,
+	0xe3, 0x1f, 0xd3, 0x81, 0x70, 0xe0, 0x22, 0x98, 0x8f, 0x63, 0x1e, 0x9a, 0x4b, 0x97, 0xb6, 0xea,
+	0x1b, 0xc2, 0x7d, 0x6f, 0xf8, 0xee, 0x7b, 0xe3, 0xd0, 0x77, 0xdf, 0x8d, 0xc2, 0x97, 0x5f, 0xaf,
+	0xa7, 0x5e, 0xfe, 0x7d, 0x5d, 0xd1, 0xb8, 0x04, 0x7a, 0x87, 0xdd, 0x62, 0x6c, 0x5a, 0xba, 0x69,
+	0xc8, 0x71, 0xf2, 0x9c, 0xde, 0x35, 0xd0, 0x13, 0xa8, 0x76, 0x6c, 0xcb, 0x23, 0x96, 0x37, 0xf4,
+	0x74, 0x11, 0x1e, 0xa4, 0x03, 0x9e, 0x76, 0xb3, 0x76, 0x7c, 0xf6, 0x7d, 0xce, 0xad, 0xad, 0x74,
+	0xe2, 0x1d, 0xe8, 0x21, 0xc0, 0x09, 0xee, 0x9b, 0x06, 0xa6, 0xb6, 0xeb, 0xd5, 0xb2, 0x17, 0x33,
+	0x33, 0x94, 0x3d, 0xf5, 0x19, 0x8f, 0x1c, 0x03, 0x53, 0xd2, 0xc8, 0xb2, 0x99, 0x6b, 0x11, 0x79,
+	0x74, 0x05, 0x56, 0xb0, 0xe3, 0xe8, 0x1e, 0xc5, 0x94, 0xe8, 0xed, 0x11, 0x25, 0x1e, 0x77, 0xd2,
+	0xcb, 0x5a, 0x19, 0x3b, 0xce, 0x01, 0xeb, 0x6d, 0xb0, 0x4e, 0xd5, 0x08, 0x76, 0x9b, 0xfb, 0x43,
+	0x84, 0x20, 0x6b, 0x60, 0x8a, 0xb9, 0xb5, 0x96, 0x35, 0xde, 0x66, 0x7d, 0x0e, 0xa6, 0x3d, 0x69,
+	0x03, 0xde, 0x46, 0x17, 0x20, 0xd7, 0x23, 0x66, 0xb7, 0x47, 0xf9, 0xb2, 0x33, 0x9a, 0xa4, 0xd8,
+	0xc6, 0x38, 0xae, 0x7d, 0x42, 0x78, 0x48, 0x29, 0x68, 0x82, 0x50, 0x7f, 0x9f, 0x86, 0xd5, 0x33,
+	0x3e, 0x93, 0xe9, 0xed, 0x61, 0xaf, 0xe7, 0x8f, 0xc5, 0xda, 0xe8, 0x2e, 0xd3, 0x8b, 0x0d, 0xe2,
+	0xca, 0x50, 0xb8, 0x16, 0xb5, 0x00, 0xdf, 0x33, 0x69, 0x82, 0x16, 0xe7, 0x92, 0x2b, 0x97, 0x32,
+	0xe8, 0x08, 0xaa, 0x7d, 0xec, 0x51, 0x5d, 0x78, 0x1c, 0x9d, 0xc7, 0xb6, 0xcc, 0x4c, 0xff, 0xfb,
+	0x10, 0xfb, 0x9e, 0x8a, 0x9d, 0x6e, 0xa9, 0xae, 0xd2, 0x8f, 0xf5, 0xa2, 0x67, 0x70, 0xbe, 0x3d,
+	0xfa, 0x05, 0xb6, 0xa8, 0x69, 0x11, 0xfd, 0xcc, 0x26, 0xad, 0x4f, 0x51, 0xdd, 0x3c, 0x31, 0x0d,
+	0x62, 0x75, 0xfc, 0xdd, 0x39, 0x17, 0xa8, 0x08, 0x76, 0xcf, 0x53, 0x9f, 0x41, 0x25, 0x1e, 0x01,
+	0x50, 0x05, 0xd2, 0xf4, 0x54, 0x9a, 0x24, 0x4d, 0x4f, 0xd1, 0x77, 0x21, 0xcb, 0xd4, 0x71, 0x73,
+	0x54, 0xa6, 0x86, 0x68, 0x29, 0x7d, 0x38, 0x72, 0x88, 0xc6, 0xf9, 0x55, 0x35, 0xb8, 0x0a, 0x41,
+	0x54, 0x18, 0xd7, 0xad, 0x5e, 0x87, 0x95, 0x31, 0x87, 0x1f, 0xd9, 0x57, 0x25, 0xba, 0xaf, 0xea,
+	0x0a, 0x94, 0x63, 0x7e, 0x5d, 0xbd, 0x00, 0xe7, 0x27, 0x39, 0x68, 0xd5, 0x0a, 0xfa, 0x63, 0x2e,
+	0x16, 0xdd, 0x81, 0x42, 0xe0, 0xa1, 0xc5, 0x55, 0x9c, 0x66, 0x37, 0x5f, 0x44, 0x0b, 0x04, 0xd8,
+	0x4d, 0x64, 0xa7, 0x99, 0x9f, 0x96, 0x34, 0x9f, 0x7e, 0x1e, 0x3b, 0x4e, 0x0b, 0x7b, 0x3d, 0xf5,
+	0xe7, 0x50, 0x9b, 0xe6, 0x77, 0xc7, 0x16, 0x93, 0x0d, 0x0e, 0xe9, 0x05, 0xc8, 0x1d, 0xdb, 0xee,
+	0x00, 0x53, 0xae, 0xac, 0xac, 0x49, 0x8a, 0x1d, 0x5e, 0xe1, 0x83, 0x33, 0xbc, 0x5b, 0x10, 0xaa,
+	0x0e, 0xef, 0x4c, 0xf5, 0xba, 0x4c, 0xc4, 0xb4, 0x0c, 0x22, 0xac, 0x5a, 0xd6, 0x04, 0x11, 0x2a,
+	0x12, 0x93, 0x15, 0x04, 0x1b, 0xd6, 0xe3, 0x2b, 0xe6, 0xfa, 0x8b, 0x9a, 0xa4, 0xd4, 0xbf, 0x14,
+	0xa1, 0xa0, 0x11, 0xcf, 0x61, 0x0e, 0x01, 0xb5, 0xa0, 0x48, 0x4e, 0x3b, 0x44, 0xe0, 0x2a, 0x65,
+	0x0e, 0x0a, 0x11, 0x32, 0x4d, 0x9f, 0x9f, 0x85, 0xfd, 0x40, 0x18, 0xdd, 0x8e, 0x61, 0xca, 0x4b,
+	0xf3, 0x94, 0x44, 0x41, 0xe5, 0xdd, 0x38, 0xa8, 0x7c, 0x7f, 0x8e, 0xec, 0x18, 0xaa, 0xbc, 0x1d,
+	0x43, 0x95, 0xf3, 0x06, 0x8e, 0xc1, 0xca, 0xdd, 0x09, 0xb0, 0x72, 0xde, 0xf2, 0xa7, 0xe0, 0xca,
+	0xdd, 0x09, 0xb8, 0xf2, 0xda, 0xdc, 0xb9, 0x4c, 0x04, 0x96, 0x77, 0xe3, 0xc0, 0x72, 0x9e, 0x39,
+	0xc6, 0x90, 0xe5, 0xc3, 0x49, 0xc8, 0xf2, 0xfa, 0x1c, 0x1d, 0x53, 0xa1, 0xe5, 0xce, 0x19, 0x68,
+	0x79, 0x65, 0x8e, 0xaa, 0x09, 0xd8, 0x72, 0x37, 0x86, 0x2d, 0x21, 0x91, 0x6d, 0xa6, 0x80, 0xcb,
+	0xfb, 0x67, 0xc1, 0xe5, 0xd5, 0x79, 0x47, 0x6d, 0x12, 0xba, 0xfc, 0xe1, 0x18, 0xba, 0xbc, 0x3c,
+	0x6f, 0x55, 0xe3, 0xf0, 0xf2, 0x68, 0x0a, 0xbc, 0xbc, 0x31, 0x47, 0xd1, 0x1c, 0x7c, 0x79, 0x34,
+	0x05, 0x5f, 0xce, 0x53, 0x3b, 0x07, 0x60, 0xb6, 0x67, 0x01, 0xcc, 0x9b, 0xf3, 0xa6, 0x9c, 0x0c,
+	0x61, 0x92, 0x99, 0x08, 0xf3, 0xa3, 0x39, 0x83, 0x2c, 0x0e, 0x31, 0xaf, 0xb3, 0x20, 0x3f, 0xe6,
+	0x92, 0x98, 0x2b, 0x24, 0xae, 0x6b, 0xbb, 0x12, 0xbd, 0x09, 0x42, 0xbd, 0xc6, 0x60, 0x47, 0xe8,
+	0x78, 0x66, 0xc0, 0x51, 0x1e, 0x78, 0x22, 0x6e, 0x46, 0xfd, 0xb3, 0x12, 0xca, 0xf2, 0xe8, 0x1c,
+	0x85, 0x2c, 0x45, 0x09, 0x59, 0x22, 0x28, 0x35, 0x1d, 0x47, 0xa9, 0xeb, 0x50, 0x62, 0xa1, 0x64,
+	0x0c, 0x80, 0x62, 0xc7, 0x07, 0xa0, 0xe8, 0x03, 0x58, 0xe5, 0x18, 0x42, 0x60, 0x59, 0x19, 0x3f,
+	0xb2, 0x3c, 0x18, 0xae, 0xb0, 0x0f, 0xe2, 0xe8, 0x8a, 0x40, 0xf2, 0x6d, 0x38, 0x17, 0xe1, 0x0d,
+	0x42, 0x94, 0x40, 0x5a, 0xd5, 0x80, 0x7b, 0x5b, 0xc6, 0xaa, 0x47, 0xa1, 0x81, 0x42, 0x70, 0x8b,
+	0x20, 0xdb, 0xb1, 0x0d, 0x22, 0x03, 0x08, 0x6f, 0x33, 0xc0, 0xdb, 0xb7, 0xbb, 0x32, 0x4c, 0xb0,
+	0x26, 0xe3, 0x0a, 0x7c, 0x6a, 0x51, 0x38, 0x4b, 0xf5, 0x4f, 0x4a, 0xa8, 0x2f, 0xc4, 0xbb, 0x93,
+	0xa0, 0xa9, 0xf2, 0x26, 0xa1, 0x69, 0xfa, 0x7f, 0x83, 0xa6, 0xea, 0x7f, 0x94, 0x70, 0x4b, 0x03,
+	0xd0, 0xf9, 0xcd, 0x4c, 0x10, 0x86, 0xdf, 0x25, 0xbe, 0x41, 0x32, 0xfc, 0xca, 0x7c, 0x21, 0xc7,
+	0xb7, 0x21, 0x9e, 0x2f, 0xe4, 0x45, 0x40, 0xe6, 0x04, 0xfa, 0x0e, 0x07, 0xab, 0xf6, 0xb1, 0xf4,
+	0xc9, 0x31, 0x40, 0x22, 0x8a, 0x46, 0x1b, 0xb2, 0x5a, 0xb4, 0xcf, 0xd8, 0x34, 0xc1, 0x1d, 0x81,
+	0x15, 0xc5, 0x18, 0xf6, 0x7d, 0x17, 0x8a, 0x6c, 0xea, 0x9e, 0x83, 0x3b, 0x84, 0x3b, 0xd5, 0xa2,
+	0x16, 0x76, 0xa8, 0x06, 0xa0, 0xb3, 0xce, 0x1d, 0x3d, 0x86, 0x1c, 0x39, 0x21, 0x16, 0x65, 0x7b,
+	0xc4, 0xcc, 0xfa, 0xee, 0x54, 0x30, 0x49, 0x2c, 0xda, 0xa8, 0x31, 0x63, 0xfe, 0xeb, 0xeb, 0xf5,
+	0xaa, 0x90, 0xb9, 0x61, 0x0f, 0x4c, 0x4a, 0x06, 0x0e, 0x1d, 0x69, 0x52, 0x8b, 0xfa, 0x9b, 0x34,
+	0xc3, 0x74, 0x31, 0xc7, 0x3f, 0xd1, 0xbc, 0xfe, 0xa5, 0x49, 0x47, 0x70, 0x7e, 0x32, 0x93, 0xbf,
+	0x07, 0xd0, 0xc5, 0x9e, 0xfe, 0x02, 0x5b, 0x94, 0x18, 0xd2, 0xee, 0xc5, 0x2e, 0xf6, 0x7e, 0xc2,
+	0x3b, 0x18, 0x54, 0x63, 0x9f, 0x87, 0x1e, 0x31, 0xf8, 0x06, 0x64, 0xb4, 0x7c, 0x17, 0x7b, 0x47,
+	0x1e, 0x31, 0x22, 0x6b, 0xcd, 0xbf, 0x89, 0xb5, 0xc6, 0xed, 0x5d, 0x18, 0xb7, 0xf7, 0x6f, 0xd3,
+	0xe1, 0xed, 0x08, 0x21, 0xf0, 0xff, 0xa7, 0x2d, 0xfe, 0xc0, 0x13, 0xe3, 0x78, 0xf4, 0x45, 0x9f,
+	0xc0, 0x6a, 0x70, 0x2b, 0xf5, 0x21, 0xbf, 0xad, 0xfe, 0x29, 0x5c, 0xec, 0x72, 0x57, 0x4f, 0xe2,
+	0xdd, 0x1e, 0xfa, 0x14, 0xde, 0x1e, 0xf3, 0x41, 0xc1, 0x00, 0xe9, 0x85, 0x5c, 0xd1, 0x5b, 0x71,
+	0x57, 0xe4, 0xeb, 0x0f, 0xad, 0x97, 0x79, 0x23, 0xb7, 0x66, 0x97, 0xa5, 0x61, 0x51, 0x5c, 0x31,
+	0xf1, 0x4c, 0x5c, 0x82, 0xb2, 0x4b, 0x28, 0x36, 0x2d, 0x3d, 0x96, 0xfa, 0x2e, 0x8b, 0x4e, 0x11,
+	0x12, 0xd4, 0xa7, 0xf0, 0xd6, 0x44, 0x64, 0x81, 0xbe, 0x0f, 0xc5, 0x10, 0x9a, 0x28, 0x33, 0x33,
+	0xc7, 0x20, 0x03, 0x0a, 0x25, 0xd4, 0x2f, 0x94, 0x50, 0x71, 0x3c, 0xb3, 0x7a, 0x00, 0x39, 0x97,
+	0x78, 0xc3, 0xbe, 0xc8, 0x72, 0x2a, 0x5b, 0x1f, 0x2f, 0x82, 0x4c, 0x58, 0xef, 0xb0, 0x4f, 0x35,
+	0xa9, 0x42, 0x7d, 0x02, 0x39, 0xd1, 0x83, 0x00, 0x72, 0xdb, 0x3b, 0x3b, 0xcd, 0xfd, 0xc3, 0x6a,
+	0x0a, 0x15, 0x61, 0x69, 0xbb, 0xb1, 0xa7, 0x1d, 0x56, 0x15, 0xd6, 0xad, 0x35, 0x7f, 0xdc, 0xdc,
+	0x39, 0xac, 0xa6, 0xd1, 0x2a, 0x94, 0x45, 0x5b, 0xbf, 0xbf, 0xa7, 0x3d, 0xda, 0x3e, 0xac, 0x66,
+	0x22, 0x5d, 0x07, 0xcd, 0xc7, 0xf7, 0x9a, 0x5a, 0x35, 0xab, 0x7e, 0xc4, 0xf2, 0xa7, 0x29, 0xc0,
+	0x25, 0xcc, 0x94, 0x94, 0x48, 0xa6, 0xa4, 0xfe, 0x2e, 0x0d, 0xf5, 0xe9, 0x38, 0x04, 0xed, 0x8f,
+	0xad, 0xf8, 0xd6, 0xc2, 0x50, 0x66, 0x6c, 0xd9, 0xe8, 0x32, 0x54, 0x5c, 0x72, 0x4c, 0x68, 0xa7,
+	0x27, 0x30, 0x92, 0x88, 0x72, 0x65, 0xad, 0x2c, 0x7b, 0xb9, 0x90, 0x27, 0xd8, 0x3e, 0x23, 0x1d,
+	0xaa, 0x8b, 0xd4, 0x4d, 0x9c, 0xbf, 0x22, 0x63, 0x63, 0xbd, 0x07, 0xa2, 0x53, 0x3d, 0x98, 0x67,
+	0xc4, 0x22, 0x2c, 0x69, 0xcd, 0x43, 0xed, 0x93, 0x6a, 0x1a, 0x21, 0xa8, 0xf0, 0xa6, 0x7e, 0xf0,
+	0x78, 0x7b, 0xff, 0xa0, 0xb5, 0xc7, 0x8c, 0x78, 0x0e, 0x56, 0x7c, 0x23, 0xfa, 0x9d, 0x59, 0xf5,
+	0xaf, 0x0a, 0xac, 0x8c, 0x5d, 0x0f, 0x74, 0x0b, 0x96, 0x04, 0xf0, 0x56, 0x66, 0x16, 0xf0, 0xf9,
+	0x7d, 0x97, 0x37, 0x4a, 0x08, 0xa0, 0x06, 0x14, 0x88, 0xac, 0x4f, 0x4c, 0xba, 0x92, 0xd1, 0x4a,
+	0x8b, 0x5f, 0xc7, 0x90, 0x0a, 0x02, 0x39, 0xd4, 0x84, 0x62, 0x70, 0xf3, 0x65, 0xa6, 0x78, 0x75,
+	0x9a, 0x92, 0xc0, 0x73, 0x48, 0x2d, 0xa1, 0xa4, 0xba, 0x03, 0xa5, 0xc8, 0x04, 0xd1, 0xb7, 0xa0,
+	0x38, 0xc0, 0xa7, 0xb2, 0x66, 0x25, 0x8a, 0x10, 0x85, 0x01, 0x3e, 0xe5, 0xe5, 0x2a, 0xf4, 0x36,
+	0xe4, 0xd9, 0xc7, 0x2e, 0x16, 0x8e, 0x24, 0xa3, 0xe5, 0x06, 0xf8, 0xf4, 0x47, 0xd8, 0x53, 0x3b,
+	0x50, 0x89, 0x97, 0x72, 0xd8, 0xc9, 0x72, 0xed, 0xa1, 0x65, 0x70, 0x1d, 0x4b, 0x9a, 0x20, 0xd0,
+	0x1d, 0x58, 0x3a, 0xb1, 0x85, 0x1f, 0x9a, 0x75, 0x03, 0x9f, 0xda, 0x94, 0x44, 0x0a, 0x42, 0x42,
+	0x46, 0x7d, 0x0c, 0x15, 0xee, 0x51, 0xb6, 0x29, 0x75, 0xcd, 0xf6, 0x90, 0x92, 0x68, 0x65, 0x72,
+	0x79, 0x42, 0x65, 0x32, 0x40, 0x1a, 0x01, 0x4e, 0xc9, 0x88, 0xb2, 0x18, 0x27, 0xd4, 0x5f, 0x29,
+	0xb0, 0xc4, 0x15, 0x32, 0x77, 0xc3, 0xab, 0x3c, 0x12, 0xc3, 0xb2, 0x36, 0xea, 0x00, 0x60, 0x7f,
+	0x20, 0x7f, 0xbe, 0x97, 0x67, 0x39, 0xba, 0x60, 0x5a, 0x8d, 0x77, 0xa5, 0xc7, 0x3b, 0x1f, 0x2a,
+	0x88, 0x78, 0xbd, 0x88, 0x5a, 0xf5, 0xa5, 0x02, 0x85, 0xc3, 0x53, 0x79, 0x5a, 0xa7, 0x14, 0x7f,
+	0xd8, 0xec, 0x77, 0xf9, 0xec, 0x45, 0xb9, 0x44, 0x10, 0xb2, 0x9a, 0x94, 0x09, 0x2a, 0x55, 0xf7,
+	0x83, 0x5b, 0x99, 0x5d, 0x2c, 0xa1, 0xf4, 0x8b, 0x78, 0xd2, 0x05, 0xf5, 0x21, 0xcf, 0xcf, 0xc3,
+	0xee, 0xbd, 0x89, 0x15, 0xc2, 0x47, 0xb0, 0xec, 0x60, 0x97, 0x7a, 0x7a, 0xac, 0x4e, 0x38, 0x2d,
+	0x27, 0xdf, 0xc7, 0x2e, 0x3d, 0x20, 0x34, 0x56, 0x2d, 0x2c, 0x71, 0x79, 0xd1, 0xa5, 0xde, 0x86,
+	0x72, 0x8c, 0x87, 0x2d, 0x96, 0xda, 0x14, 0xf7, 0xfd, 0x73, 0xc3, 0x89, 0x60, 0x26, 0xe9, 0x70,
+	0x26, 0xea, 0x1d, 0x28, 0x06, 0xc7, 0x9a, 0x65, 0x1c, 0xd8, 0x30, 0x5c, 0xe2, 0x79, 0x72, 0xb6,
+	0x3e, 0xc9, 0x4b, 0xa2, 0xf6, 0x0b, 0x59, 0xf5, 0xc9, 0x68, 0x82, 0x50, 0x09, 0xac, 0x8c, 0x45,
+	0x53, 0x74, 0x17, 0xf2, 0xce, 0xb0, 0xad, 0xfb, 0x07, 0xaa, 0xb4, 0xf5, 0xde, 0xb4, 0x45, 0x0d,
+	0xdb, 0x0f, 0xc8, 0xc8, 0x37, 0x9b, 0xc3, 0xa9, 0x70, 0x98, 0x74, 0x74, 0x98, 0x5f, 0x42, 0xc1,
+	0x3f, 0xcb, 0xe8, 0x5e, 0xf4, 0xbe, 0x8a, 0x11, 0x2e, 0xce, 0x0b, 0xf4, 0x72, 0x90, 0x50, 0x90,
+	0xe5, 0x47, 0x9e, 0xd9, 0xb5, 0x88, 0xa1, 0x87, 0xa9, 0x0f, 0x1f, 0xb3, 0xa0, 0xad, 0x88, 0x0f,
+	0x0f, 0xfd, 0xbc, 0x47, 0xbd, 0x09, 0x39, 0x31, 0xd7, 0x89, 0x07, 0x7c, 0x42, 0x8c, 0x55, 0xff,
+	0xa9, 0x40, 0xc1, 0x77, 0x38, 0x13, 0x85, 0x62, 0x8b, 0x48, 0x7f, 0xd3, 0x45, 0x4c, 0x2b, 0x5f,
+	0xfb, 0x8f, 0x05, 0xd9, 0x85, 0x1f, 0x0b, 0x6e, 0x00, 0xe2, 0x27, 0x45, 0x3f, 0xb1, 0xa9, 0x69,
+	0x75, 0x75, 0xb1, 0x17, 0x02, 0x12, 0x56, 0xf9, 0x97, 0xa7, 0xfc, 0xc3, 0x3e, 0xdf, 0x96, 0x5f,
+	0x2b, 0x50, 0x08, 0x02, 0xf8, 0xa2, 0x65, 0xca, 0x0b, 0x90, 0x93, 0x41, 0x4a, 0xd4, 0x29, 0x25,
+	0x15, 0x9c, 0xd1, 0x6c, 0xe4, 0xb6, 0xd4, 0xa1, 0x30, 0x20, 0x14, 0x73, 0x3b, 0x8b, 0xb4, 0x34,
+	0xa0, 0x3f, 0xb8, 0x04, 0xa5, 0x48, 0xdd, 0x18, 0xe5, 0x21, 0xf3, 0x98, 0xbc, 0xa8, 0xa6, 0x50,
+	0x09, 0xf2, 0x1a, 0xe1, 0xa5, 0xa2, 0xaa, 0xb2, 0xf5, 0x45, 0x09, 0x56, 0xb6, 0x1b, 0x3b, 0xbb,
+	0x2c, 0x86, 0x9a, 0x1d, 0xcc, 0x53, 0xd6, 0x3d, 0xc8, 0xf2, 0xac, 0x3d, 0xc1, 0x3b, 0x75, 0x3d,
+	0x49, 0xdd, 0x11, 0x69, 0xb0, 0xc4, 0x93, 0x7b, 0x94, 0xe4, 0xf9, 0xba, 0x9e, 0xa8, 0x1c, 0xc9,
+	0x26, 0xc9, 0x4f, 0x7d, 0x82, 0x57, 0xed, 0x7a, 0x92, 0x1a, 0x25, 0xfa, 0x14, 0x8a, 0x61, 0xd6,
+	0x9e, 0xf4, 0xad, 0xbb, 0x9e, 0xb8, 0x7a, 0xc9, 0xf4, 0x87, 0x79, 0x4a, 0xd2, 0x97, 0xde, 0x7a,
+	0x62, 0x2f, 0x8b, 0x9e, 0x41, 0xde, 0xcf, 0x08, 0x93, 0xbd, 0x46, 0xd7, 0x13, 0x56, 0x16, 0xd9,
+	0xf6, 0x89, 0x44, 0x3e, 0xc9, 0x93, 0x7b, 0x3d, 0x51, 0xf9, 0x14, 0x1d, 0x41, 0x4e, 0x42, 0xf1,
+	0x44, 0xef, 0xcc, 0xf5, 0x64, 0xf5, 0x42, 0x66, 0xe4, 0xb0, 0x54, 0x92, 0xf4, 0x67, 0x06, 0xf5,
+	0xc4, 0x75, 0x63, 0x84, 0x01, 0x22, 0xd9, 0x7d, 0xe2, 0xdf, 0x0f, 0xd4, 0x93, 0xd7, 0x83, 0xd1,
+	0xcf, 0xa0, 0x10, 0xe4, 0x70, 0x09, 0xdf, 0xf1, 0xeb, 0x49, 0x4b, 0xb2, 0xe8, 0x33, 0x28, 0xc7,
+	0xd3, 0x96, 0x45, 0x5e, 0xe7, 0xeb, 0x0b, 0xd5, 0x5a, 0xd9, 0x58, 0xf1, 0x4c, 0x66, 0x91, 0x37,
+	0xfb, 0xfa, 0x42, 0x05, 0x58, 0x74, 0x02, 0xab, 0x67, 0x93, 0x8f, 0x45, 0x1f, 0xf2, 0xeb, 0x0b,
+	0x17, 0x66, 0xd1, 0x08, 0xd0, 0x84, 0x04, 0x66, 0xe1, 0xd7, 0xfd, 0xfa, 0xe2, 0xd5, 0xda, 0x46,
+	0xf3, 0xcb, 0x57, 0x6b, 0xca, 0x57, 0xaf, 0xd6, 0x94, 0x7f, 0xbc, 0x5a, 0x53, 0x5e, 0xbe, 0x5e,
+	0x4b, 0x7d, 0xf5, 0x7a, 0x2d, 0xf5, 0xb7, 0xd7, 0x6b, 0xa9, 0x9f, 0x7e, 0xd8, 0x35, 0x69, 0x6f,
+	0xd8, 0xde, 0xe8, 0xd8, 0x83, 0xcd, 0x50, 0x6d, 0xb4, 0x19, 0xfe, 0xc2, 0xaa, 0x9d, 0xe3, 0xc1,
+	0xef, 0xe3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x31, 0x8d, 0x36, 0x76, 0x25, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -6310,79 +6194,6 @@ func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *EvidenceParams) 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 *EvidenceParams) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.MaxNum != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.MaxNum))
-		i--
-		dAtA[i] = 0x18
-	}
-	n45, err45 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
-	if err45 != nil {
-		return 0, err45
-	}
-	i -= n45
-	i = encodeVarintTypes(dAtA, i, uint64(n45))
-	i--
-	dAtA[i] = 0x12
-	if m.MaxAgeNumBlocks != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.MaxAgeNumBlocks))
-		i--
-		dAtA[i] = 0x8
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *ValidatorParams) 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 *ValidatorParams) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.PubKeyTypes) > 0 {
-		for iNdEx := len(m.PubKeyTypes) - 1; iNdEx >= 0; iNdEx-- {
-			i -= len(m.PubKeyTypes[iNdEx])
-			copy(dAtA[i:], m.PubKeyTypes[iNdEx])
-			i = encodeVarintTypes(dAtA, i, uint64(len(m.PubKeyTypes[iNdEx])))
-			i--
-			dAtA[i] = 0xa
-		}
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *LastCommitInfo) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -6819,12 +6630,12 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x28
 	}
-	n50, err50 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
-	if err50 != nil {
-		return 0, err50
+	n49, err49 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
+	if err49 != nil {
+		return 0, err49
 	}
-	i -= n50
-	i = encodeVarintTypes(dAtA, i, uint64(n50))
+	i -= n49
+	i = encodeVarintTypes(dAtA, i, uint64(n49))
 	i--
 	dAtA[i] = 0x22
 	if m.Height != 0 {
@@ -7938,38 +7749,6 @@ func (m *BlockParams) Size() (n int) {
 	return n
 }
 
-func (m *EvidenceParams) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.MaxAgeNumBlocks != 0 {
-		n += 1 + sovTypes(uint64(m.MaxAgeNumBlocks))
-	}
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration)
-	n += 1 + l + sovTypes(uint64(l))
-	if m.MaxNum != 0 {
-		n += 1 + sovTypes(uint64(m.MaxNum))
-	}
-	return n
-}
-
-func (m *ValidatorParams) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.PubKeyTypes) > 0 {
-		for _, s := range m.PubKeyTypes {
-			l = len(s)
-			n += 1 + l + sovTypes(uint64(l))
-		}
-	}
-	return n
-}
-
 func (m *LastCommitInfo) Size() (n int) {
 	if m == nil {
 		return 0
@@ -13473,7 +13252,7 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Evidence == nil {
-				m.Evidence = &EvidenceParams{}
+				m.Evidence = &types.EvidenceParams{}
 			}
 			if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -13509,7 +13288,7 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Validator == nil {
-				m.Validator = &ValidatorParams{}
+				m.Validator = &types.ValidatorParams{}
 			}
 			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
@@ -13630,215 +13409,6 @@ func (m *BlockParams) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *EvidenceParams) 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 ErrIntOverflowTypes
-			}
-			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: EvidenceParams: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EvidenceParams: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxAgeNumBlocks", wireType)
-			}
-			m.MaxAgeNumBlocks = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MaxAgeNumBlocks |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxAgeDuration", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxAgeDuration, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MaxNum", wireType)
-			}
-			m.MaxNum = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MaxNum |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ValidatorParams) 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 ErrIntOverflowTypes
-			}
-			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: ValidatorParams: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorParams: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PubKeyTypes", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				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 ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.PubKeyTypes = append(m.PubKeyTypes, string(dAtA[iNdEx:postIndex]))
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *LastCommitInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

abci/types/types.proto

@@ -6,7 +6,7 @@ option  go_package = "github.com/tendermint/tendermint/abci/types";
 // https://github.com/gogo/protobuf/blob/master/extensions.md
 import "crypto/merkle/merkle.proto";
 import "proto/types/types.proto";
-import "google/protobuf/duration.proto";
+import "proto/types/params.proto";
 import "google/protobuf/timestamp.proto";
 import "third_party/proto/gogoproto/gogo.proto";
 
@@ -277,8 +277,8 @@ message ResponseApplySnapshotChunk {
 // that can be adjusted by the abci app
 message ConsensusParams {
   BlockParams     block     = 1;
-  EvidenceParams  evidence  = 2;
-  ValidatorParams validator = 3;
+  tendermint.proto.types.EvidenceParams  evidence  = 2;
+  tendermint.proto.types.ValidatorParams validator = 3;
 }
 
 // BlockParams contains limits on the block size.
@@ -289,19 +289,6 @@ message BlockParams {
   int64 max_gas = 2;
 }
 
-message EvidenceParams {
-  // Note: must be greater than 0
-  int64                    max_age_num_blocks = 1;
-  google.protobuf.Duration max_age_duration   = 2
-    [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
-  uint32                   max_num            = 3;
-}
-
-// ValidatorParams contains limits on validators.
-message ValidatorParams {
-  repeated string pub_key_types = 1;
-}
-
 message LastCommitInfo {
   int32             round = 1;
   repeated VoteInfo votes = 2 [(gogoproto.nullable) = false];

consensus/replay.go

@@ -334,7 +334,7 @@ func (h *Handshaker) ReplayBlocks(
 			}
 
 			if res.ConsensusParams != nil {
-				state.ConsensusParams = state.ConsensusParams.Update(res.ConsensusParams)
+				state.ConsensusParams = types.UpdateConsensusParams(state.ConsensusParams, res.ConsensusParams)
 			}
 			sm.SaveState(h.stateDB, state)
 		}

consensus/replay_test.go

@@ -1099,14 +1099,14 @@ func stateAndStore(
 
 type mockBlockStore struct {
 	config  *cfg.Config
-	params  types.ConsensusParams
+	params  tmproto.ConsensusParams
 	chain   []*types.Block
 	commits []*types.Commit
 	base    int64
 }
 
 // TODO: NewBlockStore(db.NewMemDB) ...
-func newMockBlockStore(config *cfg.Config, params types.ConsensusParams) *mockBlockStore {
+func newMockBlockStore(config *cfg.Config, params tmproto.ConsensusParams) *mockBlockStore {
 	return &mockBlockStore{config, params, nil, nil, 0}
 }
 

evidence/pool_test.go

@@ -10,6 +10,7 @@ import (
 
 	dbm "github.com/tendermint/tm-db"
 
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
@@ -294,12 +295,12 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
 		Validators:                  valSet,
 		NextValidators:              valSet.CopyIncrementProposerPriority(1),
 		LastHeightValidatorsChanged: 1,
-		ConsensusParams: types.ConsensusParams{
-			Block: types.BlockParams{
+		ConsensusParams: tmproto.ConsensusParams{
+			Block: tmproto.BlockParams{
 				MaxBytes: 22020096,
 				MaxGas:   -1,
 			},
-			Evidence: types.EvidenceParams{
+			Evidence: tmproto.EvidenceParams{
 				MaxAgeNumBlocks: 20,
 				MaxAgeDuration:  48 * time.Hour,
 			},

light/rpc/client.go

@@ -163,7 +163,7 @@ func (c *Client) ConsensusParams(height *int64) (*ctypes.ResultConsensusParams,
 	}
 
 	// Validate res.
-	if err := res.ConsensusParams.Validate(); err != nil {
+	if err := types.ValidateConsensusParams(res.ConsensusParams); err != nil {
 		return nil, err
 	}
 	if res.BlockHeight <= 0 {
@@ -177,7 +177,7 @@ func (c *Client) ConsensusParams(height *int64) (*ctypes.ResultConsensusParams,
 	}
 
 	// Verify hash.
-	if cH, tH := res.ConsensusParams.Hash(), h.ConsensusHash; !bytes.Equal(cH, tH) {
+	if cH, tH := types.HashConsensusParams(res.ConsensusParams), h.ConsensusHash; !bytes.Equal(cH, tH) {
 		return nil, fmt.Errorf("params hash %X does not match trusted hash %X",
 			cH, tH)
 	}

proto/crypto/keys/types.pb.go

@@ -8,6 +8,7 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	golang_proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -15,6 +16,7 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
+var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
@@ -175,13 +177,18 @@ func (*PrivateKey) XXX_OneofWrappers() []interface{} {
 
 func init() {
 	proto.RegisterType((*PublicKey)(nil), "tendermint.proto.crypto.keys.PublicKey")
+	golang_proto.RegisterType((*PublicKey)(nil), "tendermint.proto.crypto.keys.PublicKey")
 	proto.RegisterType((*PrivateKey)(nil), "tendermint.proto.crypto.keys.PrivateKey")
+	golang_proto.RegisterType((*PrivateKey)(nil), "tendermint.proto.crypto.keys.PrivateKey")
 }
 
 func init() { proto.RegisterFile("proto/crypto/keys/types.proto", fileDescriptor_943d79b57ec0188f) }
+func init() {
+	golang_proto.RegisterFile("proto/crypto/keys/types.proto", fileDescriptor_943d79b57ec0188f)
+}
 
 var fileDescriptor_943d79b57ec0188f = []byte{
-	// 215 bytes of a gzipped FileDescriptorProto
+	// 220 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2d, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0xcf, 0x4e, 0xad, 0x2c, 0xd6, 0x2f, 0xa9,
 	0x2c, 0x48, 0x2d, 0xd6, 0x03, 0x8b, 0x0b, 0xc9, 0x94, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66,
@@ -191,11 +198,11 @@ var fileDescriptor_943d79b57ec0188f = []byte{
 	0x52, 0x5c, 0xec, 0xa9, 0x29, 0x46, 0xa6, 0xa6, 0x86, 0x96, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c,
 	0x1e, 0x0c, 0x41, 0x30, 0x01, 0x2b, 0x8e, 0x17, 0x0b, 0xe4, 0x19, 0x5f, 0x2c, 0x94, 0x67, 0x74,
 	0x62, 0xe5, 0x62, 0x2e, 0x2e, 0xcd, 0x55, 0xd2, 0xe7, 0xe2, 0x0a, 0x28, 0xca, 0x2c, 0x4b, 0x2c,
-	0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0xc9, 0xe7, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
-	0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5,
-	0x18, 0xa2, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x11, 0xbe,
-	0x42, 0x66, 0x62, 0x04, 0x45, 0x12, 0x1b, 0x58, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x85,
-	0x0d, 0xee, 0x82, 0x26, 0x01, 0x00, 0x00,
+	0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0x29, 0xe0, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
+	0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc0, 0x63, 0x39, 0xc6, 0x0b, 0x8f, 0xe5,
+	0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce,
+	0xcf, 0xd5, 0x47, 0xf8, 0x0c, 0x99, 0x89, 0x11, 0x1c, 0x49, 0x6c, 0x60, 0x21, 0x63, 0x40, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0xc1, 0xcf, 0x98, 0xcb, 0x2a, 0x01, 0x00, 0x00,
 }
 
 func (this *PublicKey) Compare(that interface{}) int {

proto/crypto/keys/types.proto

@@ -5,6 +5,11 @@ option go_package = "github.com/tendermint/tendermint/proto/crypto/keys";
 
 import "third_party/proto/gogoproto/gogo.proto";
 
+option (gogoproto.marshaler_all)        = true;
+option (gogoproto.unmarshaler_all)      = true;
+option (gogoproto.sizer_all)            = true;
+option (gogoproto.goproto_registration) = true;
+
 // PublicKey defines the keys available for use with Tendermint Validators
 message PublicKey {
   option (gogoproto.compare) = true;

proto/types/params.pb.go

@@ -8,6 +8,7 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
+	golang_proto "github.com/golang/protobuf/proto"
 	_ "github.com/golang/protobuf/ptypes/duration"
 	io "io"
 	math "math"
@@ -17,6 +18,7 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
+var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 var _ = time.Kitchen
@@ -331,48 +333,54 @@ func (m *HashedParams) GetBlockMaxGas() int64 {
 
 func init() {
 	proto.RegisterType((*ConsensusParams)(nil), "tendermint.proto.types.ConsensusParams")
+	golang_proto.RegisterType((*ConsensusParams)(nil), "tendermint.proto.types.ConsensusParams")
 	proto.RegisterType((*BlockParams)(nil), "tendermint.proto.types.BlockParams")
+	golang_proto.RegisterType((*BlockParams)(nil), "tendermint.proto.types.BlockParams")
 	proto.RegisterType((*EvidenceParams)(nil), "tendermint.proto.types.EvidenceParams")
+	golang_proto.RegisterType((*EvidenceParams)(nil), "tendermint.proto.types.EvidenceParams")
 	proto.RegisterType((*ValidatorParams)(nil), "tendermint.proto.types.ValidatorParams")
+	golang_proto.RegisterType((*ValidatorParams)(nil), "tendermint.proto.types.ValidatorParams")
 	proto.RegisterType((*HashedParams)(nil), "tendermint.proto.types.HashedParams")
+	golang_proto.RegisterType((*HashedParams)(nil), "tendermint.proto.types.HashedParams")
 }
 
 func init() { proto.RegisterFile("proto/types/params.proto", fileDescriptor_95a9f934fa6f056c) }
+func init() { golang_proto.RegisterFile("proto/types/params.proto", fileDescriptor_95a9f934fa6f056c) }
 
 var fileDescriptor_95a9f934fa6f056c = []byte{
-	// 497 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xc1, 0x6e, 0xd3, 0x4a,
-	0x14, 0xcd, 0x3c, 0x3f, 0x4a, 0x72, 0xd3, 0x34, 0x68, 0x16, 0x60, 0x8a, 0xe4, 0x46, 0x46, 0x0a,
-	0x95, 0x40, 0xb6, 0x04, 0x62, 0x8d, 0x30, 0xa0, 0x16, 0xaa, 0x54, 0xc8, 0x42, 0x2c, 0xba, 0xb1,
-	0xc6, 0xf1, 0xe0, 0x58, 0xcd, 0x78, 0x2c, 0xcf, 0x4c, 0x15, 0xff, 0x05, 0x4b, 0x7e, 0x00, 0x89,
-	0x4f, 0xe9, 0xb2, 0x4b, 0x56, 0x80, 0x92, 0x15, 0x7f, 0x81, 0x3c, 0xce, 0xe0, 0xa4, 0xa2, 0xbb,
-	0x99, 0x7b, 0xcf, 0x39, 0x73, 0xcf, 0xb9, 0x36, 0xd8, 0x45, 0xc9, 0x25, 0xf7, 0x65, 0x55, 0x50,
-	0xe1, 0x17, 0xa4, 0x24, 0x4c, 0x78, 0xba, 0x84, 0xef, 0x4a, 0x9a, 0x27, 0xb4, 0x64, 0x59, 0x2e,
-	0x9b, 0x8a, 0xa7, 0x41, 0xfb, 0x63, 0x39, 0xcb, 0xca, 0x24, 0x2a, 0x48, 0x29, 0x2b, 0xbf, 0x61,
-	0xa7, 0x3c, 0xe5, 0xed, 0xa9, 0x41, 0xef, 0x3b, 0x29, 0xe7, 0xe9, 0x9c, 0x36, 0x90, 0x58, 0x7d,
-	0xf2, 0x13, 0x55, 0x12, 0x99, 0xf1, 0xbc, 0xe9, 0xbb, 0xbf, 0x11, 0x0c, 0x5f, 0xf1, 0x5c, 0xd0,
-	0x5c, 0x28, 0xf1, 0x5e, 0xbf, 0x8c, 0x5f, 0xc0, 0xad, 0x78, 0xce, 0xa7, 0xe7, 0x36, 0x1a, 0xa1,
-	0xc3, 0xfe, 0xd3, 0x87, 0xde, 0xbf, 0x67, 0xf0, 0x82, 0x1a, 0xd4, 0x70, 0x82, 0xff, 0x2f, 0x7f,
-	0x1c, 0x74, 0xc2, 0x86, 0x87, 0x8f, 0xa1, 0x4b, 0x2f, 0xb2, 0x84, 0xe6, 0x53, 0x6a, 0xff, 0xa7,
-	0x35, 0xc6, 0x37, 0x69, 0xbc, 0x59, 0xe3, 0xb6, 0x64, 0xfe, 0xb2, 0xf1, 0x09, 0xf4, 0x2e, 0xc8,
-	0x3c, 0x4b, 0x88, 0xe4, 0xa5, 0x6d, 0x69, 0xa9, 0x47, 0x37, 0x49, 0x7d, 0x34, 0xc0, 0x2d, 0xad,
-	0x96, 0xef, 0x52, 0xe8, 0x6f, 0x8c, 0x8c, 0x1f, 0x40, 0x8f, 0x91, 0x45, 0x14, 0x57, 0x92, 0x0a,
-	0x6d, 0xd5, 0x0a, 0xbb, 0x8c, 0x2c, 0x82, 0xfa, 0x8e, 0xef, 0xc1, 0xed, 0xba, 0x99, 0x12, 0xa1,
-	0x1d, 0x58, 0xe1, 0x0e, 0x23, 0x8b, 0x23, 0x22, 0xf0, 0x08, 0x76, 0x65, 0xc6, 0x68, 0x94, 0x71,
-	0x49, 0x22, 0x26, 0xf4, 0x50, 0x56, 0x08, 0x75, 0xed, 0x2d, 0x97, 0x64, 0x22, 0xdc, 0xaf, 0x08,
-	0xf6, 0xb6, 0x6d, 0xe1, 0xc7, 0x80, 0x6b, 0x35, 0x92, 0xd2, 0x28, 0x57, 0x2c, 0xd2, 0x29, 0x99,
-	0x37, 0x87, 0x8c, 0x2c, 0x5e, 0xa6, 0xf4, 0x54, 0x31, 0x3d, 0x9c, 0xc0, 0x13, 0xb8, 0x63, 0xc0,
-	0x66, 0x59, 0xeb, 0x14, 0xef, 0x7b, 0xcd, 0x36, 0x3d, 0xb3, 0x4d, 0xef, 0xf5, 0x1a, 0x10, 0x74,
-	0x6b, 0xb3, 0x5f, 0x7e, 0x1e, 0xa0, 0x70, 0xaf, 0xd1, 0x33, 0x1d, 0xe3, 0x24, 0x57, 0x4c, 0xcf,
-	0x3a, 0xd0, 0x4e, 0x4e, 0x15, 0x73, 0x9f, 0xc3, 0xf0, 0x5a, 0x64, 0xd8, 0x85, 0x41, 0xa1, 0xe2,
-	0xe8, 0x9c, 0x56, 0x91, 0xce, 0xd4, 0x46, 0x23, 0xeb, 0xb0, 0x17, 0xf6, 0x0b, 0x15, 0x9f, 0xd0,
-	0xea, 0x43, 0x5d, 0x72, 0xcf, 0x60, 0xf7, 0x98, 0x88, 0x19, 0x4d, 0xd6, 0x9c, 0x31, 0x0c, 0xb5,
-	0x9f, 0xe8, 0x7a, 0x98, 0x03, 0x5d, 0x9e, 0x98, 0x44, 0x5d, 0x18, 0xb4, 0xb8, 0x36, 0xd7, 0xbe,
-	0x41, 0x1d, 0x11, 0x11, 0xbc, 0xfb, 0xb6, 0x74, 0xd0, 0xe5, 0xd2, 0x41, 0x57, 0x4b, 0x07, 0xfd,
-	0x5a, 0x3a, 0xe8, 0xf3, 0xca, 0xe9, 0x5c, 0xad, 0x9c, 0xce, 0xf7, 0x95, 0xd3, 0x39, 0x7b, 0x92,
-	0x66, 0x72, 0xa6, 0x62, 0x6f, 0xca, 0x99, 0xdf, 0x7e, 0x03, 0x9b, 0xc7, 0x8d, 0xdf, 0x28, 0xde,
-	0xd1, 0x97, 0x67, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x1a, 0x4c, 0x9f, 0x5c, 0x03, 0x00,
-	0x00,
+	// 512 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0x31, 0x6f, 0xd3, 0x40,
+	0x14, 0xce, 0x61, 0x28, 0xe9, 0x4b, 0xd3, 0xa0, 0x1b, 0xc0, 0x14, 0xc9, 0x89, 0x8c, 0x14, 0x2a,
+	0x81, 0x6c, 0x09, 0x36, 0x96, 0x0a, 0x03, 0x6a, 0x51, 0x95, 0x08, 0x59, 0x88, 0xa1, 0x8b, 0x75,
+	0x8e, 0x0f, 0xc7, 0x6a, 0xce, 0x67, 0xf9, 0xee, 0xaa, 0xf8, 0x5f, 0x30, 0x32, 0x76, 0x41, 0xe2,
+	0x27, 0x30, 0x32, 0x76, 0xec, 0xc8, 0x04, 0x28, 0x59, 0xe0, 0x5f, 0x20, 0x9f, 0x63, 0x9c, 0x54,
+	0x74, 0xbb, 0x7b, 0xef, 0xfb, 0xbe, 0x7b, 0xdf, 0xf7, 0x6c, 0x30, 0xb3, 0x9c, 0x4b, 0xee, 0xca,
+	0x22, 0xa3, 0xc2, 0xcd, 0x48, 0x4e, 0x98, 0x70, 0x74, 0x09, 0xdf, 0x95, 0x34, 0x8d, 0x68, 0xce,
+	0x92, 0x54, 0x56, 0x15, 0x47, 0x83, 0xf6, 0x86, 0x72, 0x9a, 0xe4, 0x51, 0x90, 0x91, 0x5c, 0x16,
+	0x6e, 0xc5, 0x8e, 0x79, 0xcc, 0x9b, 0x53, 0x85, 0xde, 0xb3, 0x62, 0xce, 0xe3, 0x19, 0xad, 0x20,
+	0xa1, 0xfa, 0xe0, 0x46, 0x2a, 0x27, 0x32, 0xe1, 0x69, 0xd5, 0xb7, 0xff, 0x20, 0xe8, 0xbd, 0xe4,
+	0xa9, 0xa0, 0xa9, 0x50, 0xe2, 0xad, 0x7e, 0x19, 0x1f, 0xc0, 0xad, 0x70, 0xc6, 0x27, 0xa7, 0x26,
+	0x1a, 0xa0, 0xfd, 0xce, 0xd3, 0x87, 0xce, 0xff, 0x67, 0x70, 0xbc, 0x12, 0x54, 0x71, 0xbc, 0x9b,
+	0x17, 0x3f, 0xfa, 0x2d, 0xbf, 0xe2, 0xe1, 0x23, 0x68, 0xd3, 0xb3, 0x24, 0xa2, 0xe9, 0x84, 0x9a,
+	0x37, 0xb4, 0xc6, 0xf0, 0x3a, 0x8d, 0xd7, 0x2b, 0xdc, 0x86, 0xcc, 0x3f, 0x36, 0x3e, 0x86, 0xed,
+	0x33, 0x32, 0x4b, 0x22, 0x22, 0x79, 0x6e, 0x1a, 0x5a, 0xea, 0xd1, 0x75, 0x52, 0xef, 0x6b, 0xe0,
+	0x86, 0x56, 0xc3, 0xb7, 0x29, 0x74, 0xd6, 0x46, 0xc6, 0x0f, 0x60, 0x9b, 0x91, 0x79, 0x10, 0x16,
+	0x92, 0x0a, 0x6d, 0xd5, 0xf0, 0xdb, 0x8c, 0xcc, 0xbd, 0xf2, 0x8e, 0xef, 0xc1, 0xed, 0xb2, 0x19,
+	0x13, 0xa1, 0x1d, 0x18, 0xfe, 0x16, 0x23, 0xf3, 0x43, 0x22, 0xf0, 0x00, 0x76, 0x64, 0xc2, 0x68,
+	0x90, 0x70, 0x49, 0x02, 0x26, 0xf4, 0x50, 0x86, 0x0f, 0x65, 0xed, 0x0d, 0x97, 0x64, 0x24, 0xec,
+	0xcf, 0x08, 0x76, 0x37, 0x6d, 0xe1, 0xc7, 0x80, 0x4b, 0x35, 0x12, 0xd3, 0x20, 0x55, 0x2c, 0xd0,
+	0x29, 0xd5, 0x6f, 0xf6, 0x18, 0x99, 0xbf, 0x88, 0xe9, 0x58, 0x31, 0x3d, 0x9c, 0xc0, 0x23, 0xb8,
+	0x53, 0x83, 0xeb, 0x65, 0xad, 0x52, 0xbc, 0xef, 0x54, 0xdb, 0x74, 0xea, 0x6d, 0x3a, 0xaf, 0x56,
+	0x00, 0xaf, 0x5d, 0x9a, 0xfd, 0xf4, 0xb3, 0x8f, 0xfc, 0xdd, 0x4a, 0xaf, 0xee, 0xd4, 0x4e, 0x52,
+	0xc5, 0xf4, 0xac, 0x5d, 0xed, 0x64, 0xac, 0x98, 0x7d, 0x00, 0xbd, 0x2b, 0x91, 0x61, 0x1b, 0xba,
+	0x99, 0x0a, 0x83, 0x53, 0x5a, 0x04, 0x3a, 0x53, 0x13, 0x0d, 0x8c, 0xfd, 0x6d, 0xbf, 0x93, 0xa9,
+	0xf0, 0x98, 0x16, 0xef, 0xca, 0xd2, 0xf3, 0xf6, 0xd7, 0xf3, 0x3e, 0xfa, 0x7d, 0xde, 0x47, 0xf6,
+	0x09, 0xec, 0x1c, 0x11, 0x31, 0xa5, 0xd1, 0x8a, 0x3d, 0x84, 0x9e, 0x76, 0x16, 0x5c, 0x8d, 0xb5,
+	0xab, 0xcb, 0xa3, 0x3a, 0x5b, 0x1b, 0xba, 0x0d, 0xae, 0x49, 0xb8, 0x53, 0xa3, 0x0e, 0x89, 0xf0,
+	0xc6, 0x5f, 0x16, 0x16, 0xba, 0x58, 0x58, 0xe8, 0x72, 0x61, 0xa1, 0x5f, 0x0b, 0x0b, 0x7d, 0x5c,
+	0x5a, 0xad, 0x6f, 0x4b, 0x0b, 0x5d, 0x2e, 0xad, 0xd6, 0xf7, 0xa5, 0xd5, 0x3a, 0x79, 0x12, 0x27,
+	0x72, 0xaa, 0x42, 0x67, 0xc2, 0x99, 0xdb, 0x7c, 0x11, 0xeb, 0xc7, 0xb5, 0x9f, 0x2a, 0xdc, 0xd2,
+	0x97, 0x67, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x66, 0x2c, 0xc5, 0x1a, 0x6a, 0x03, 0x00, 0x00,
 }
 
 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -729,6 +737,90 @@ func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return base
 }
+func NewPopulatedValidatorParams(r randyParams, easy bool) *ValidatorParams {
+	this := &ValidatorParams{}
+	v1 := r.Intn(10)
+	this.PubKeyTypes = make([]string, v1)
+	for i := 0; i < v1; i++ {
+		this.PubKeyTypes[i] = string(randStringParams(r))
+	}
+	if !easy && r.Intn(10) != 0 {
+	}
+	return this
+}
+
+type randyParams interface {
+	Float32() float32
+	Float64() float64
+	Int63() int64
+	Int31() int32
+	Uint32() uint32
+	Intn(n int) int
+}
+
+func randUTF8RuneParams(r randyParams) rune {
+	ru := r.Intn(62)
+	if ru < 10 {
+		return rune(ru + 48)
+	} else if ru < 36 {
+		return rune(ru + 55)
+	}
+	return rune(ru + 61)
+}
+func randStringParams(r randyParams) string {
+	v2 := r.Intn(100)
+	tmps := make([]rune, v2)
+	for i := 0; i < v2; i++ {
+		tmps[i] = randUTF8RuneParams(r)
+	}
+	return string(tmps)
+}
+func randUnrecognizedParams(r randyParams, maxFieldNumber int) (dAtA []byte) {
+	l := r.Intn(5)
+	for i := 0; i < l; i++ {
+		wire := r.Intn(4)
+		if wire == 3 {
+			wire = 5
+		}
+		fieldNumber := maxFieldNumber + r.Intn(100)
+		dAtA = randFieldParams(dAtA, r, fieldNumber, wire)
+	}
+	return dAtA
+}
+func randFieldParams(dAtA []byte, r randyParams, fieldNumber int, wire int) []byte {
+	key := uint32(fieldNumber)<<3 | uint32(wire)
+	switch wire {
+	case 0:
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(key))
+		v3 := r.Int63()
+		if r.Intn(2) == 0 {
+			v3 *= -1
+		}
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(v3))
+	case 1:
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(key))
+		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
+	case 2:
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(key))
+		ll := r.Intn(100)
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(ll))
+		for j := 0; j < ll; j++ {
+			dAtA = append(dAtA, byte(r.Intn(256)))
+		}
+	default:
+		dAtA = encodeVarintPopulateParams(dAtA, uint64(key))
+		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
+	}
+	return dAtA
+}
+func encodeVarintPopulateParams(dAtA []byte, v uint64) []byte {
+	for v >= 1<<7 {
+		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
+		v >>= 7
+	}
+	dAtA = append(dAtA, uint8(v))
+	return dAtA
+}
 func (m *ConsensusParams) Size() (n int) {
 	if m == nil {
 		return 0

proto/types/params.proto

@@ -7,6 +7,10 @@ import "third_party/proto/gogoproto/gogo.proto";
 import "google/protobuf/duration.proto";
 
 option (gogoproto.equal_all) = true;
+option (gogoproto.marshaler_all)        = true;
+option (gogoproto.unmarshaler_all)      = true;
+option (gogoproto.sizer_all)            = true;
+option (gogoproto.goproto_registration) = true;
 
 // ConsensusParams contains consensus critical parameters that determine the
 // validity of blocks.
@@ -53,6 +57,9 @@ message EvidenceParams {
 // ValidatorParams restrict the public key types validators can use.
 // NOTE: uses ABCI pubkey naming, not Amino names.
 message ValidatorParams {
+  option (gogoproto.populate) = true;
+  option (gogoproto.equal)    = true;
+
   repeated string pub_key_types = 1;
 }
 

proto/types/validator.pb.go

@@ -7,6 +7,7 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	golang_proto "github.com/golang/protobuf/proto"
 	keys "github.com/tendermint/tendermint/proto/crypto/keys"
 	io "io"
 	math "math"
@@ -15,6 +16,7 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
+var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
@@ -154,36 +156,41 @@ func (m *Validator) GetProposerPriority() int64 {
 
 func init() {
 	proto.RegisterType((*ValidatorSet)(nil), "tendermint.proto.types.ValidatorSet")
+	golang_proto.RegisterType((*ValidatorSet)(nil), "tendermint.proto.types.ValidatorSet")
 	proto.RegisterType((*Validator)(nil), "tendermint.proto.types.Validator")
+	golang_proto.RegisterType((*Validator)(nil), "tendermint.proto.types.Validator")
 }
 
 func init() { proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406) }
+func init() {
+	golang_proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406)
+}
 
 var fileDescriptor_2e7c6b38c20e5406 = []byte{
-	// 354 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xbd, 0x6e, 0xea, 0x30,
-	0x14, 0xc7, 0xe3, 0x0b, 0x82, 0x7b, 0x0d, 0xc3, 0xad, 0x87, 0x2a, 0xa2, 0x6a, 0x0a, 0x0c, 0x2d,
-	0x52, 0x91, 0x23, 0xb5, 0x73, 0x87, 0x32, 0xb0, 0xb0, 0xa0, 0x54, 0x62, 0xe8, 0x12, 0x25, 0xc4,
-	0x0a, 0x16, 0x1f, 0xb6, 0x9c, 0x13, 0x2a, 0xbf, 0x45, 0x5f, 0xa8, 0x9d, 0x19, 0x19, 0x3b, 0x55,
-	0x15, 0xbc, 0x48, 0x45, 0x4c, 0x02, 0x52, 0x19, 0xba, 0x9d, 0xf3, 0xff, 0x9f, 0x8f, 0x9f, 0x8f,
-	0x8c, 0x2f, 0xa4, 0x12, 0x20, 0x5c, 0xd0, 0x92, 0x25, 0xee, 0x32, 0x98, 0xf1, 0x28, 0x00, 0xa1,
-	0x68, 0xa6, 0x92, 0x73, 0x60, 0x8b, 0x88, 0xa9, 0x39, 0x5f, 0x80, 0x51, 0x68, 0x56, 0xd7, 0xb8,
-	0x86, 0x09, 0x57, 0x91, 0x2f, 0x03, 0x05, 0xda, 0x35, 0x03, 0x62, 0x11, 0x8b, 0x43, 0x64, 0xaa,
-	0x1b, 0x97, 0x46, 0x19, 0x2b, 0x2d, 0x41, 0xb8, 0x53, 0xa6, 0x13, 0xb3, 0xc8, 0xd8, 0xed, 0x77,
-	0x84, 0xeb, 0xa3, 0x7c, 0xe5, 0x13, 0x03, 0xf2, 0x88, 0x71, 0x81, 0x90, 0xd8, 0xa8, 0x59, 0xea,
-	0xd4, 0xee, 0x5a, 0xf4, 0x34, 0x04, 0x2d, 0x3a, 0xbd, 0xa3, 0x26, 0xf2, 0x80, 0xff, 0x4a, 0x25,
-	0xa4, 0x48, 0x98, 0xb2, 0xff, 0x34, 0xd1, 0xef, 0x06, 0x14, 0x2d, 0xa4, 0x8b, 0x09, 0x08, 0x08,
-	0x66, 0xfe, 0x52, 0x00, 0x5f, 0xc4, 0xbe, 0x14, 0x2f, 0x4c, 0xd9, 0xa5, 0x26, 0xea, 0x94, 0xbc,
-	0xff, 0x99, 0x33, 0xca, 0x8c, 0xe1, 0x4e, 0x6f, 0xbf, 0x21, 0xfc, 0xaf, 0x98, 0x42, 0x6c, 0x5c,
-	0x0d, 0xa2, 0x48, 0xb1, 0x64, 0x87, 0x8e, 0x3a, 0x75, 0x2f, 0x4f, 0x49, 0x1f, 0x57, 0x65, 0x1a,
-	0xfa, 0x53, 0xa6, 0xf7, 0x4c, 0x37, 0x3f, 0x99, 0xcc, 0x91, 0xe8, 0xee, 0x48, 0x74, 0x98, 0x86,
-	0x33, 0x3e, 0x1e, 0x30, 0xdd, 0x2b, 0xaf, 0x3e, 0xaf, 0x2c, 0xaf, 0x22, 0xd3, 0x70, 0xc0, 0x34,
-	0x69, 0xe1, 0xfa, 0x09, 0xae, 0xda, 0xf2, 0x80, 0x44, 0x6e, 0xf1, 0x59, 0xfe, 0x18, 0x5f, 0x2a,
-	0x2e, 0x14, 0x07, 0x6d, 0x97, 0x0d, 0x7f, 0x6e, 0x0c, 0xf7, 0x7a, 0xaf, 0xbf, 0xda, 0x38, 0x68,
-	0xbd, 0x71, 0xd0, 0xd7, 0xc6, 0x41, 0xaf, 0x5b, 0xc7, 0x5a, 0x6f, 0x1d, 0xeb, 0x63, 0xeb, 0x58,
-	0xcf, 0xdd, 0x98, 0xc3, 0x24, 0x0d, 0xe9, 0x58, 0xcc, 0xdd, 0x03, 0xea, 0x71, 0x78, 0xf4, 0x6f,
-	0xc2, 0x4a, 0x96, 0xdc, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x3e, 0xe6, 0x5d, 0x4d, 0x02,
-	0x00, 0x00,
+	// 358 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0x3f, 0x4f, 0xfa, 0x40,
+	0x18, 0xc7, 0x7b, 0x3f, 0x08, 0xfc, 0x3c, 0x18, 0xf4, 0x06, 0xd3, 0x60, 0xac, 0xc0, 0xa0, 0x24,
+	0x92, 0x36, 0xd1, 0xd9, 0x41, 0x06, 0x07, 0x59, 0x48, 0x4d, 0x18, 0x5c, 0x9a, 0x96, 0x5e, 0xca,
+	0x85, 0x3f, 0x77, 0xb9, 0x3e, 0xc5, 0xdc, 0xbb, 0xf0, 0x0d, 0x69, 0x1c, 0x19, 0x19, 0x9d, 0x8c,
+	0xa1, 0x6f, 0xc4, 0xd0, 0xa3, 0x85, 0x44, 0x06, 0xb7, 0xe7, 0xf9, 0x7e, 0x9f, 0x3f, 0x9f, 0x7b,
+	0x72, 0xf8, 0x4c, 0x48, 0x0e, 0xdc, 0x01, 0x25, 0x68, 0xec, 0x2c, 0xfc, 0x29, 0x0b, 0x7d, 0xe0,
+	0xd2, 0xce, 0x54, 0x72, 0x0a, 0x74, 0x1e, 0x52, 0x39, 0x63, 0x73, 0xd0, 0x8a, 0x9d, 0xd5, 0x35,
+	0x2e, 0x61, 0xcc, 0x64, 0xe8, 0x09, 0x5f, 0x82, 0x72, 0xf4, 0x80, 0x88, 0x47, 0x7c, 0x17, 0xe9,
+	0xea, 0xc6, 0xb9, 0x56, 0x46, 0x52, 0x09, 0xe0, 0xce, 0x84, 0xaa, 0x58, 0x2f, 0xd2, 0x76, 0xfb,
+	0x1d, 0xe1, 0xfa, 0x30, 0x5f, 0xf9, 0x44, 0x81, 0xdc, 0x63, 0x5c, 0x20, 0xc4, 0x26, 0x6a, 0x96,
+	0x3a, 0xb5, 0x9b, 0x96, 0x7d, 0x18, 0xc2, 0x2e, 0x3a, 0xdd, 0xbd, 0x26, 0x72, 0x87, 0xff, 0x0b,
+	0xc9, 0x05, 0x8f, 0xa9, 0x34, 0xff, 0x35, 0xd1, 0xdf, 0x06, 0x14, 0x2d, 0xa4, 0x8b, 0x09, 0x70,
+	0xf0, 0xa7, 0xde, 0x82, 0x03, 0x9b, 0x47, 0x9e, 0xe0, 0x2f, 0x54, 0x9a, 0xa5, 0x26, 0xea, 0x94,
+	0xdc, 0xe3, 0xcc, 0x19, 0x66, 0xc6, 0x60, 0xa3, 0xb7, 0xdf, 0x10, 0x3e, 0x2a, 0xa6, 0x10, 0x13,
+	0x57, 0xfd, 0x30, 0x94, 0x34, 0xde, 0xa0, 0xa3, 0x4e, 0xdd, 0xcd, 0x53, 0xf2, 0x80, 0xab, 0x22,
+	0x09, 0xbc, 0x09, 0x55, 0x5b, 0xa6, 0xab, 0xdf, 0x4c, 0xfa, 0x48, 0xf6, 0xe6, 0x48, 0xf6, 0x20,
+	0x09, 0xa6, 0x6c, 0xd4, 0xa7, 0xaa, 0x57, 0x5e, 0x7e, 0x5d, 0x18, 0x6e, 0x45, 0x24, 0x41, 0x9f,
+	0x2a, 0xd2, 0xc2, 0xf5, 0x03, 0x5c, 0xb5, 0xc5, 0x0e, 0x89, 0x5c, 0xe3, 0x93, 0xfc, 0x31, 0x9e,
+	0x90, 0x8c, 0x4b, 0x06, 0xca, 0x2c, 0x6b, 0xfe, 0xdc, 0x18, 0x6c, 0xf5, 0xde, 0xe3, 0x72, 0x6d,
+	0xa1, 0xd5, 0xda, 0x42, 0xdf, 0x6b, 0x0b, 0xbd, 0xa6, 0x96, 0xf1, 0x91, 0x5a, 0x68, 0x95, 0x5a,
+	0xc6, 0x67, 0x6a, 0x19, 0xcf, 0xdd, 0x88, 0xc1, 0x38, 0x09, 0xec, 0x11, 0x9f, 0x39, 0x3b, 0xdc,
+	0xfd, 0x70, 0xef, 0xef, 0x04, 0x95, 0x2c, 0xb9, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xf6,
+	0x8f, 0xab, 0x51, 0x02, 0x00, 0x00,
 }
 
 func (m *ValidatorSet) Marshal() (dAtA []byte, err error) {

proto/types/validator.proto

@@ -6,6 +6,11 @@ option go_package = "github.com/tendermint/tendermint/proto/types";
 import "third_party/proto/gogoproto/gogo.proto";
 import "proto/crypto/keys/types.proto";
 
+option (gogoproto.marshaler_all)        = true;
+option (gogoproto.unmarshaler_all)      = true;
+option (gogoproto.sizer_all)            = true;
+option (gogoproto.goproto_registration) = true;
+
 message ValidatorSet {
   repeated Validator validators         = 1;
   Validator          proposer           = 2;

rpc/core/types/responses.go

@@ -7,8 +7,8 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/libs/bytes"
-
 	"github.com/tendermint/tendermint/p2p"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -134,8 +134,8 @@ type ResultValidators struct {
 
 // ConsensusParams for given height
 type ResultConsensusParams struct {
-	BlockHeight     int64                 `json:"block_height"`
-	ConsensusParams types.ConsensusParams `json:"consensus_params"`
+	BlockHeight     int64                   `json:"block_height"`
+	ConsensusParams tmproto.ConsensusParams `json:"consensus_params"`
 }
 
 // Info about the consensus state.

state/execution.go

@@ -11,6 +11,7 @@ import (
 	"github.com/tendermint/tendermint/libs/fail"
 	"github.com/tendermint/tendermint/libs/log"
 	mempl "github.com/tendermint/tendermint/mempool"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
@@ -365,7 +366,7 @@ func getBeginBlockValidatorInfo(block *types.Block, stateDB dbm.DB) (abci.LastCo
 }
 
 func validateValidatorUpdates(abciUpdates []abci.ValidatorUpdate,
-	params types.ValidatorParams) error {
+	params tmproto.ValidatorParams) error {
 	for _, valUpdate := range abciUpdates {
 		if valUpdate.GetPower() < 0 {
 			return fmt.Errorf("voting power can't be negative %v", valUpdate)
@@ -377,7 +378,7 @@ func validateValidatorUpdates(abciUpdates []abci.ValidatorUpdate,
 
 		// Check if validator's pubkey matches an ABCI type in the consensus params
 		thisKeyType := valUpdate.PubKey.Type
-		if !params.IsValidPubkeyType(thisKeyType) {
+		if !types.IsValidPubkeyType(params, thisKeyType) {
 			return fmt.Errorf("validator %v is using pubkey %s, which is unsupported for consensus",
 				valUpdate, thisKeyType)
 		}
@@ -417,8 +418,8 @@ func updateState(
 	lastHeightParamsChanged := state.LastHeightConsensusParamsChanged
 	if abciResponses.EndBlock.ConsensusParamUpdates != nil {
 		// NOTE: must not mutate s.ConsensusParams
-		nextParams = state.ConsensusParams.Update(abciResponses.EndBlock.ConsensusParamUpdates)
-		err := nextParams.Validate()
+		nextParams = types.UpdateConsensusParams(state.ConsensusParams, abciResponses.EndBlock.ConsensusParamUpdates)
+		err := types.ValidateConsensusParams(nextParams)
 		if err != nil {
 			return state, fmt.Errorf("error updating consensus params: %v", err)
 		}

state/execution_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/mempool/mock"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
@@ -177,13 +178,13 @@ func TestValidateValidatorUpdates(t *testing.T) {
 
 	secpKey := secp256k1.GenPrivKey().PubKey()
 
-	defaultValidatorParams := types.ValidatorParams{PubKeyTypes: []string{types.ABCIPubKeyTypeEd25519}}
+	defaultValidatorParams := tmproto.ValidatorParams{PubKeyTypes: []string{types.ABCIPubKeyTypeEd25519}}
 
 	testCases := []struct {
 		name string
 
 		abciUpdates     []abci.ValidatorUpdate
-		validatorParams types.ValidatorParams
+		validatorParams tmproto.ValidatorParams
 
 		shouldErr bool
 	}{

state/export_test.go

@@ -4,6 +4,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -34,13 +35,13 @@ func UpdateState(
 
 // ValidateValidatorUpdates is an alias for validateValidatorUpdates exported
 // from execution.go, exclusively and explicitly for testing.
-func ValidateValidatorUpdates(abciUpdates []abci.ValidatorUpdate, params types.ValidatorParams) error {
+func ValidateValidatorUpdates(abciUpdates []abci.ValidatorUpdate, params tmproto.ValidatorParams) error {
 	return validateValidatorUpdates(abciUpdates, params)
 }
 
 // SaveConsensusParamsInfo is an alias for the private saveConsensusParamsInfo
 // method in store.go, exported exclusively and explicitly for testing.
-func SaveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params types.ConsensusParams) {
+func SaveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params tmproto.ConsensusParams) {
 	saveConsensusParamsInfo(db, nextHeight, changeHeight, params)
 }
 

state/helpers_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
@@ -19,7 +20,7 @@ import (
 
 type paramsChangeTestCase struct {
 	height int64
-	params types.ConsensusParams
+	params tmproto.ConsensusParams
 }
 
 func newTestApp() proxy.AppConns {
@@ -147,14 +148,14 @@ func makeConsensusParams(
 	blockTimeIotaMs int64,
 	evidenceAge int64,
 	maxNumEvidence uint32,
-) types.ConsensusParams {
-	return types.ConsensusParams{
-		Block: types.BlockParams{
+) tmproto.ConsensusParams {
+	return tmproto.ConsensusParams{
+		Block: tmproto.BlockParams{
 			MaxBytes:   blockBytes,
 			MaxGas:     blockGas,
 			TimeIotaMs: blockTimeIotaMs,
 		},
-		Evidence: types.EvidenceParams{
+		Evidence: tmproto.EvidenceParams{
 			MaxAgeNumBlocks: evidenceAge,
 			MaxAgeDuration:  time.Duration(evidenceAge),
 			MaxNum:          maxNumEvidence,
@@ -211,7 +212,7 @@ func makeHeaderPartsResponsesValPowerChange(
 
 func makeHeaderPartsResponsesParams(
 	state sm.State,
-	params types.ConsensusParams,
+	params tmproto.ConsensusParams,
 ) (types.Header, types.BlockID, *sm.ABCIResponses) {
 
 	block := makeBlock(state, state.LastBlockHeight+1)

state/state.go

@@ -6,6 +6,7 @@ import (
 	"io/ioutil"
 	"time"
 
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	tmversion "github.com/tendermint/tendermint/proto/version"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -73,7 +74,7 @@ type State struct {
 
 	// Consensus parameters used for validating blocks.
 	// Changes returned by EndBlock and updated after Commit.
-	ConsensusParams                  types.ConsensusParams
+	ConsensusParams                  tmproto.ConsensusParams
 	LastHeightConsensusParamsChanged int64
 
 	// Merkle root of the results from executing prev block
@@ -153,7 +154,7 @@ func (state State) MakeBlock(
 		state.Version.Consensus, state.ChainID,
 		timestamp, state.LastBlockID,
 		state.Validators.Hash(), state.NextValidators.Hash(),
-		state.ConsensusParams.Hash(), state.AppHash, state.LastResultsHash,
+		types.HashConsensusParams(state.ConsensusParams), state.AppHash, state.LastResultsHash,
 		proposerAddress,
 	)
 

state/state_test.go

@@ -18,6 +18,7 @@ import (
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )
@@ -932,7 +933,7 @@ func TestConsensusParamsChangesSaveLoad(t *testing.T) {
 
 	// Each valset is just one validator.
 	// create list of them.
-	params := make([]types.ConsensusParams, N+1)
+	params := make([]tmproto.ConsensusParams, N+1)
 	params[0] = state.ConsensusParams
 	for i := 1; i < N+1; i++ {
 		params[i] = *types.DefaultConsensusParams()
@@ -988,9 +989,9 @@ func TestApplyUpdates(t *testing.T) {
 	initParams := makeConsensusParams(1, 2, 3, 4, 5)
 	const maxAge int64 = 66
 	cases := [...]struct {
-		init     types.ConsensusParams
+		init     tmproto.ConsensusParams
 		updates  abci.ConsensusParams
-		expected types.ConsensusParams
+		expected tmproto.ConsensusParams
 	}{
 		0: {initParams, abci.ConsensusParams{}, initParams},
 		1: {initParams, abci.ConsensusParams{}, initParams},
@@ -1004,7 +1005,7 @@ func TestApplyUpdates(t *testing.T) {
 			makeConsensusParams(44, 55, 3, 4, 5)},
 		3: {initParams,
 			abci.ConsensusParams{
-				Evidence: &abci.EvidenceParams{
+				Evidence: &tmproto.EvidenceParams{
 					MaxAgeNumBlocks: maxAge,
 					MaxAgeDuration:  time.Duration(maxAge),
 					MaxNum:          10,
@@ -1014,7 +1015,7 @@ func TestApplyUpdates(t *testing.T) {
 	}
 
 	for i, tc := range cases {
-		res := tc.init.Update(&(tc.updates))
+		res := types.UpdateConsensusParams(tc.init, &(tc.updates))
 		assert.Equal(t, tc.expected, res, "case %d", i)
 	}
 }

state/store.go

@@ -8,6 +8,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	tmos "github.com/tendermint/tendermint/libs/os"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -168,7 +169,7 @@ func PruneStates(db dbm.DB, from int64, to int64) error {
 		keepVals[lastStoredHeightFor(to, valInfo.LastHeightChanged)] = true // keep last checkpoint too
 	}
 	keepParams := make(map[int64]bool)
-	if paramsInfo.ConsensusParams.Equals(&types.ConsensusParams{}) {
+	if paramsInfo.ConsensusParams.Equal(&tmproto.ConsensusParams{}) {
 		keepParams[paramsInfo.LastHeightChanged] = true
 	}
 
@@ -199,7 +200,7 @@ func PruneStates(db dbm.DB, from int64, to int64) error {
 
 		if keepParams[h] {
 			p := loadConsensusParamsInfo(db, h)
-			if p.ConsensusParams.Equals(&types.ConsensusParams{}) {
+			if p.ConsensusParams.Equal(&tmproto.ConsensusParams{}) {
 				p.ConsensusParams, err = LoadConsensusParams(db, h)
 				if err != nil {
 					return err
@@ -379,7 +380,7 @@ func saveValidatorsInfo(db dbm.DB, height, lastHeightChanged int64, valSet *type
 
 // ConsensusParamsInfo represents the latest consensus params, or the last height it changed
 type ConsensusParamsInfo struct {
-	ConsensusParams   types.ConsensusParams
+	ConsensusParams   tmproto.ConsensusParams
 	LastHeightChanged int64
 }
 
@@ -389,15 +390,15 @@ func (params ConsensusParamsInfo) Bytes() []byte {
 }
 
 // LoadConsensusParams loads the ConsensusParams for a given height.
-func LoadConsensusParams(db dbm.DB, height int64) (types.ConsensusParams, error) {
-	empty := types.ConsensusParams{}
+func LoadConsensusParams(db dbm.DB, height int64) (tmproto.ConsensusParams, error) {
+	empty := tmproto.ConsensusParams{}
 
 	paramsInfo := loadConsensusParamsInfo(db, height)
 	if paramsInfo == nil {
 		return empty, ErrNoConsensusParamsForHeight{height}
 	}
 
-	if paramsInfo.ConsensusParams.Equals(&empty) {
+	if paramsInfo.ConsensusParams.Equal(&empty) {
 		paramsInfo2 := loadConsensusParamsInfo(db, paramsInfo.LastHeightChanged)
 		if paramsInfo2 == nil {
 			panic(
@@ -439,7 +440,7 @@ func loadConsensusParamsInfo(db dbm.DB, height int64) *ConsensusParamsInfo {
 // It should be called from s.Save(), right before the state itself is persisted.
 // If the consensus params did not change after processing the latest block,
 // only the last height for which they changed is persisted.
-func saveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params types.ConsensusParams) {
+func saveConsensusParamsInfo(db dbm.DB, nextHeight, changeHeight int64, params tmproto.ConsensusParams) {
 	paramsInfo := &ConsensusParamsInfo{
 		LastHeightChanged: changeHeight,
 	}

state/store_test.go

@@ -11,6 +11,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	cfg "github.com/tendermint/tendermint/config"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )
@@ -113,8 +114,8 @@ func TestPruneStates(t *testing.T) {
 					LastBlockHeight: h - 1,
 					Validators:      validatorSet,
 					NextValidators:  validatorSet,
-					ConsensusParams: types.ConsensusParams{
-						Block: types.BlockParams{MaxBytes: 10e6},
+					ConsensusParams: tmproto.ConsensusParams{
+						Block: tmproto.BlockParams{MaxBytes: 10e6},
 					},
 					LastHeightValidatorsChanged:      valsChanged,
 					LastHeightConsensusParamsChanged: paramsChanged,
@@ -156,7 +157,7 @@ func TestPruneStates(t *testing.T) {
 				params, err := sm.LoadConsensusParams(db, h)
 				if expectParams[h] {
 					require.NoError(t, err, "params height %v", h)
-					require.False(t, params.Equals(&types.ConsensusParams{}))
+					require.False(t, params.Equal(&tmproto.ConsensusParams{}))
 				} else {
 					require.Error(t, err, "params height %v", h)
 					require.Equal(t, sm.ErrNoConsensusParamsForHeight{Height: h}, err)

state/validation.go

@@ -56,9 +56,10 @@ func validateBlock(evidencePool EvidencePool, stateDB dbm.DB, state State, block
 			block.AppHash,
 		)
 	}
-	if !bytes.Equal(block.ConsensusHash, state.ConsensusParams.Hash()) {
+	hashCP := types.HashConsensusParams(state.ConsensusParams)
+	if !bytes.Equal(block.ConsensusHash, hashCP) {
 		return fmt.Errorf("wrong Block.Header.ConsensusHash.  Expected %X, got %v",
-			state.ConsensusParams.Hash(),
+			hashCP,
 			block.ConsensusHash,
 		)
 	}

types/genesis.go

@@ -11,6 +11,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
 	tmos "github.com/tendermint/tendermint/libs/os"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
@@ -35,12 +36,12 @@ type GenesisValidator struct {
 
 // GenesisDoc defines the initial conditions for a tendermint blockchain, in particular its validator set.
 type GenesisDoc struct {
-	GenesisTime     time.Time          `json:"genesis_time"`
-	ChainID         string             `json:"chain_id"`
-	ConsensusParams *ConsensusParams   `json:"consensus_params,omitempty"`
-	Validators      []GenesisValidator `json:"validators,omitempty"`
-	AppHash         tmbytes.HexBytes   `json:"app_hash"`
-	AppState        json.RawMessage    `json:"app_state,omitempty"`
+	GenesisTime     time.Time                `json:"genesis_time"`
+	ChainID         string                   `json:"chain_id"`
+	ConsensusParams *tmproto.ConsensusParams `json:"consensus_params,omitempty"`
+	Validators      []GenesisValidator       `json:"validators,omitempty"`
+	AppHash         tmbytes.HexBytes         `json:"app_hash"`
+	AppState        json.RawMessage          `json:"app_state,omitempty"`
 }
 
 // SaveAs is a utility method for saving GenensisDoc as a JSON file.
@@ -74,7 +75,7 @@ func (genDoc *GenesisDoc) ValidateAndComplete() error {
 
 	if genDoc.ConsensusParams == nil {
 		genDoc.ConsensusParams = DefaultConsensusParams()
-	} else if err := genDoc.ConsensusParams.Validate(); err != nil {
+	} else if err := ValidateConsensusParams(*genDoc.ConsensusParams); err != nil {
 		return err
 	}
 

types/params.go

@@ -7,7 +7,7 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	tmstrings "github.com/tendermint/tendermint/libs/strings"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 )
 
 const (
@@ -24,87 +24,27 @@ const (
 	MaxEvidencePerBlock = 65535
 )
 
-// ConsensusParams contains consensus critical parameters that determine the
-// validity of blocks.
-type ConsensusParams struct {
-	Block     BlockParams     `json:"block"`
-	Evidence  EvidenceParams  `json:"evidence"`
-	Validator ValidatorParams `json:"validator"`
-}
-
-// HashedParams is a subset of ConsensusParams.
-// It is amino encoded and hashed into the Header.ConsensusHash.
-type HashedParams struct {
-	BlockMaxBytes int64
-	BlockMaxGas   int64
-}
-
-// BlockParams defines limits on the block size and gas plus minimum time
-// between blocks.
-type BlockParams struct {
-	MaxBytes int64 `json:"max_bytes"`
-	MaxGas   int64 `json:"max_gas"`
-	// Minimum time increment between consecutive blocks (in milliseconds)
-	// Not exposed to the application.
-	TimeIotaMs int64 `json:"time_iota_ms"`
-}
-
-// EvidenceParams determines how we handle evidence of malfeasance.
-//
-// Evidence older than MaxAgeNumBlocks && MaxAgeDuration is considered
-// stale and ignored.
-//
-// In Cosmos-SDK based blockchains, MaxAgeDuration is usually equal to the
-// unbonding period. MaxAgeNumBlocks is calculated by dividing the unboding
-// period by the average block time (e.g. 2 weeks / 6s per block = 2d8h).
-type EvidenceParams struct {
-	// Max age of evidence, in blocks.
-	//
-	// The basic formula for calculating this is: MaxAgeDuration / {average block
-	// time}.
-	MaxAgeNumBlocks int64 `json:"max_age_num_blocks"`
-
-	// Max age of evidence, in time.
-	//
-	// It should correspond with an app's "unbonding period" or other similar
-	// mechanism for handling [Nothing-At-Stake
-	// attacks](https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQ#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed).
-	MaxAgeDuration time.Duration `json:"max_age_duration"`
-
-	// This sets the maximum number of evidence that can be committed in a single block.
-	// and should fall comfortably under the max block bytes when we consider the size of
-	// each evidence (See MaxEvidenceBytes). The maximum number is MaxEvidencePerBlock.
-	// Default is 50
-	MaxNum uint32 `json:"max_num"`
-}
-
-// ValidatorParams restrict the public key types validators can use.
-// NOTE: uses ABCI pubkey naming, not Amino names.
-type ValidatorParams struct {
-	PubKeyTypes []string `json:"pub_key_types"`
-}
-
 // DefaultConsensusParams returns a default ConsensusParams.
-func DefaultConsensusParams() *ConsensusParams {
-	return &ConsensusParams{
-		DefaultBlockParams(),
-		DefaultEvidenceParams(),
-		DefaultValidatorParams(),
+func DefaultConsensusParams() *tmproto.ConsensusParams {
+	return &tmproto.ConsensusParams{
+		Block:     DefaultBlockParams(),
+		Evidence:  DefaultEvidenceParams(),
+		Validator: DefaultValidatorParams(),
 	}
 }
 
 // DefaultBlockParams returns a default BlockParams.
-func DefaultBlockParams() BlockParams {
-	return BlockParams{
+func DefaultBlockParams() tmproto.BlockParams {
+	return tmproto.BlockParams{
 		MaxBytes:   22020096, // 21MB
 		MaxGas:     -1,
 		TimeIotaMs: 1000, // 1s
 	}
 }
 
-// DefaultEvidenceParams returns a default EvidenceParams.
-func DefaultEvidenceParams() EvidenceParams {
-	return EvidenceParams{
+// DefaultEvidenceParams Params returns a default EvidenceParams.
+func DefaultEvidenceParams() tmproto.EvidenceParams {
+	return tmproto.EvidenceParams{
 		MaxAgeNumBlocks: 100000, // 27.8 hrs at 1block/s
 		MaxAgeDuration:  48 * time.Hour,
 		MaxNum:          50,
@@ -113,11 +53,13 @@ func DefaultEvidenceParams() EvidenceParams {
 
 // DefaultValidatorParams returns a default ValidatorParams, which allows
 // only ed25519 pubkeys.
-func DefaultValidatorParams() ValidatorParams {
-	return ValidatorParams{[]string{ABCIPubKeyTypeEd25519}}
+func DefaultValidatorParams() tmproto.ValidatorParams {
+	return tmproto.ValidatorParams{
+		PubKeyTypes: []string{ABCIPubKeyTypeEd25519},
+	}
 }
 
-func (params *ValidatorParams) IsValidPubkeyType(pubkeyType string) bool {
+func IsValidPubkeyType(params tmproto.ValidatorParams, pubkeyType string) bool {
 	for i := 0; i < len(params.PubKeyTypes); i++ {
 		if params.PubKeyTypes[i] == pubkeyType {
 			return true
@@ -128,7 +70,7 @@ func (params *ValidatorParams) IsValidPubkeyType(pubkeyType string) bool {
 
 // Validate validates the ConsensusParams to ensure all values are within their
 // allowed limits, and returns an error if they are not.
-func (params *ConsensusParams) Validate() error {
+func ValidateConsensusParams(params tmproto.ConsensusParams) error {
 	if params.Block.MaxBytes <= 0 {
 		return fmt.Errorf("block.MaxBytes must be greater than 0. Got %d",
 			params.Block.MaxBytes)
@@ -188,28 +130,26 @@ func (params *ConsensusParams) Validate() error {
 // Only the Block.MaxBytes and Block.MaxGas are included in the hash.
 // This allows the ConsensusParams to evolve more without breaking the block
 // protocol. No need for a Merkle tree here, just a small struct to hash.
-func (params *ConsensusParams) Hash() []byte {
+func HashConsensusParams(params tmproto.ConsensusParams) []byte {
 	hasher := tmhash.New()
-	bz := cdcEncode(HashedParams{
-		params.Block.MaxBytes,
-		params.Block.MaxGas,
-	})
-	if bz == nil {
-		panic("cannot fail to encode ConsensusParams")
+
+	hp := tmproto.HashedParams{
+		BlockMaxBytes: params.Block.MaxBytes,
+		BlockMaxGas:   params.Block.MaxGas,
+	}
+
+	bz, err := hp.Marshal()
+	if err != nil {
+		panic(err)
 	}
+
 	hasher.Write(bz)
 	return hasher.Sum(nil)
 }
 
-func (params *ConsensusParams) Equals(params2 *ConsensusParams) bool {
-	return params.Block == params2.Block &&
-		params.Evidence == params2.Evidence &&
-		tmstrings.StringSliceEqual(params.Validator.PubKeyTypes, params2.Validator.PubKeyTypes)
-}
-
 // Update returns a copy of the params with updates from the non-zero fields of p2.
 // NOTE: note: must not modify the original
-func (params ConsensusParams) Update(params2 *abci.ConsensusParams) ConsensusParams {
+func UpdateConsensusParams(params tmproto.ConsensusParams, params2 *abci.ConsensusParams) tmproto.ConsensusParams {
 	res := params // explicit copy
 
 	if params2 == nil {

types/params_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	abci "github.com/tendermint/tendermint/abci/types"
+	tmproto "github.com/tendermint/tendermint/proto/types"
 )
 
 var (
@@ -18,7 +19,7 @@ var (
 
 func TestConsensusParamsValidation(t *testing.T) {
 	testCases := []struct {
-		params ConsensusParams
+		params tmproto.ConsensusParams
 		valid  bool
 	}{
 		// test block params
@@ -43,9 +44,9 @@ func TestConsensusParamsValidation(t *testing.T) {
 	}
 	for i, tc := range testCases {
 		if tc.valid {
-			assert.NoErrorf(t, tc.params.Validate(), "expected no error for valid params (#%d)", i)
+			assert.NoErrorf(t, ValidateConsensusParams(tc.params), "expected no error for valid params (#%d)", i)
 		} else {
-			assert.Errorf(t, tc.params.Validate(), "expected error for non valid params (#%d)", i)
+			assert.Errorf(t, ValidateConsensusParams(tc.params), "expected error for non valid params (#%d)", i)
 		}
 	}
 }
@@ -56,26 +57,26 @@ func makeParams(
 	evidenceAge int64,
 	maxEvidence uint32,
 	pubkeyTypes []string,
-) ConsensusParams {
-	return ConsensusParams{
-		Block: BlockParams{
+) tmproto.ConsensusParams {
+	return tmproto.ConsensusParams{
+		Block: tmproto.BlockParams{
 			MaxBytes:   blockBytes,
 			MaxGas:     blockGas,
 			TimeIotaMs: blockTimeIotaMs,
 		},
-		Evidence: EvidenceParams{
+		Evidence: tmproto.EvidenceParams{
 			MaxAgeNumBlocks: evidenceAge,
 			MaxAgeDuration:  time.Duration(evidenceAge),
 			MaxNum:          maxEvidence,
 		},
-		Validator: ValidatorParams{
+		Validator: tmproto.ValidatorParams{
 			PubKeyTypes: pubkeyTypes,
 		},
 	}
 }
 
 func TestConsensusParamsHash(t *testing.T) {
-	params := []ConsensusParams{
+	params := []tmproto.ConsensusParams{
 		makeParams(4, 2, 10, 3, 1, valEd25519),
 		makeParams(1, 4, 10, 3, 1, valEd25519),
 		makeParams(1, 2, 10, 4, 1, valEd25519),
@@ -88,7 +89,7 @@ func TestConsensusParamsHash(t *testing.T) {
 
 	hashes := make([][]byte, len(params))
 	for i := range params {
-		hashes[i] = params[i].Hash()
+		hashes[i] = HashConsensusParams(params[i])
 	}
 
 	// make sure there are no duplicates...
@@ -103,9 +104,9 @@ func TestConsensusParamsHash(t *testing.T) {
 
 func TestConsensusParamsUpdate(t *testing.T) {
 	testCases := []struct {
-		params        ConsensusParams
+		params        tmproto.ConsensusParams
 		updates       *abci.ConsensusParams
-		updatedParams ConsensusParams
+		updatedParams tmproto.ConsensusParams
 	}{
 		// empty updates
 		{
@@ -121,12 +122,12 @@ func TestConsensusParamsUpdate(t *testing.T) {
 					MaxBytes: 100,
 					MaxGas:   200,
 				},
-				Evidence: &abci.EvidenceParams{
+				Evidence: &tmproto.EvidenceParams{
 					MaxAgeNumBlocks: 300,
 					MaxAgeDuration:  time.Duration(300),
 					MaxNum:          50,
 				},
-				Validator: &abci.ValidatorParams{
+				Validator: &tmproto.ValidatorParams{
 					PubKeyTypes: valSecp256k1,
 				},
 			},
@@ -134,6 +135,6 @@ func TestConsensusParamsUpdate(t *testing.T) {
 		},
 	}
 	for _, tc := range testCases {
-		assert.Equal(t, tc.updatedParams, tc.params.Update(tc.updates))
+		assert.Equal(t, tc.updatedParams, UpdateConsensusParams(tc.params, tc.updates))
 	}
 }

types/protobuf.go

@@ -128,20 +128,14 @@ func (tm2pb) ValidatorUpdates(vals *ValidatorSet) []abci.ValidatorUpdate {
 	return validators
 }
 
-func (tm2pb) ConsensusParams(params *ConsensusParams) *abci.ConsensusParams {
+func (tm2pb) ConsensusParams(params *tmproto.ConsensusParams) *abci.ConsensusParams {
 	return &abci.ConsensusParams{
 		Block: &abci.BlockParams{
 			MaxBytes: params.Block.MaxBytes,
 			MaxGas:   params.Block.MaxGas,
 		},
-		Evidence: &abci.EvidenceParams{
-			MaxAgeNumBlocks: params.Evidence.MaxAgeNumBlocks,
-			MaxAgeDuration:  params.Evidence.MaxAgeDuration,
-			MaxNum:          params.Evidence.MaxNum,
-		},
-		Validator: &abci.ValidatorParams{
-			PubKeyTypes: params.Validator.PubKeyTypes,
-		},
+		Evidence:  &params.Evidence,
+		Validator: &params.Validator,
 	}
 }
 

types/protobuf_test.go

@@ -66,7 +66,7 @@ func TestABCIValidators(t *testing.T) {
 func TestABCIConsensusParams(t *testing.T) {
 	cp := DefaultConsensusParams()
 	abciCP := TM2PB.ConsensusParams(cp)
-	cp2 := cp.Update(abciCP)
+	cp2 := UpdateConsensusParams(*cp, abciCP)
 
 	assert.Equal(t, *cp, cp2)
 }