mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-04-28 19:36:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

types: migrate params to protobuf (#4962)

Browse Source
This commit is contained in:
Marko
2020-06-05 15:29:53 +02:00
committed by GitHub
parent d4f1876d12
commit 9ef266b88f
28 changed files with 494 additions and 867 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG_PENDING.md
View File

@@ -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.

816
abci/types/types.pb.go
View File

@@ -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

19
abci/types/types.proto
View File

@@ -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];

2
consensus/replay.go
View File

@@ -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)
}

4
consensus/replay_test.go
View File

@@ -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}
}

7
evidence/pool_test.go
View File

@@ -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,
},

4
light/rpc/client.go
View File

@@ -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)
}

19
proto/crypto/keys/types.pb.go
View File

@@ -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 {

5
proto/crypto/keys/types.proto
View File

@@ -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;

158
proto/types/params.pb.go
View File

@@ -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

7
proto/types/params.proto
View File

@@ -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;
}

55
proto/types/validator.pb.go
View File

@@ -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) {

5
proto/types/validator.proto
View File

@@ -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;

6
rpc/core/types/responses.go
View File

@@ -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.

9
state/execution.go
View File

@@ -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)
}

5
state/execution_test.go
View File

@@ -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
}{

5
state/export_test.go
View File

@@ -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)
}

13
state/helpers_test.go
View File

@@ -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)

5
state/state.go
View File

@@ -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,
)

11
state/state_test.go
View File

@@ -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)
}
}

15
state/store.go
View File

@@ -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,
}

7
state/store_test.go
View File

@@ -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)

5
state/validation.go
View File

@@ -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,
)
}

15
types/genesis.go
View File

@@ -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
}

118
types/params.go
View File

@@ -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 {

31
types/params_test.go
View File

@@ -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))
}
}

12
types/protobuf.go
View File

@@ -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,
}
}

2
types/protobuf_test.go
View File

@@ -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)
}