certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

add proposer address to block's Header 

Refs #1134

Validation:

- ignored in block.ValidateBasic since it's stateful information
- checked in blockExec.ValidateBlock
This commit is contained in:
Anton Kaliaev 2018-07-30 12:59:16 +04:00 committed by Ethan Buchman
parent 06a157ad06
commit bec9d5cba9
12 changed files with 319 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG_PENDING.md
View File

@ -14,6 +14,7 @@ BREAKING CHANGES:
- [p2p] Remove salsa and ripemd primitives, in favor of using chacha as a stream cipher, and hkdf
- [abci] Changed time format from int64 to google.protobuf.Timestamp
- [abci] Changed Validators to LastCommitInfo in RequestBeginBlock
- [abci] Added address of the original proposer of the block to Header.
FEATURES:
- [tools] Added `make check_dep`

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

@ -59,7 +59,7 @@ func (m *Request) Reset() { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage() {}
func (*Request) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{0}
return fileDescriptor_types_2abffab37bc29540, []int{0}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -481,7 +481,7 @@ func (m *RequestEcho) Reset() { *m = RequestEcho{} }
func (m *RequestEcho) String() string { return proto.CompactTextString(m) }
func (*RequestEcho) ProtoMessage() {}
func (*RequestEcho) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{1}
return fileDescriptor_types_2abffab37bc29540, []int{1}
}
func (m *RequestEcho) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -527,7 +527,7 @@ func (m *RequestFlush) Reset() { *m = RequestFlush{} }
func (m *RequestFlush) String() string { return proto.CompactTextString(m) }
func (*RequestFlush) ProtoMessage() {}
func (*RequestFlush) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{2}
return fileDescriptor_types_2abffab37bc29540, []int{2}
}
func (m *RequestFlush) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -567,7 +567,7 @@ func (m *RequestInfo) Reset() { *m = RequestInfo{} }
func (m *RequestInfo) String() string { return proto.CompactTextString(m) }
func (*RequestInfo) ProtoMessage() {}
func (*RequestInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{3}
return fileDescriptor_types_2abffab37bc29540, []int{3}
}
func (m *RequestInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -616,7 +616,7 @@ func (m *RequestSetOption) Reset() { *m = RequestSetOption{} }
func (m *RequestSetOption) String() string { return proto.CompactTextString(m) }
func (*RequestSetOption) ProtoMessage() {}
func (*RequestSetOption) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{4}
return fileDescriptor_types_2abffab37bc29540, []int{4}
}
func (m *RequestSetOption) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -674,7 +674,7 @@ func (m *RequestInitChain) Reset() { *m = RequestInitChain{} }
func (m *RequestInitChain) String() string { return proto.CompactTextString(m) }
func (*RequestInitChain) ProtoMessage() {}
func (*RequestInitChain) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{5}
return fileDescriptor_types_2abffab37bc29540, []int{5}
}
func (m *RequestInitChain) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -752,7 +752,7 @@ func (m *RequestQuery) Reset() { *m = RequestQuery{} }
func (m *RequestQuery) String() string { return proto.CompactTextString(m) }
func (*RequestQuery) ProtoMessage() {}
func (*RequestQuery) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{6}
return fileDescriptor_types_2abffab37bc29540, []int{6}
}
func (m *RequestQuery) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -824,7 +824,7 @@ func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} }
func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) }
func (*RequestBeginBlock) ProtoMessage() {}
func (*RequestBeginBlock) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{7}
return fileDescriptor_types_2abffab37bc29540, []int{7}
}
func (m *RequestBeginBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -892,7 +892,7 @@ func (m *RequestCheckTx) Reset() { *m = RequestCheckTx{} }
func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) }
func (*RequestCheckTx) ProtoMessage() {}
func (*RequestCheckTx) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{8}
return fileDescriptor_types_2abffab37bc29540, []int{8}
}
func (m *RequestCheckTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -939,7 +939,7 @@ func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} }
func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) }
func (*RequestDeliverTx) ProtoMessage() {}
func (*RequestDeliverTx) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{9}
return fileDescriptor_types_2abffab37bc29540, []int{9}
}
func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -986,7 +986,7 @@ func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} }
func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) }
func (*RequestEndBlock) ProtoMessage() {}
func (*RequestEndBlock) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{10}
return fileDescriptor_types_2abffab37bc29540, []int{10}
}
func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1032,7 +1032,7 @@ func (m *RequestCommit) Reset() { *m = RequestCommit{} }
func (m *RequestCommit) String() string { return proto.CompactTextString(m) }
func (*RequestCommit) ProtoMessage() {}
func (*RequestCommit) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{11}
return fileDescriptor_types_2abffab37bc29540, []int{11}
}
func (m *RequestCommit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1085,7 +1085,7 @@ func (m *Response) Reset() { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage() {}
func (*Response) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{12}
return fileDescriptor_types_2abffab37bc29540, []int{12}
}
func (m *Response) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1538,7 +1538,7 @@ func (m *ResponseException) Reset() { *m = ResponseException{} }
func (m *ResponseException) String() string { return proto.CompactTextString(m) }
func (*ResponseException) ProtoMessage() {}
func (*ResponseException) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{13}
return fileDescriptor_types_2abffab37bc29540, []int{13}
}
func (m *ResponseException) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1585,7 +1585,7 @@ func (m *ResponseEcho) Reset() { *m = ResponseEcho{} }
func (m *ResponseEcho) String() string { return proto.CompactTextString(m) }
func (*ResponseEcho) ProtoMessage() {}
func (*ResponseEcho) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{14}
return fileDescriptor_types_2abffab37bc29540, []int{14}
}
func (m *ResponseEcho) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1631,7 +1631,7 @@ func (m *ResponseFlush) Reset() { *m = ResponseFlush{} }
func (m *ResponseFlush) String() string { return proto.CompactTextString(m) }
func (*ResponseFlush) ProtoMessage() {}
func (*ResponseFlush) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{15}
return fileDescriptor_types_2abffab37bc29540, []int{15}
}
func (m *ResponseFlush) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1674,7 +1674,7 @@ func (m *ResponseInfo) Reset() { *m = ResponseInfo{} }
func (m *ResponseInfo) String() string { return proto.CompactTextString(m) }
func (*ResponseInfo) ProtoMessage() {}
func (*ResponseInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{16}
return fileDescriptor_types_2abffab37bc29540, []int{16}
}
func (m *ResponseInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1746,7 +1746,7 @@ func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} }
func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) }
func (*ResponseSetOption) ProtoMessage() {}
func (*ResponseSetOption) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{17}
return fileDescriptor_types_2abffab37bc29540, []int{17}
}
func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1808,7 +1808,7 @@ func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} }
func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) }
func (*ResponseInitChain) ProtoMessage() {}
func (*ResponseInitChain) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{18}
return fileDescriptor_types_2abffab37bc29540, []int{18}
}
func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1870,7 +1870,7 @@ func (m *ResponseQuery) Reset() { *m = ResponseQuery{} }
func (m *ResponseQuery) String() string { return proto.CompactTextString(m) }
func (*ResponseQuery) ProtoMessage() {}
func (*ResponseQuery) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{19}
return fileDescriptor_types_2abffab37bc29540, []int{19}
}
func (m *ResponseQuery) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1966,7 +1966,7 @@ func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} }
func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) }
func (*ResponseBeginBlock) ProtoMessage() {}
func (*ResponseBeginBlock) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{20}
return fileDescriptor_types_2abffab37bc29540, []int{20}
}
func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2019,7 +2019,7 @@ func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} }
func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) }
func (*ResponseCheckTx) ProtoMessage() {}
func (*ResponseCheckTx) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{21}
return fileDescriptor_types_2abffab37bc29540, []int{21}
}
func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2114,7 +2114,7 @@ func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} }
func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) }
func (*ResponseDeliverTx) ProtoMessage() {}
func (*ResponseDeliverTx) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{22}
return fileDescriptor_types_2abffab37bc29540, []int{22}
}
func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2205,7 +2205,7 @@ func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} }
func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) }
func (*ResponseEndBlock) ProtoMessage() {}
func (*ResponseEndBlock) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{23}
return fileDescriptor_types_2abffab37bc29540, []int{23}
}
func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2267,7 +2267,7 @@ func (m *ResponseCommit) Reset() { *m = ResponseCommit{} }
func (m *ResponseCommit) String() string { return proto.CompactTextString(m) }
func (*ResponseCommit) ProtoMessage() {}
func (*ResponseCommit) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{24}
return fileDescriptor_types_2abffab37bc29540, []int{24}
}
func (m *ResponseCommit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2318,7 +2318,7 @@ func (m *ConsensusParams) Reset() { *m = ConsensusParams{} }
func (m *ConsensusParams) String() string { return proto.CompactTextString(m) }
func (*ConsensusParams) ProtoMessage() {}
func (*ConsensusParams) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{25}
return fileDescriptor_types_2abffab37bc29540, []int{25}
}
func (m *ConsensusParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2382,7 +2382,7 @@ func (m *BlockSize) Reset() { *m = BlockSize{} }
func (m *BlockSize) String() string { return proto.CompactTextString(m) }
func (*BlockSize) ProtoMessage() {}
func (*BlockSize) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{26}
return fileDescriptor_types_2abffab37bc29540, []int{26}
}
func (m *BlockSize) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2445,7 +2445,7 @@ func (m *TxSize) Reset() { *m = TxSize{} }
func (m *TxSize) String() string { return proto.CompactTextString(m) }
func (*TxSize) ProtoMessage() {}
func (*TxSize) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{27}
return fileDescriptor_types_2abffab37bc29540, []int{27}
}
func (m *TxSize) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2502,7 +2502,7 @@ func (m *BlockGossip) Reset() { *m = BlockGossip{} }
func (m *BlockGossip) String() string { return proto.CompactTextString(m) }
func (*BlockGossip) ProtoMessage() {}
func (*BlockGossip) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{28}
return fileDescriptor_types_2abffab37bc29540, []int{28}
}
func (m *BlockGossip) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2550,7 +2550,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_types_d8da2202f45d32c0, []int{29}
return fileDescriptor_types_2abffab37bc29540, []int{29}
}
func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2607,17 +2607,17 @@ type Header struct {
ValidatorsHash []byte `protobuf:"bytes,7,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
AppHash []byte `protobuf:"bytes,8,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
// consensus
Proposer Validator `protobuf:"bytes,9,opt,name=proposer" json:"proposer"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
ProposerAddress []byte `protobuf:"bytes,9,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{30}
return fileDescriptor_types_2abffab37bc29540, []int{30}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2702,11 +2702,11 @@ func (m *Header) GetAppHash() []byte {
return nil
}
func (m *Header) GetProposer() Validator {
func (m *Header) GetProposerAddress() []byte {
if m != nil {
return m.Proposer
return m.ProposerAddress
}
return Validator{}
return nil
}
// Validator
@ -2723,7 +2723,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_types_d8da2202f45d32c0, []int{31}
return fileDescriptor_types_2abffab37bc29540, []int{31}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2786,7 +2786,7 @@ func (m *SigningValidator) Reset() { *m = SigningValidator{} }
func (m *SigningValidator) String() string { return proto.CompactTextString(m) }
func (*SigningValidator) ProtoMessage() {}
func (*SigningValidator) Descriptor() ([]byte, []int) {
return fileDescriptor_types_d8da2202f45d32c0, []int{32}
return fileDescriptor_types_2abffab37bc29540, []int{32}
}
func (m *SigningValidator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2841,7 +2841,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_types_d8da2202f45d32c0, []int{33}
return fileDescriptor_types_2abffab37bc29540, []int{33}
}
func (m *PubKey) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -2899,7 +2899,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_types_d8da2202f45d32c0, []int{34}
return fileDescriptor_types_2abffab37bc29540, []int{34}
}
func (m *Evidence) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -4620,7 +4620,7 @@ func (this *Header) Equal(that interface{}) bool {
if !bytes.Equal(this.AppHash, that1.AppHash) {
return false
}
if !this.Proposer.Equal(&that1.Proposer) {
if !bytes.Equal(this.ProposerAddress, that1.ProposerAddress) {
return false
}
if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
@ -6675,14 +6675,12 @@ func (m *Header) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash)))
i += copy(dAtA[i:], m.AppHash)
}
dAtA[i] = 0x4a
i++
i = encodeVarintTypes(dAtA, i, uint64(m.Proposer.Size()))
n36, err := m.Proposer.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
if len(m.ProposerAddress) > 0 {
dAtA[i] = 0x4a
i++
i = encodeVarintTypes(dAtA, i, uint64(len(m.ProposerAddress)))
i += copy(dAtA[i:], m.ProposerAddress)
}
i += n36
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
@ -6713,11 +6711,11 @@ func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintTypes(dAtA, i, uint64(m.PubKey.Size()))
n37, err := m.PubKey.MarshalTo(dAtA[i:])
n36, err := m.PubKey.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n37
i += n36
if m.Power != 0 {
dAtA[i] = 0x18
i++
@ -6747,11 +6745,11 @@ func (m *SigningValidator) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintTypes(dAtA, i, uint64(m.Validator.Size()))
n38, err := m.Validator.MarshalTo(dAtA[i:])
n37, err := m.Validator.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n38
i += n37
if m.SignedLastBlock {
dAtA[i] = 0x10
i++
@ -6825,11 +6823,11 @@ func (m *Evidence) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintTypes(dAtA, i, uint64(m.Validator.Size()))
n39, err := m.Validator.MarshalTo(dAtA[i:])
n38, err := m.Validator.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n39
i += n38
if m.Height != 0 {
dAtA[i] = 0x18
i++
@ -6838,11 +6836,11 @@ func (m *Evidence) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x22
i++
i = encodeVarintTypes(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)))
n40, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i:])
n39, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i:])
if err != nil {
return 0, err
}
i += n40
i += n39
if m.TotalVotingPower != 0 {
dAtA[i] = 0x28
i++
@ -7545,8 +7543,11 @@ func NewPopulatedHeader(r randyTypes, easy bool) *Header {
for i := 0; i < v37; i++ {
this.AppHash[i] = byte(r.Intn(256))
}
v38 := NewPopulatedValidator(r, easy)
this.Proposer = *v38
v38 := r.Intn(100)
this.ProposerAddress = make([]byte, v38)
for i := 0; i < v38; i++ {
this.ProposerAddress[i] = byte(r.Intn(256))
}
if !easy && r.Intn(10) != 0 {
this.XXX_unrecognized = randUnrecognizedTypes(r, 10)
}
@ -8470,8 +8471,10 @@ func (m *Header) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.Proposer.Size()
n += 1 + l + sovTypes(uint64(l))
l = len(m.ProposerAddress)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -12930,9 +12933,9 @@ func (m *Header) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Proposer", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field ProposerAddress", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -12942,20 +12945,21 @@ func (m *Header) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Proposer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.ProposerAddress = append(m.ProposerAddress[:0], dAtA[iNdEx:postIndex]...)
if m.ProposerAddress == nil {
m.ProposerAddress = []byte{}
}
iNdEx = postIndex
default:
@ -13606,134 +13610,134 @@ var (
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
)
func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_d8da2202f45d32c0) }
func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_2abffab37bc29540) }
func init() {
golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_d8da2202f45d32c0)
golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_types_2abffab37bc29540)
}
var fileDescriptor_types_d8da2202f45d32c0 = []byte{
// 1959 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4f, 0x73, 0x1b, 0x49,
0x15, 0xf7, 0xc8, 0xb2, 0xa4, 0x79, 0xb2, 0x2d, 0xa7, 0x9d, 0xd8, 0x8a, 0x16, 0xec, 0x30, 0x45,
0x65, 0x1d, 0xd6, 0x2b, 0x83, 0x97, 0x6c, 0x39, 0xbb, 0xb0, 0x85, 0xe5, 0x0d, 0x2b, 0xd7, 0x2e,
0x60, 0x26, 0xd9, 0x50, 0xc5, 0x45, 0xd5, 0xd2, 0xb4, 0x47, 0x53, 0x91, 0x66, 0x66, 0xa7, 0x5b,
0x5e, 0x39, 0x1f, 0x81, 0xda, 0xa2, 0xb8, 0x71, 0xe6, 0xc6, 0x17, 0xa0, 0x8a, 0x23, 0x27, 0x6a,
0x8f, 0x1c, 0xa0, 0xe0, 0x14, 0xc0, 0x5b, 0x5c, 0xf8, 0x04, 0x1c, 0xa9, 0xd7, 0xdd, 0xf3, 0xd7,
0xa3, 0x54, 0x12, 0x6e, 0x5c, 0xa4, 0xee, 0x7e, 0xef, 0xf5, 0xf4, 0x7b, 0xfd, 0xde, 0xfb, 0xbd,
0xd7, 0xb0, 0x45, 0x87, 0x23, 0xef, 0x40, 0x5c, 0x86, 0x8c, 0xab, 0xdf, 0x6e, 0x18, 0x05, 0x22,
0x20, 0x2b, 0x72, 0xd2, 0x79, 0xdb, 0xf5, 0xc4, 0x78, 0x36, 0xec, 0x8e, 0x82, 0xe9, 0x81, 0x1b,
0xb8, 0xc1, 0x81, 0xa4, 0x0e, 0x67, 0xe7, 0x72, 0x26, 0x27, 0x72, 0xa4, 0xa4, 0x3a, 0xbb, 0x6e,
0x10, 0xb8, 0x13, 0x96, 0x72, 0x09, 0x6f, 0xca, 0xb8, 0xa0, 0xd3, 0x50, 0x33, 0x1c, 0x65, 0xf6,
0x13, 0xcc, 0x77, 0x58, 0x34, 0xf5, 0x7c, 0x91, 0x1d, 0x4e, 0xbc, 0x21, 0x3f, 0x18, 0x05, 0xd3,
0x69, 0xe0, 0x67, 0x0f, 0x64, 0xfd, 0xb1, 0x0a, 0x75, 0x9b, 0x7d, 0x36, 0x63, 0x5c, 0x90, 0x3d,
0xa8, 0xb2, 0xd1, 0x38, 0x68, 0x57, 0xee, 0x18, 0x7b, 0xcd, 0x43, 0xd2, 0x55, 0x7c, 0x9a, 0xfa,
0x70, 0x34, 0x0e, 0xfa, 0x4b, 0xb6, 0xe4, 0x20, 0x6f, 0xc1, 0xca, 0xf9, 0x64, 0xc6, 0xc7, 0xed,
0x65, 0xc9, 0xba, 0x99, 0x67, 0xfd, 0x21, 0x92, 0xfa, 0x4b, 0xb6, 0xe2, 0xc1, 0x6d, 0x3d, 0xff,
0x3c, 0x68, 0x57, 0xcb, 0xb6, 0x3d, 0xf5, 0xcf, 0xe5, 0xb6, 0xc8, 0x41, 0x8e, 0x00, 0x38, 0x13,
0x83, 0x20, 0x14, 0x5e, 0xe0, 0xb7, 0x57, 0x24, 0xff, 0x76, 0x9e, 0xff, 0x11, 0x13, 0x3f, 0x91,
0xe4, 0xfe, 0x92, 0x6d, 0xf2, 0x78, 0x82, 0x92, 0x9e, 0xef, 0x89, 0xc1, 0x68, 0x4c, 0x3d, 0xbf,
0x5d, 0x2b, 0x93, 0x3c, 0xf5, 0x3d, 0x71, 0x82, 0x64, 0x94, 0xf4, 0xe2, 0x09, 0xaa, 0xf2, 0xd9,
0x8c, 0x45, 0x97, 0xed, 0x7a, 0x99, 0x2a, 0x3f, 0x45, 0x12, 0xaa, 0x22, 0x79, 0xc8, 0xfb, 0xd0,
0x1c, 0x32, 0xd7, 0xf3, 0x07, 0xc3, 0x49, 0x30, 0x7a, 0xda, 0x6e, 0x48, 0x91, 0x76, 0x5e, 0xa4,
0x87, 0x0c, 0x3d, 0xa4, 0xf7, 0x97, 0x6c, 0x18, 0x26, 0x33, 0x72, 0x08, 0x8d, 0xd1, 0x98, 0x8d,
0x9e, 0x0e, 0xc4, 0xbc, 0x6d, 0x4a, 0xc9, 0x5b, 0x79, 0xc9, 0x13, 0xa4, 0x3e, 0x9e, 0xf7, 0x97,
0xec, 0xfa, 0x48, 0x0d, 0xc9, 0x7d, 0x30, 0x99, 0xef, 0xe8, 0xcf, 0x35, 0xa5, 0xd0, 0x56, 0xe1,
0x5e, 0x7c, 0x27, 0xfe, 0x58, 0x83, 0xe9, 0x31, 0xe9, 0x42, 0x0d, 0xef, 0xda, 0x13, 0xed, 0x55,
0x29, 0x73, 0xb3, 0xf0, 0x21, 0x49, 0xeb, 0x2f, 0xd9, 0x9a, 0x0b, 0xcd, 0xe7, 0xb0, 0x89, 0x77,
0xc1, 0x22, 0x3c, 0xdc, 0x66, 0x99, 0xf9, 0x3e, 0x54, 0x74, 0x79, 0x3c, 0xd3, 0x89, 0x27, 0xbd,
0x3a, 0xac, 0x5c, 0xd0, 0xc9, 0x8c, 0x59, 0x6f, 0x42, 0x33, 0xe3, 0x29, 0xa4, 0x0d, 0xf5, 0x29,
0xe3, 0x9c, 0xba, 0xac, 0x6d, 0xdc, 0x31, 0xf6, 0x4c, 0x3b, 0x9e, 0x5a, 0xeb, 0xb0, 0x9a, 0xf5,
0x93, 0x8c, 0x20, 0xfa, 0x02, 0x0a, 0x5e, 0xb0, 0x88, 0xa3, 0x03, 0x68, 0x41, 0x3d, 0xb5, 0xde,
0x83, 0x8d, 0xa2, 0x13, 0x90, 0x0d, 0x58, 0x7e, 0xca, 0x2e, 0x35, 0x27, 0x0e, 0xc9, 0x4d, 0x7d,
0x20, 0xe9, 0xc5, 0xa6, 0xad, 0x4f, 0xf7, 0x8b, 0x4a, 0x22, 0x9c, 0xf8, 0x01, 0x39, 0x82, 0x2a,
0x06, 0x92, 0x94, 0x6e, 0x1e, 0x76, 0xba, 0x2a, 0xca, 0xba, 0x71, 0x94, 0x75, 0x1f, 0xc7, 0x51,
0xd6, 0x6b, 0x7c, 0xf9, 0x7c, 0x77, 0xe9, 0x57, 0x7f, 0xdf, 0x35, 0x6c, 0x29, 0x41, 0x6e, 0xe3,
0x55, 0x52, 0xcf, 0x1f, 0x78, 0x8e, 0xfe, 0x4e, 0x5d, 0xce, 0x4f, 0x1d, 0x72, 0x0c, 0x1b, 0xa3,
0xc0, 0xe7, 0xcc, 0xe7, 0x33, 0x3e, 0x08, 0x69, 0x44, 0xa7, 0x5c, 0x47, 0x49, 0x7c, 0x71, 0x27,
0x31, 0xf9, 0x4c, 0x52, 0xed, 0xd6, 0x28, 0xbf, 0x40, 0xde, 0x05, 0xb8, 0xa0, 0x13, 0xcf, 0xa1,
0x22, 0x88, 0x78, 0xbb, 0x7a, 0x67, 0x79, 0xaf, 0x79, 0xb8, 0xa1, 0x85, 0x9f, 0xc4, 0x84, 0x5e,
0x15, 0xcf, 0x64, 0x67, 0x38, 0xc9, 0x5d, 0x68, 0xd1, 0x30, 0x1c, 0x70, 0x41, 0x05, 0x1b, 0x0c,
0x2f, 0x05, 0xe3, 0x32, 0x86, 0x56, 0xed, 0x35, 0x1a, 0x86, 0x8f, 0x70, 0xb5, 0x87, 0x8b, 0x96,
0x93, 0xdc, 0x80, 0x74, 0x6f, 0x42, 0xa0, 0xea, 0x50, 0x41, 0xa5, 0x1d, 0x56, 0x6d, 0x39, 0xc6,
0xb5, 0x90, 0x8a, 0xb1, 0xd6, 0x4e, 0x8e, 0xc9, 0x16, 0xd4, 0xc6, 0xcc, 0x73, 0xc7, 0x42, 0x2a,
0xb4, 0x6c, 0xeb, 0x19, 0x9a, 0x3c, 0x8c, 0x82, 0x0b, 0x26, 0x23, 0xbc, 0x61, 0xab, 0x89, 0xf5,
0x2f, 0x03, 0x6e, 0x5c, 0x0b, 0x09, 0xdc, 0x77, 0x4c, 0xf9, 0x38, 0xfe, 0x16, 0x8e, 0xc9, 0x5b,
0xb8, 0x2f, 0x75, 0x58, 0xa4, 0x33, 0xcf, 0x9a, 0xd6, 0xb5, 0x2f, 0x17, 0xb5, 0xa2, 0x9a, 0x85,
0x3c, 0x84, 0x8d, 0x09, 0xe5, 0x62, 0xa0, 0x3c, 0x77, 0x20, 0x33, 0xcb, 0x72, 0x2e, 0x9a, 0x3e,
0xa1, 0xb1, 0x87, 0xa3, 0x43, 0x69, 0xf1, 0xf5, 0x49, 0x6e, 0x95, 0xf4, 0xe1, 0xe6, 0xf0, 0xf2,
0x19, 0xf5, 0x85, 0xe7, 0xb3, 0xc1, 0x35, 0x6b, 0xb7, 0xf4, 0x56, 0x0f, 0x2f, 0x3c, 0x87, 0xf9,
0x23, 0xa6, 0x37, 0xd9, 0x4c, 0x44, 0x92, 0x6b, 0xe0, 0xd6, 0x1d, 0x58, 0xcf, 0xc7, 0x2f, 0x59,
0x87, 0x8a, 0x98, 0x6b, 0x0d, 0x2b, 0x62, 0x6e, 0x59, 0x89, 0xef, 0x25, 0x41, 0x74, 0x8d, 0xe7,
0x1e, 0xb4, 0x0a, 0x01, 0x9d, 0x31, 0xb7, 0x91, 0x35, 0xb7, 0xd5, 0x82, 0xb5, 0x5c, 0x1c, 0x5b,
0x5f, 0xac, 0x40, 0xc3, 0x66, 0x3c, 0x44, 0x37, 0x22, 0x47, 0x60, 0xb2, 0xf9, 0x88, 0xa9, 0x14,
0x6a, 0x14, 0x12, 0x94, 0xe2, 0x79, 0x18, 0xd3, 0x31, 0x94, 0x13, 0x66, 0x72, 0x2f, 0x97, 0xfe,
0x37, 0x8b, 0x42, 0xd9, 0xfc, 0xbf, 0x9f, 0xcf, 0xff, 0x37, 0x0b, 0xbc, 0x05, 0x00, 0xb8, 0x97,
0x03, 0x80, 0xe2, 0xc6, 0x39, 0x04, 0x78, 0x50, 0x82, 0x00, 0xc5, 0xe3, 0x2f, 0x80, 0x80, 0x07,
0x25, 0x10, 0xd0, 0xbe, 0xf6, 0xad, 0x52, 0x0c, 0xd8, 0xcf, 0x63, 0x40, 0x51, 0x9d, 0x02, 0x08,
0x7c, 0xaf, 0x0c, 0x04, 0x6e, 0x17, 0x64, 0x16, 0xa2, 0xc0, 0x3b, 0xd7, 0x50, 0x60, 0xab, 0x20,
0x5a, 0x02, 0x03, 0x0f, 0x72, 0xf9, 0x19, 0x4a, 0x75, 0x2b, 0x4f, 0xd0, 0xe4, 0xdd, 0xeb, 0x08,
0xb2, 0x5d, 0xbc, 0xda, 0x32, 0x08, 0x39, 0x28, 0x40, 0xc8, 0xad, 0xe2, 0x29, 0x0b, 0x18, 0x92,
0x22, 0xc1, 0x3d, 0x8c, 0xfb, 0x82, 0xa7, 0x61, 0x8e, 0x60, 0x51, 0x14, 0x44, 0x3a, 0x55, 0xab,
0x89, 0xb5, 0x87, 0x99, 0x28, 0xf5, 0xaf, 0x17, 0xa0, 0x86, 0x74, 0xfa, 0x8c, 0x77, 0x59, 0xbf,
0x36, 0x52, 0x59, 0x19, 0xd1, 0xd9, 0x2c, 0x66, 0xea, 0x2c, 0x96, 0x01, 0x93, 0x4a, 0x0e, 0x4c,
0xc8, 0xb7, 0xe0, 0x86, 0x4c, 0x23, 0xd2, 0x2e, 0x83, 0x5c, 0x5a, 0x6b, 0x21, 0x41, 0x19, 0x44,
0xe5, 0xb7, 0xb7, 0x61, 0x33, 0xc3, 0x8b, 0x29, 0x56, 0xa6, 0xb0, 0xaa, 0x0c, 0xde, 0x8d, 0x84,
0xfb, 0x38, 0x0c, 0xfb, 0x94, 0x8f, 0xad, 0x1f, 0xa5, 0xfa, 0xa7, 0x40, 0x45, 0xa0, 0x3a, 0x0a,
0x1c, 0xa5, 0xd6, 0x9a, 0x2d, 0xc7, 0x08, 0x5e, 0x93, 0xc0, 0x95, 0x5f, 0x35, 0x6d, 0x1c, 0x22,
0x57, 0x12, 0x29, 0xa6, 0x0a, 0x09, 0xeb, 0x97, 0x46, 0xba, 0x5f, 0x8a, 0x5d, 0x65, 0x30, 0x63,
0xfc, 0x2f, 0x30, 0x53, 0x79, 0x59, 0x98, 0xb1, 0x7e, 0x67, 0xa4, 0x77, 0x91, 0x00, 0xc8, 0xeb,
0x29, 0x87, 0x6e, 0xe1, 0xf9, 0x0e, 0x9b, 0xcb, 0x50, 0x5f, 0xb6, 0xd5, 0x24, 0x46, 0xf5, 0x9a,
0x34, 0x70, 0x1e, 0xd5, 0xeb, 0x72, 0x4d, 0x4d, 0x34, 0xf0, 0x04, 0xe7, 0x32, 0x06, 0x57, 0x6d,
0x35, 0xc9, 0xe4, 0x4d, 0x33, 0x97, 0x37, 0xcf, 0x80, 0x5c, 0x8f, 0x4e, 0xf2, 0x1e, 0x54, 0x05,
0x75, 0xd1, 0x78, 0xa8, 0xff, 0x7a, 0x57, 0xd5, 0xc8, 0xdd, 0x8f, 0x9f, 0x9c, 0x51, 0x2f, 0xea,
0x6d, 0xa1, 0xf6, 0xff, 0x7e, 0xbe, 0xbb, 0x8e, 0x3c, 0xfb, 0xc1, 0xd4, 0x13, 0x6c, 0x1a, 0x8a,
0x4b, 0x5b, 0xca, 0x58, 0x7f, 0x31, 0x30, 0x6b, 0xe7, 0xa2, 0xb6, 0xd4, 0x16, 0xb1, 0x6b, 0x56,
0x32, 0x00, 0xfb, 0x72, 0xf6, 0xf9, 0x3a, 0x80, 0x4b, 0xf9, 0xe0, 0x73, 0xea, 0x0b, 0xe6, 0x68,
0x23, 0x99, 0x2e, 0xe5, 0x3f, 0x93, 0x0b, 0x58, 0x87, 0x20, 0x79, 0xc6, 0x99, 0x23, 0xad, 0xb5,
0x6c, 0xd7, 0x5d, 0xca, 0x3f, 0xe5, 0xcc, 0x49, 0xf4, 0xaa, 0xbf, 0x86, 0x5e, 0x7f, 0xcd, 0xb8,
0x5c, 0x0a, 0x59, 0xff, 0x0f, 0x9a, 0x7d, 0x65, 0x20, 0x16, 0xe7, 0xd3, 0x1e, 0x39, 0x81, 0x1b,
0x89, 0x7b, 0x0f, 0x66, 0xa1, 0x43, 0xb1, 0x72, 0x32, 0x5e, 0x18, 0x0f, 0x1b, 0x89, 0xc0, 0xa7,
0x8a, 0x9f, 0xfc, 0x18, 0xb6, 0x0b, 0x01, 0x99, 0x6c, 0x55, 0x79, 0x61, 0x5c, 0xde, 0xca, 0xc7,
0x65, 0xbc, 0x5f, 0xac, 0xe5, 0xf2, 0x6b, 0x68, 0xf9, 0x4d, 0x2c, 0x49, 0xb2, 0x69, 0xba, 0xec,
0x9e, 0xac, 0xdf, 0x18, 0xd0, 0x2a, 0x1c, 0x86, 0x1c, 0x00, 0xa8, 0x2c, 0xc7, 0xbd, 0x67, 0x71,
0x61, 0x1c, 0xdb, 0x40, 0x1a, 0xeb, 0x91, 0xf7, 0x8c, 0xd9, 0xe6, 0x30, 0x1e, 0x92, 0xbb, 0x50,
0x17, 0x73, 0xc5, 0x9d, 0x2f, 0xde, 0x1e, 0xcf, 0x25, 0x6b, 0x4d, 0xc8, 0x7f, 0x72, 0x1f, 0x56,
0xd5, 0xc6, 0x6e, 0xc0, 0xb9, 0x17, 0xea, 0xc2, 0x81, 0x64, 0xb7, 0xfe, 0x48, 0x52, 0xec, 0xe6,
0x30, 0x9d, 0x58, 0x3f, 0x07, 0x33, 0xf9, 0x2c, 0x79, 0x03, 0xcc, 0x29, 0x9d, 0xeb, 0xca, 0x16,
0xcf, 0xb6, 0x62, 0x37, 0xa6, 0x74, 0x2e, 0x8b, 0x5a, 0xb2, 0x0d, 0x75, 0x24, 0x8a, 0xb9, 0xb2,
0xf7, 0x8a, 0x5d, 0x9b, 0xd2, 0xf9, 0xe3, 0x79, 0x42, 0x70, 0x29, 0x8f, 0xcb, 0xd6, 0x29, 0x9d,
0x7f, 0x44, 0xb9, 0xf5, 0x01, 0xd4, 0xd4, 0x21, 0x5f, 0x6a, 0x63, 0x94, 0xaf, 0xe4, 0xe4, 0x7f,
0x00, 0xcd, 0xcc, 0xb9, 0xc9, 0x77, 0xe0, 0x96, 0xd2, 0x30, 0xa4, 0x91, 0x90, 0x16, 0xc9, 0x6d,
0x48, 0x24, 0xf1, 0x8c, 0x46, 0x02, 0x3f, 0xa9, 0x0a, 0xf1, 0x08, 0xd6, 0xf3, 0xc5, 0x2a, 0xf9,
0x06, 0xac, 0xea, 0xc2, 0x36, 0x0a, 0x66, 0xbe, 0xa3, 0x65, 0x9b, 0x6a, 0xcd, 0xc6, 0x25, 0xf2,
0xfd, 0x92, 0xb4, 0x1d, 0x23, 0xfa, 0x23, 0xcf, 0xf5, 0x3d, 0xdf, 0x7d, 0x51, 0xf6, 0xfe, 0x5b,
0x05, 0x6a, 0xaa, 0xb0, 0x26, 0x77, 0x33, 0x5d, 0x8c, 0x44, 0xcd, 0x5e, 0xf3, 0xea, 0xf9, 0x6e,
0x5d, 0x02, 0xcc, 0xe9, 0x87, 0x69, 0x4b, 0x93, 0x26, 0xd4, 0x4a, 0xae, 0xee, 0x8f, 0xfb, 0xa7,
0xe5, 0x57, 0xee, 0x9f, 0xb6, 0xa1, 0xee, 0xcf, 0xa6, 0xf2, 0xb2, 0xaa, 0xea, 0xb2, 0xfc, 0xd9,
0x14, 0x2f, 0xeb, 0x0d, 0x30, 0x45, 0x20, 0xe8, 0x44, 0x92, 0x54, 0x52, 0x68, 0xc8, 0x05, 0x24,
0xde, 0x85, 0x56, 0x16, 0xb3, 0x11, 0x83, 0x15, 0x44, 0xac, 0xa5, 0x88, 0x8d, 0xfd, 0xc4, 0x9b,
0xd0, 0x4a, 0x15, 0x56, 0x7c, 0x0a, 0x36, 0xd6, 0xd3, 0x65, 0xc9, 0x78, 0x1b, 0x1a, 0x09, 0x9a,
0x2b, 0x08, 0xa9, 0x53, 0x05, 0xe2, 0xd8, 0xac, 0x87, 0x51, 0x10, 0x06, 0x9c, 0x45, 0xba, 0x4c,
0x5b, 0x94, 0x0a, 0x12, 0x3e, 0xcb, 0x03, 0x33, 0x21, 0x62, 0xe9, 0x41, 0x1d, 0x27, 0x62, 0x9c,
0xeb, 0x2a, 0x3f, 0x9e, 0x92, 0x7d, 0xa8, 0x87, 0xb3, 0xe1, 0x00, 0x11, 0x2e, 0x1f, 0x32, 0x67,
0xb3, 0xe1, 0xc7, 0xec, 0x32, 0xee, 0x77, 0x42, 0x39, 0x93, 0x18, 0x17, 0x7c, 0xce, 0x22, 0xed,
0xbc, 0x6a, 0x62, 0x09, 0xd8, 0x28, 0xde, 0x35, 0xf9, 0x2e, 0x98, 0x89, 0x7e, 0x85, 0xd0, 0x2d,
0x9e, 0x39, 0x65, 0xc4, 0x42, 0x88, 0x7b, 0xae, 0xcf, 0x9c, 0x41, 0x6a, 0x5b, 0x79, 0xae, 0x86,
0xdd, 0x52, 0x84, 0x4f, 0x62, 0xe3, 0x5a, 0xdf, 0x86, 0x9a, 0x3a, 0x23, 0xe6, 0x13, 0xdc, 0x39,
0x2e, 0xb6, 0x70, 0x5c, 0x9a, 0x63, 0xfe, 0x6c, 0x40, 0x23, 0x6e, 0xa2, 0x4a, 0x85, 0x72, 0x87,
0xae, 0xbc, 0xec, 0xa1, 0x17, 0x75, 0xa2, 0xb1, 0x47, 0x56, 0x5f, 0xd9, 0x23, 0xf7, 0x81, 0x28,
0xc7, 0xbb, 0x08, 0x84, 0xe7, 0xbb, 0x03, 0x65, 0x73, 0xe5, 0x81, 0x1b, 0x92, 0xf2, 0x44, 0x12,
0xce, 0x70, 0xfd, 0xf0, 0x8b, 0x15, 0x68, 0x1d, 0xf7, 0x4e, 0x4e, 0x8f, 0xc3, 0x70, 0xe2, 0x8d,
0xa8, 0xac, 0xf0, 0x0e, 0xa0, 0x2a, 0x6b, 0xd8, 0x92, 0x77, 0xb3, 0x4e, 0x59, 0x33, 0x45, 0x0e,
0x61, 0x45, 0x96, 0xb2, 0xa4, 0xec, 0xf9, 0xac, 0x53, 0xda, 0x53, 0xe1, 0x47, 0x54, 0xb1, 0x7b,
0xfd, 0x15, 0xad, 0x53, 0xd6, 0x58, 0x91, 0x0f, 0xc0, 0x4c, 0x8b, 0xd0, 0x45, 0x6f, 0x69, 0x9d,
0x85, 0x2d, 0x16, 0xca, 0xa7, 0x15, 0xc0, 0xa2, 0x27, 0xa1, 0xce, 0xc2, 0x5e, 0x84, 0x1c, 0x41,
0x3d, 0xae, 0x8c, 0xca, 0x5f, 0xbb, 0x3a, 0x0b, 0xda, 0x1f, 0x34, 0x8f, 0xaa, 0x2e, 0xcb, 0x9e,
0xe4, 0x3a, 0xa5, 0x3d, 0x1a, 0xb9, 0x0f, 0x35, 0x0d, 0x78, 0xa5, 0x2f, 0x5e, 0x9d, 0xf2, 0x26,
0x06, 0x95, 0x4c, 0x2b, 0xeb, 0x45, 0xcf, 0x86, 0x9d, 0x85, 0xcd, 0x24, 0x39, 0x06, 0xc8, 0x54,
0x94, 0x0b, 0xdf, 0x03, 0x3b, 0x8b, 0x9b, 0x44, 0xf2, 0x3e, 0x34, 0xd2, 0xc6, 0xbf, 0xfc, 0x85,
0xaf, 0xb3, 0xa8, 0x6f, 0xeb, 0x7d, 0xed, 0x3f, 0xff, 0xdc, 0x31, 0x7e, 0x7b, 0xb5, 0x63, 0xfc,
0xfe, 0x6a, 0xc7, 0xf8, 0xf2, 0x6a, 0xc7, 0xf8, 0xd3, 0xd5, 0x8e, 0xf1, 0x8f, 0xab, 0x1d, 0xe3,
0x0f, 0x5f, 0xed, 0x18, 0xc3, 0x9a, 0x74, 0xff, 0x77, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xc1,
0xc2, 0x93, 0xfb, 0x94, 0x16, 0x00, 0x00,
var fileDescriptor_types_2abffab37bc29540 = []byte{
// 1964 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4f, 0x73, 0x23, 0x47,
0x15, 0xf7, 0xc8, 0xfa, 0x37, 0x4f, 0xb6, 0xa5, 0xb4, 0x77, 0x6d, 0xad, 0x02, 0xf6, 0x32, 0x45,
0x6d, 0x6c, 0xe2, 0xc8, 0xe0, 0xb0, 0x29, 0x6f, 0x02, 0x29, 0x2c, 0x67, 0x89, 0x5c, 0x09, 0x60,
0x66, 0x37, 0x4b, 0x15, 0x97, 0xa9, 0x96, 0xa6, 0x3d, 0x9a, 0x5a, 0x69, 0x66, 0x32, 0xdd, 0x72,
0xe4, 0xfd, 0x08, 0x54, 0x8a, 0xe2, 0xc6, 0x99, 0x1b, 0x5f, 0x80, 0x2a, 0x8e, 0x9c, 0xa8, 0xdc,
0xe0, 0x00, 0xc5, 0x6d, 0x01, 0xa7, 0xb8, 0xf0, 0x09, 0x38, 0x52, 0xaf, 0x7b, 0xfe, 0x7b, 0xb4,
0xb5, 0x59, 0x6e, 0x5c, 0xa4, 0xee, 0x7e, 0xef, 0xf5, 0xf4, 0x7b, 0xfd, 0xde, 0xfb, 0xbd, 0xd7,
0xb0, 0x45, 0x47, 0x63, 0xf7, 0x50, 0x5c, 0x05, 0x8c, 0xab, 0xdf, 0x7e, 0x10, 0xfa, 0xc2, 0x27,
0x35, 0x39, 0xe9, 0xbd, 0xe5, 0xb8, 0x62, 0x32, 0x1f, 0xf5, 0xc7, 0xfe, 0xec, 0xd0, 0xf1, 0x1d,
0xff, 0x50, 0x52, 0x47, 0xf3, 0x0b, 0x39, 0x93, 0x13, 0x39, 0x52, 0x52, 0xbd, 0x5d, 0xc7, 0xf7,
0x9d, 0x29, 0x4b, 0xb9, 0x84, 0x3b, 0x63, 0x5c, 0xd0, 0x59, 0x10, 0x31, 0x1c, 0x67, 0xf6, 0x13,
0xcc, 0xb3, 0x59, 0x38, 0x73, 0x3d, 0x91, 0x1d, 0x4e, 0xdd, 0x11, 0x3f, 0x1c, 0xfb, 0xb3, 0x99,
0xef, 0x65, 0x0f, 0x64, 0xfc, 0xb1, 0x0a, 0x0d, 0x93, 0x7d, 0x3a, 0x67, 0x5c, 0x90, 0x3d, 0xa8,
0xb2, 0xf1, 0xc4, 0xef, 0x56, 0xee, 0x6a, 0x7b, 0xad, 0x23, 0xd2, 0x57, 0x7c, 0x11, 0xf5, 0xe1,
0x78, 0xe2, 0x0f, 0x57, 0x4c, 0xc9, 0x41, 0xde, 0x84, 0xda, 0xc5, 0x74, 0xce, 0x27, 0xdd, 0x55,
0xc9, 0xba, 0x99, 0x67, 0xfd, 0x21, 0x92, 0x86, 0x2b, 0xa6, 0xe2, 0xc1, 0x6d, 0x5d, 0xef, 0xc2,
0xef, 0x56, 0xcb, 0xb6, 0x3d, 0xf3, 0x2e, 0xe4, 0xb6, 0xc8, 0x41, 0x8e, 0x01, 0x38, 0x13, 0x96,
0x1f, 0x08, 0xd7, 0xf7, 0xba, 0x35, 0xc9, 0xbf, 0x9d, 0xe7, 0x7f, 0xc4, 0xc4, 0x4f, 0x24, 0x79,
0xb8, 0x62, 0xea, 0x3c, 0x9e, 0xa0, 0xa4, 0xeb, 0xb9, 0xc2, 0x1a, 0x4f, 0xa8, 0xeb, 0x75, 0xeb,
0x65, 0x92, 0x67, 0x9e, 0x2b, 0x4e, 0x91, 0x8c, 0x92, 0x6e, 0x3c, 0x41, 0x55, 0x3e, 0x9d, 0xb3,
0xf0, 0xaa, 0xdb, 0x28, 0x53, 0xe5, 0xa7, 0x48, 0x42, 0x55, 0x24, 0x0f, 0x79, 0x0f, 0x5a, 0x23,
0xe6, 0xb8, 0x9e, 0x35, 0x9a, 0xfa, 0xe3, 0xa7, 0xdd, 0xa6, 0x14, 0xe9, 0xe6, 0x45, 0x06, 0xc8,
0x30, 0x40, 0xfa, 0x70, 0xc5, 0x84, 0x51, 0x32, 0x23, 0x47, 0xd0, 0x1c, 0x4f, 0xd8, 0xf8, 0xa9,
0x25, 0x16, 0x5d, 0x5d, 0x4a, 0xde, 0xce, 0x4b, 0x9e, 0x22, 0xf5, 0xf1, 0x62, 0xb8, 0x62, 0x36,
0xc6, 0x6a, 0x48, 0xee, 0x83, 0xce, 0x3c, 0x3b, 0xfa, 0x5c, 0x4b, 0x0a, 0x6d, 0x15, 0xee, 0xc5,
0xb3, 0xe3, 0x8f, 0x35, 0x59, 0x34, 0x26, 0x7d, 0xa8, 0xe3, 0x5d, 0xbb, 0xa2, 0xbb, 0x26, 0x65,
0x6e, 0x15, 0x3e, 0x24, 0x69, 0xc3, 0x15, 0x33, 0xe2, 0x42, 0xf3, 0xd9, 0x6c, 0xea, 0x5e, 0xb2,
0x10, 0x0f, 0xb7, 0x59, 0x66, 0xbe, 0x0f, 0x14, 0x5d, 0x1e, 0x4f, 0xb7, 0xe3, 0xc9, 0xa0, 0x01,
0xb5, 0x4b, 0x3a, 0x9d, 0x33, 0xe3, 0x0d, 0x68, 0x65, 0x3c, 0x85, 0x74, 0xa1, 0x31, 0x63, 0x9c,
0x53, 0x87, 0x75, 0xb5, 0xbb, 0xda, 0x9e, 0x6e, 0xc6, 0x53, 0x63, 0x03, 0xd6, 0xb2, 0x7e, 0x92,
0x11, 0x44, 0x5f, 0x40, 0xc1, 0x4b, 0x16, 0x72, 0x74, 0x80, 0x48, 0x30, 0x9a, 0x1a, 0xef, 0x42,
0xa7, 0xe8, 0x04, 0xa4, 0x03, 0xab, 0x4f, 0xd9, 0x55, 0xc4, 0x89, 0x43, 0x72, 0x2b, 0x3a, 0x90,
0xf4, 0x62, 0xdd, 0x8c, 0x4e, 0xf7, 0x8b, 0x4a, 0x22, 0x9c, 0xf8, 0x01, 0x39, 0x86, 0x2a, 0x06,
0x92, 0x94, 0x6e, 0x1d, 0xf5, 0xfa, 0x2a, 0xca, 0xfa, 0x71, 0x94, 0xf5, 0x1f, 0xc7, 0x51, 0x36,
0x68, 0x7e, 0xf1, 0x7c, 0x77, 0xe5, 0x57, 0x7f, 0xdf, 0xd5, 0x4c, 0x29, 0x41, 0xee, 0xe0, 0x55,
0x52, 0xd7, 0xb3, 0x5c, 0x3b, 0xfa, 0x4e, 0x43, 0xce, 0xcf, 0x6c, 0x72, 0x02, 0x9d, 0xb1, 0xef,
0x71, 0xe6, 0xf1, 0x39, 0xb7, 0x02, 0x1a, 0xd2, 0x19, 0x8f, 0xa2, 0x24, 0xbe, 0xb8, 0xd3, 0x98,
0x7c, 0x2e, 0xa9, 0x66, 0x7b, 0x9c, 0x5f, 0x20, 0xef, 0x00, 0x5c, 0xd2, 0xa9, 0x6b, 0x53, 0xe1,
0x87, 0xbc, 0x5b, 0xbd, 0xbb, 0xba, 0xd7, 0x3a, 0xea, 0x44, 0xc2, 0x4f, 0x62, 0xc2, 0xa0, 0x8a,
0x67, 0x32, 0x33, 0x9c, 0xe4, 0x1e, 0xb4, 0x69, 0x10, 0x58, 0x5c, 0x50, 0xc1, 0xac, 0xd1, 0x95,
0x60, 0x5c, 0xc6, 0xd0, 0x9a, 0xb9, 0x4e, 0x83, 0xe0, 0x11, 0xae, 0x0e, 0x70, 0xd1, 0xb0, 0x93,
0x1b, 0x90, 0xee, 0x4d, 0x08, 0x54, 0x6d, 0x2a, 0xa8, 0xb4, 0xc3, 0x9a, 0x29, 0xc7, 0xb8, 0x16,
0x50, 0x31, 0x89, 0xb4, 0x93, 0x63, 0xb2, 0x05, 0xf5, 0x09, 0x73, 0x9d, 0x89, 0x90, 0x0a, 0xad,
0x9a, 0xd1, 0x0c, 0x4d, 0x1e, 0x84, 0xfe, 0x25, 0x93, 0x11, 0xde, 0x34, 0xd5, 0xc4, 0xf8, 0x97,
0x06, 0xaf, 0xdd, 0x08, 0x09, 0xdc, 0x77, 0x42, 0xf9, 0x24, 0xfe, 0x16, 0x8e, 0xc9, 0x9b, 0xb8,
0x2f, 0xb5, 0x59, 0x18, 0x65, 0x9e, 0xf5, 0x48, 0xd7, 0xa1, 0x5c, 0x8c, 0x14, 0x8d, 0x58, 0xc8,
0x43, 0xe8, 0x4c, 0x29, 0x17, 0x96, 0xf2, 0x5c, 0x4b, 0x66, 0x96, 0xd5, 0x5c, 0x34, 0x7d, 0x4c,
0x63, 0x0f, 0x47, 0x87, 0x8a, 0xc4, 0x37, 0xa6, 0xb9, 0x55, 0x32, 0x84, 0x5b, 0xa3, 0xab, 0x67,
0xd4, 0x13, 0xae, 0xc7, 0xac, 0x1b, 0xd6, 0x6e, 0x47, 0x5b, 0x3d, 0xbc, 0x74, 0x6d, 0xe6, 0x8d,
0x59, 0xb4, 0xc9, 0x66, 0x22, 0x92, 0x5c, 0x03, 0x37, 0xee, 0xc2, 0x46, 0x3e, 0x7e, 0xc9, 0x06,
0x54, 0xc4, 0x22, 0xd2, 0xb0, 0x22, 0x16, 0x86, 0x91, 0xf8, 0x5e, 0x12, 0x44, 0x37, 0x78, 0xf6,
0xa1, 0x5d, 0x08, 0xe8, 0x8c, 0xb9, 0xb5, 0xac, 0xb9, 0x8d, 0x36, 0xac, 0xe7, 0xe2, 0xd8, 0xf8,
0xbc, 0x06, 0x4d, 0x93, 0xf1, 0x00, 0xdd, 0x88, 0x1c, 0x83, 0xce, 0x16, 0x63, 0xa6, 0x52, 0xa8,
0x56, 0x48, 0x50, 0x8a, 0xe7, 0x61, 0x4c, 0xc7, 0x50, 0x4e, 0x98, 0xc9, 0x7e, 0x2e, 0xfd, 0x6f,
0x16, 0x85, 0xb2, 0xf9, 0xff, 0x20, 0x9f, 0xff, 0x6f, 0x15, 0x78, 0x0b, 0x00, 0xb0, 0x9f, 0x03,
0x80, 0xe2, 0xc6, 0x39, 0x04, 0x78, 0x50, 0x82, 0x00, 0xc5, 0xe3, 0x2f, 0x81, 0x80, 0x07, 0x25,
0x10, 0xd0, 0xbd, 0xf1, 0xad, 0x52, 0x0c, 0x38, 0xc8, 0x63, 0x40, 0x51, 0x9d, 0x02, 0x08, 0x7c,
0xaf, 0x0c, 0x04, 0xee, 0x14, 0x64, 0x96, 0xa2, 0xc0, 0xdb, 0x37, 0x50, 0x60, 0xab, 0x20, 0x5a,
0x02, 0x03, 0x0f, 0x72, 0xf9, 0x19, 0x4a, 0x75, 0x2b, 0x4f, 0xd0, 0xe4, 0x9d, 0x9b, 0x08, 0xb2,
0x5d, 0xbc, 0xda, 0x32, 0x08, 0x39, 0x2c, 0x40, 0xc8, 0xed, 0xe2, 0x29, 0x0b, 0x18, 0x92, 0x22,
0xc1, 0x3e, 0xc6, 0x7d, 0xc1, 0xd3, 0x30, 0x47, 0xb0, 0x30, 0xf4, 0xc3, 0x28, 0x55, 0xab, 0x89,
0xb1, 0x87, 0x99, 0x28, 0xf5, 0xaf, 0x17, 0xa0, 0x86, 0x74, 0xfa, 0x8c, 0x77, 0x19, 0xbf, 0xd6,
0x52, 0x59, 0x19, 0xd1, 0xd9, 0x2c, 0xa6, 0x47, 0x59, 0x2c, 0x03, 0x26, 0x95, 0x1c, 0x98, 0x90,
0x6f, 0xc1, 0x6b, 0x32, 0x8d, 0x48, 0xbb, 0x58, 0xb9, 0xb4, 0xd6, 0x46, 0x82, 0x32, 0x88, 0xca,
0x6f, 0x6f, 0xc1, 0x66, 0x86, 0x17, 0x53, 0xac, 0x4c, 0x61, 0x55, 0x19, 0xbc, 0x9d, 0x84, 0xfb,
0x24, 0x08, 0x86, 0x94, 0x4f, 0x8c, 0x1f, 0xa5, 0xfa, 0xa7, 0x40, 0x45, 0xa0, 0x3a, 0xf6, 0x6d,
0xa5, 0xd6, 0xba, 0x29, 0xc7, 0x08, 0x5e, 0x53, 0xdf, 0x91, 0x5f, 0xd5, 0x4d, 0x1c, 0x22, 0x57,
0x12, 0x29, 0xba, 0x0a, 0x09, 0xe3, 0x97, 0x5a, 0xba, 0x5f, 0x8a, 0x5d, 0x65, 0x30, 0xa3, 0xfd,
0x2f, 0x30, 0x53, 0x79, 0x59, 0x98, 0x31, 0x7e, 0xa7, 0xa5, 0x77, 0x91, 0x00, 0xc8, 0xab, 0x29,
0x87, 0x6e, 0xe1, 0x7a, 0x36, 0x5b, 0xc8, 0x50, 0x5f, 0x35, 0xd5, 0x24, 0x46, 0xf5, 0xba, 0x34,
0x70, 0x1e, 0xd5, 0x1b, 0x72, 0x4d, 0x4d, 0x22, 0xe0, 0xf1, 0x2f, 0x64, 0x0c, 0xae, 0x99, 0x6a,
0x92, 0xc9, 0x9b, 0x7a, 0x2e, 0x6f, 0x9e, 0x03, 0xb9, 0x19, 0x9d, 0xe4, 0x5d, 0xa8, 0x0a, 0xea,
0xa0, 0xf1, 0x50, 0xff, 0x8d, 0xbe, 0xaa, 0x91, 0xfb, 0x1f, 0x3d, 0x39, 0xa7, 0x6e, 0x38, 0xd8,
0x42, 0xed, 0xff, 0xfd, 0x7c, 0x77, 0x03, 0x79, 0x0e, 0xfc, 0x99, 0x2b, 0xd8, 0x2c, 0x10, 0x57,
0xa6, 0x94, 0x31, 0xfe, 0xaa, 0x61, 0xd6, 0xce, 0x45, 0x6d, 0xa9, 0x2d, 0x62, 0xd7, 0xac, 0x64,
0x00, 0xf6, 0xe5, 0xec, 0xf3, 0x75, 0x00, 0x87, 0x72, 0xeb, 0x33, 0xea, 0x09, 0x66, 0x47, 0x46,
0xd2, 0x1d, 0xca, 0x7f, 0x26, 0x17, 0xb0, 0x0e, 0x41, 0xf2, 0x9c, 0x33, 0x5b, 0x5a, 0x6b, 0xd5,
0x6c, 0x38, 0x94, 0x7f, 0xc2, 0x99, 0x9d, 0xe8, 0xd5, 0x78, 0x05, 0xbd, 0xfe, 0x96, 0x71, 0xb9,
0x14, 0xb2, 0xfe, 0x1f, 0x34, 0xfb, 0x52, 0x43, 0x2c, 0xce, 0xa7, 0x3d, 0x72, 0x0a, 0xaf, 0x25,
0xee, 0x6d, 0xcd, 0x03, 0x9b, 0x62, 0xe5, 0xa4, 0xbd, 0x30, 0x1e, 0x3a, 0x89, 0xc0, 0x27, 0x8a,
0x9f, 0xfc, 0x18, 0xb6, 0x0b, 0x01, 0x99, 0x6c, 0x55, 0x79, 0x61, 0x5c, 0xde, 0xce, 0xc7, 0x65,
0xbc, 0x5f, 0xac, 0xe5, 0xea, 0x2b, 0x68, 0xf9, 0x4d, 0x2c, 0x49, 0xb2, 0x69, 0xba, 0xec, 0x9e,
0x8c, 0xdf, 0x68, 0xd0, 0x2e, 0x1c, 0x86, 0x1c, 0x02, 0xa8, 0x2c, 0xc7, 0xdd, 0x67, 0x71, 0x61,
0x1c, 0xdb, 0x40, 0x1a, 0xeb, 0x91, 0xfb, 0x8c, 0x99, 0xfa, 0x28, 0x1e, 0x92, 0x7b, 0xd0, 0x10,
0x0b, 0xc5, 0x9d, 0x2f, 0xde, 0x1e, 0x2f, 0x24, 0x6b, 0x5d, 0xc8, 0x7f, 0x72, 0x1f, 0xd6, 0xd4,
0xc6, 0x8e, 0xcf, 0xb9, 0x1b, 0x44, 0x85, 0x03, 0xc9, 0x6e, 0xfd, 0xa1, 0xa4, 0x98, 0xad, 0x51,
0x3a, 0x31, 0x7e, 0x0e, 0x7a, 0xf2, 0x59, 0xf2, 0x3a, 0xe8, 0x33, 0xba, 0x88, 0x2a, 0x5b, 0x3c,
0x5b, 0xcd, 0x6c, 0xce, 0xe8, 0x42, 0x16, 0xb5, 0x64, 0x1b, 0x1a, 0x48, 0x14, 0x0b, 0x65, 0xef,
0x9a, 0x59, 0x9f, 0xd1, 0xc5, 0xe3, 0x45, 0x42, 0x70, 0x28, 0x8f, 0xcb, 0xd6, 0x19, 0x5d, 0x7c,
0x48, 0xb9, 0xf1, 0x3e, 0xd4, 0xd5, 0x21, 0x5f, 0x6a, 0x63, 0x94, 0xaf, 0xe4, 0xe4, 0x7f, 0x00,
0xad, 0xcc, 0xb9, 0xc9, 0x77, 0xe0, 0xb6, 0xd2, 0x30, 0xa0, 0xa1, 0x90, 0x16, 0xc9, 0x6d, 0x48,
0x24, 0xf1, 0x9c, 0x86, 0x02, 0x3f, 0xa9, 0x0a, 0xf1, 0x10, 0x36, 0xf2, 0xc5, 0x2a, 0xf9, 0x06,
0xac, 0x45, 0x85, 0x6d, 0xe8, 0xcf, 0x3d, 0x3b, 0x92, 0x6d, 0xa9, 0x35, 0x13, 0x97, 0xc8, 0xf7,
0x4b, 0xd2, 0x76, 0x8c, 0xe8, 0x8f, 0x5c, 0xc7, 0x73, 0x3d, 0xe7, 0x45, 0xd9, 0xfb, 0x4f, 0x15,
0xa8, 0xab, 0xc2, 0x9a, 0xdc, 0xcb, 0x74, 0x31, 0x12, 0x35, 0x07, 0xad, 0xeb, 0xe7, 0xbb, 0x0d,
0x09, 0x30, 0x67, 0x1f, 0xa4, 0x2d, 0x4d, 0x9a, 0x50, 0x2b, 0xb9, 0xba, 0x3f, 0xee, 0x9f, 0x56,
0xbf, 0x72, 0xff, 0xb4, 0x0d, 0x0d, 0x6f, 0x3e, 0x93, 0x97, 0x55, 0x55, 0x97, 0xe5, 0xcd, 0x67,
0x78, 0x59, 0xaf, 0x83, 0x2e, 0x7c, 0x41, 0xa7, 0x92, 0xa4, 0x92, 0x42, 0x53, 0x2e, 0x20, 0xf1,
0x1e, 0xb4, 0xb3, 0x98, 0x8d, 0x18, 0xac, 0x20, 0x62, 0x3d, 0x45, 0x6c, 0xec, 0x27, 0xde, 0x80,
0x76, 0xaa, 0xb0, 0xe2, 0x53, 0xb0, 0xb1, 0x91, 0x2e, 0x4b, 0xc6, 0x3b, 0xd0, 0x4c, 0xd0, 0x5c,
0x41, 0x48, 0x83, 0x2a, 0x10, 0x27, 0xfb, 0xd0, 0x09, 0x42, 0x3f, 0xf0, 0x39, 0x0b, 0x2d, 0x6a,
0xdb, 0x21, 0xe3, 0x5c, 0xc2, 0xc9, 0x9a, 0xd9, 0x8e, 0xd7, 0x4f, 0xd4, 0xb2, 0xe1, 0x82, 0x9e,
0x18, 0x1c, 0x2b, 0x8e, 0x98, 0x5d, 0x8b, 0x76, 0x54, 0x53, 0x72, 0x00, 0x8d, 0x60, 0x3e, 0xb2,
0x10, 0xd8, 0xf2, 0x91, 0x72, 0x3e, 0x1f, 0x7d, 0xc4, 0xae, 0xe2, 0x36, 0x27, 0x90, 0x33, 0x09,
0x6d, 0xfe, 0x67, 0x2c, 0x8c, 0x7c, 0x56, 0x4d, 0x0c, 0x01, 0x9d, 0xe2, 0x15, 0x93, 0xef, 0x82,
0x9e, 0xa8, 0x55, 0x88, 0xd8, 0xa2, 0x1f, 0xa4, 0x8c, 0x58, 0xff, 0x70, 0xd7, 0xf1, 0x98, 0x6d,
0xa5, 0x26, 0x95, 0xe7, 0x6a, 0x9a, 0x6d, 0x45, 0xf8, 0x38, 0xb6, 0xa9, 0xf1, 0x6d, 0xa8, 0xab,
0x33, 0x62, 0x1a, 0xc1, 0x9d, 0xe3, 0x1a, 0x0b, 0xc7, 0xa5, 0xa9, 0xe5, 0x2f, 0x1a, 0x34, 0xe3,
0xde, 0xa9, 0x54, 0x28, 0x77, 0xe8, 0xca, 0xcb, 0x1e, 0x7a, 0x59, 0x03, 0x1a, 0x3b, 0x62, 0xf5,
0x2b, 0x3b, 0xe2, 0x01, 0x10, 0xe5, 0x6f, 0x97, 0xbe, 0x70, 0x3d, 0xc7, 0x52, 0x36, 0x57, 0x8e,
0xd7, 0x91, 0x94, 0x27, 0x92, 0x70, 0x8e, 0xeb, 0x47, 0x9f, 0xd7, 0xa0, 0x7d, 0x32, 0x38, 0x3d,
0x3b, 0x09, 0x82, 0xa9, 0x3b, 0xa6, 0xb2, 0xb0, 0x3b, 0x84, 0xaa, 0x2c, 0x5d, 0x4b, 0x9e, 0xcb,
0x7a, 0x65, 0x3d, 0x14, 0x39, 0x82, 0x9a, 0xac, 0x60, 0x49, 0xd9, 0xab, 0x59, 0xaf, 0xb4, 0x95,
0xc2, 0x8f, 0xa8, 0x1a, 0xf7, 0xe6, 0xe3, 0x59, 0xaf, 0xac, 0x9f, 0x22, 0xef, 0x83, 0x9e, 0xd6,
0x9e, 0xcb, 0x9e, 0xd0, 0x7a, 0x4b, 0x3b, 0x2b, 0x94, 0x4f, 0x81, 0x7f, 0xd9, 0x4b, 0x50, 0x6f,
0x69, 0x0b, 0x42, 0x8e, 0xa1, 0x11, 0x17, 0x44, 0xe5, 0x8f, 0x5c, 0xbd, 0x25, 0x5d, 0x0f, 0x9a,
0x47, 0x15, 0x95, 0x65, 0x2f, 0x71, 0xbd, 0xd2, 0xd6, 0x8c, 0xdc, 0x87, 0x7a, 0x84, 0x73, 0xa5,
0x0f, 0x5d, 0xbd, 0xf2, 0xde, 0x05, 0x95, 0x4c, 0x0b, 0xea, 0x65, 0xaf, 0x85, 0xbd, 0xa5, 0x3d,
0x24, 0x39, 0x01, 0xc8, 0x14, 0x92, 0x4b, 0x9f, 0x01, 0x7b, 0xcb, 0x7b, 0x43, 0xf2, 0x1e, 0x34,
0xd3, 0x7e, 0xbf, 0xfc, 0x61, 0xaf, 0xb7, 0xac, 0x5d, 0x1b, 0x7c, 0xed, 0x3f, 0xff, 0xdc, 0xd1,
0x7e, 0x7b, 0xbd, 0xa3, 0xfd, 0xfe, 0x7a, 0x47, 0xfb, 0xe2, 0x7a, 0x47, 0xfb, 0xf3, 0xf5, 0x8e,
0xf6, 0x8f, 0xeb, 0x1d, 0xed, 0x0f, 0x5f, 0xee, 0x68, 0xa3, 0xba, 0x74, 0xff, 0xb7, 0xff, 0x1b,
0x00, 0x00, 0xff, 0xff, 0x79, 0xfd, 0x53, 0xad, 0x8b, 0x16, 0x00, 0x00,
}

2
abci/types/types.proto
View File

@ -249,7 +249,7 @@ message Header {
bytes app_hash = 8;
// consensus
Validator proposer = 9 [(gogoproto.nullable)=false];
bytes proposer_address = 9;
}
// Validator

8
docs/spec/blockchain/blockchain.md
View File

@ -57,8 +57,8 @@ type Header struct {
ConsensusParamsHash []byte // SimpleMerkle of the ConsensusParams
// consensus
Proposer []byte // Address of the block proposer
EvidenceHash []byte // SimpleMerkle of []Evidence
ProposerAddress []byte // Address of the original proposer of the block
}
```
@ -300,13 +300,13 @@ block.ConsensusParamsHash == SimpleMerkleRoot(state.ConsensusParams)
Simple Merkle root of the consensus parameters.
May be updated by the application.
### Proposer
### ProposerAddress
```go
block.Header.Proposer in state.Validators
block.Header.ProposerAddress in state.Validators
```
Original proposer of the block. Must be a current validator.
Address of the original proposer of the block. Must be a current validator.
NOTE: we also need to track the round.

5
state/state.go
View File

@ -98,7 +98,8 @@ func (state State) IsEmpty() bool {
//------------------------------------------------------------------------
// Create a block from the latest state
// MakeBlock builds a block from the current state with the given txs, commit, and evidence.
// MakeBlock builds a block from the current state with the given txs, commit,
// and evidence.
func (state State) MakeBlock(
height int64,
txs []types.Tx,
@ -121,6 +122,8 @@ func (state State) MakeBlock(
block.AppHash = state.AppHash
block.LastResultsHash = state.LastResultsHash
block.ProposerAddress = state.Validators.GetProposer().Address
return block, block.MakePartSet(state.ConsensusParams.BlockGossip.BlockPartSizeBytes)
}

11
state/state_test.go
View File

@ -301,6 +301,17 @@ func genValSet(size int) *types.ValidatorSet {
return types.NewValidatorSet(vals)
}
func TestStateMakeBlock(t *testing.T) {
tearDown, _, state := setupTestCase(t)
defer tearDown(t)
proposerAddress := state.Validators.GetProposer().Address
block := makeBlock(state, 2)
// test we set proposer address
assert.Equal(t, proposerAddress, block.ProposerAddress)
}
// TestConsensusParamsChangesSaveLoad tests saving and loading consensus params
// with changes.
func TestConsensusParamsChangesSaveLoad(t *testing.T) {

65
state/validation.go
View File

@ -5,8 +5,8 @@ import (
"errors"
"fmt"
"github.com/tendermint/tendermint/types"
dbm "github.com/tendermint/tendermint/libs/db"
"github.com/tendermint/tendermint/types"
)
//-----------------------------------------------------
@ -20,10 +20,18 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
// Validate basic info.
if block.ChainID != state.ChainID {
return fmt.Errorf("Wrong Block.Header.ChainID. Expected %v, got %v", state.ChainID, block.ChainID)
return fmt.Errorf(
"Wrong Block.Header.ChainID. Expected %v, got %v",
state.ChainID,
block.ChainID,
)
}
if block.Height != state.LastBlockHeight+1 {
return fmt.Errorf("Wrong Block.Header.Height. Expected %v, got %v", state.LastBlockHeight+1, block.Height)
return fmt.Errorf(
"Wrong Block.Header.Height. Expected %v, got %v",
state.LastBlockHeight+1,
block.Height,
)
}
/* TODO: Determine bounds for Time
See blockchain/reactor "stopSyncingDurationMinutes"
@ -35,25 +43,49 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
// Validate prev block info.
if !block.LastBlockID.Equals(state.LastBlockID) {
return fmt.Errorf("Wrong Block.Header.LastBlockID. Expected %v, got %v", state.LastBlockID, block.LastBlockID)
return fmt.Errorf(
"Wrong Block.Header.LastBlockID. Expected %v, got %v",
state.LastBlockID,
block.LastBlockID,
)
}
newTxs := int64(len(block.Data.Txs))
if block.TotalTxs != state.LastBlockTotalTx+newTxs {
return fmt.Errorf("Wrong Block.Header.TotalTxs. Expected %v, got %v", state.LastBlockTotalTx+newTxs, block.TotalTxs)
return fmt.Errorf(
"Wrong Block.Header.TotalTxs. Expected %v, got %v",
state.LastBlockTotalTx+newTxs,
block.TotalTxs,
)
}
// Validate app info
if !bytes.Equal(block.AppHash, state.AppHash) {
return fmt.Errorf("Wrong Block.Header.AppHash. Expected %X, got %v", state.AppHash, block.AppHash)
return fmt.Errorf(
"Wrong Block.Header.AppHash. Expected %X, got %v",
state.AppHash,
block.AppHash,
)
}
if !bytes.Equal(block.ConsensusHash, state.ConsensusParams.Hash()) {
return fmt.Errorf("Wrong Block.Header.ConsensusHash. Expected %X, got %v", state.ConsensusParams.Hash(), block.ConsensusHash)
return fmt.Errorf(
"Wrong Block.Header.ConsensusHash. Expected %X, got %v",
state.ConsensusParams.Hash(),
block.ConsensusHash,
)
}
if !bytes.Equal(block.LastResultsHash, state.LastResultsHash) {
return fmt.Errorf("Wrong Block.Header.LastResultsHash. Expected %X, got %v", state.LastResultsHash, block.LastResultsHash)
return fmt.Errorf(
"Wrong Block.Header.LastResultsHash. Expected %X, got %v",
state.LastResultsHash,
block.LastResultsHash,
)
}
if !bytes.Equal(block.ValidatorsHash, state.Validators.Hash()) {
return fmt.Errorf("Wrong Block.Header.ValidatorsHash. Expected %X, got %v", state.Validators.Hash(), block.ValidatorsHash)
return fmt.Errorf(
"Wrong Block.Header.ValidatorsHash. Expected %X, got %v",
state.Validators.Hash(),
block.ValidatorsHash,
)
}
if !bytes.Equal(block.NextValidatorsHash, state.NextValidators.Hash()) {
return fmt.Errorf("Wrong Block.Header.NextValidatorsHash. Expected %X, got %v", state.NextValidators.Hash(), block.NextValidatorsHash)
@ -66,8 +98,11 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
}
} else {
if len(block.LastCommit.Precommits) != state.LastValidators.Size() {
return fmt.Errorf("Invalid block commit size. Expected %v, got %v",
state.LastValidators.Size(), len(block.LastCommit.Precommits))
return fmt.Errorf(
"Invalid block commit size. Expected %v, got %v",
state.LastValidators.Size(),
len(block.LastCommit.Precommits),
)
}
err := state.LastValidators.VerifyCommit(
state.ChainID, state.LastBlockID, block.Height-1, block.LastCommit)
@ -86,6 +121,14 @@ func validateBlock(stateDB dbm.DB, state State, block *types.Block) error {
}
}
if !bytes.Equal(block.ProposerAddress, state.Validators.GetProposer().Address) {
return fmt.Errorf(
"Wrong Block.Header.ProposerAddress. Expected %X, got %v",
state.Validators.GetProposer().Address,
block.ProposerAddress,
)
}
return nil
}

7
state/validation_test.go
View File

@ -4,6 +4,7 @@ import (
"testing"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
dbm "github.com/tendermint/tendermint/libs/db"
"github.com/tendermint/tendermint/libs/log"
)
@ -65,4 +66,10 @@ func TestValidateBlock(t *testing.T) {
block.ValidatorsHash = []byte("wrong validators hash")
err = blockExec.ValidateBlock(state, block)
require.Error(t, err)
// wrong proposer address
block = makeBlock(state, 1)
block.ProposerAddress = ed25519.GenPrivKey().PubKey().Address()
err = blockExec.ValidateBlock(state, block)
require.Error(t, err)
}

39
types/block.go
View File

@ -23,9 +23,10 @@ type Block struct {
LastCommit *Commit `json:"last_commit"`
}
// MakeBlock returns a new block with an empty header, except what can be computed from itself.
// It populates the same set of fields validated by ValidateBasic
func MakeBlock(height int64, txs []Tx, commit *Commit, evidence []Evidence) *Block {
// MakeBlock returns a new block with an empty header, except what can be
// computed from itself.
// It populates the same set of fields validated by ValidateBasic.
func MakeBlock(height int64, txs []Tx, lastCommit *Commit, evidence []Evidence) *Block {
block := &Block{
Header: Header{
Height: height,
@ -36,7 +37,7 @@ func MakeBlock(height int64, txs []Tx, commit *Commit, evidence []Evidence) *Blo
Txs: txs,
},
Evidence: EvidenceData{Evidence: evidence},
LastCommit: commit,
LastCommit: lastCommit,
}
block.fillHeader()
return block
@ -53,10 +54,18 @@ func (b *Block) ValidateBasic() error {
newTxs := int64(len(b.Data.Txs))
if b.NumTxs != newTxs {
return fmt.Errorf("Wrong Block.Header.NumTxs. Expected %v, got %v", newTxs, b.NumTxs)
return fmt.Errorf(
"Wrong Block.Header.NumTxs. Expected %v, got %v",
newTxs,
b.NumTxs,
)
}
if !bytes.Equal(b.LastCommitHash, b.LastCommit.Hash()) {
return fmt.Errorf("Wrong Block.Header.LastCommitHash. Expected %v, got %v", b.LastCommitHash, b.LastCommit.Hash())
return fmt.Errorf(
"Wrong Block.Header.LastCommitHash. Expected %v, got %v",
b.LastCommitHash,
b.LastCommit.Hash(),
)
}
if b.Header.Height != 1 {
if err := b.LastCommit.ValidateBasic(); err != nil {
@ -64,10 +73,18 @@ func (b *Block) ValidateBasic() error {
}
}
if !bytes.Equal(b.DataHash, b.Data.Hash()) {
return fmt.Errorf("Wrong Block.Header.DataHash. Expected %v, got %v", b.DataHash, b.Data.Hash())
return fmt.Errorf(
"Wrong Block.Header.DataHash. Expected %v, got %v",
b.DataHash,
b.Data.Hash(),
)
}
if !bytes.Equal(b.EvidenceHash, b.Evidence.Hash()) {
return errors.New(cmn.Fmt("Wrong Block.Header.EvidenceHash. Expected %v, got %v", b.EvidenceHash, b.Evidence.Hash()))
return fmt.Errorf(
"Wrong Block.Header.EvidenceHash. Expected %v, got %v",
b.EvidenceHash,
b.Evidence.Hash(),
)
}
return nil
}
@ -200,7 +217,8 @@ type Header struct {
LastResultsHash cmn.HexBytes `json:"last_results_hash"` // root hash of all results from the txs from the previous block
// consensus info
EvidenceHash cmn.HexBytes `json:"evidence_hash"` // evidence included in the block
EvidenceHash cmn.HexBytes `json:"evidence_hash"` // evidence included in the block
ProposerAddress Address `json:"proposer_address"` // original proposer of the block
}
// Hash returns the hash of the header.
@ -226,6 +244,7 @@ func (h *Header) Hash() cmn.HexBytes {
"Consensus": aminoHasher(h.ConsensusHash),
"Results": aminoHasher(h.LastResultsHash),
"Evidence": aminoHasher(h.EvidenceHash),
"Proposer": aminoHasher(h.ProposerAddress),
})
}
@ -249,6 +268,7 @@ func (h *Header) StringIndented(indent string) string {
%s Consensus: %v
%s Results: %v
%s Evidence: %v
%s Proposer: %v
%s}#%v`,
indent, h.ChainID,
indent, h.Height,
@ -264,6 +284,7 @@ func (h *Header) StringIndented(indent string) string {
indent, h.ConsensusHash,
indent, h.LastResultsHash,
indent, h.EvidenceHash,
indent, h.ProposerAddress,
indent, h.Hash())
}

1
types/block_test.go
View File

@ -44,6 +44,7 @@ func TestBlockValidateBasic(t *testing.T) {
block := MakeBlock(h, txs, commit, evList)
require.NotNil(t, block)
block.ProposerAddress = valSet.GetProposer().Address
// proper block must pass
err = block.ValidateBasic()

2
types/protobuf.go
View File

@ -46,7 +46,7 @@ func (tm2pb) Header(header *Header) abci.Header {
ValidatorsHash: header.ValidatorsHash,
AppHash: header.AppHash,
// Proposer: TODO
ProposerAddress: header.ProposerAddress,
}
}

8
types/protobuf_test.go
View File

@ -76,13 +76,15 @@ func TestABCIConsensusParams(t *testing.T) {
func TestABCIHeader(t *testing.T) {
header := &Header{
Height: int64(3),
Time: time.Now(),
NumTxs: int64(10),
Height: int64(3),
Time: time.Now(),
NumTxs: int64(10),
ProposerAddress: []byte("cloak"),
}
abciHeader := TM2PB.Header(header)
assert.Equal(t, int64(3), abciHeader.Height)
assert.Equal(t, []byte("cloak"), abciHeader.ProposerAddress)
}
func TestABCIEvidence(t *testing.T) {