mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-07-19 22:42:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Old PrepareProposal and vote extension integration on feature/abci++ppp (#9117)

Browse Source 
* abci: PrepareProposal-VoteExtension integration [2nd try] (#7821)

* PrepareProposal-VoteExtension integration (#6915)

* make proto-gen

* Fix protobuf crash in e2e nightly tests

* Update types/vote.go

Co-authored-by: M. J. Fromberger <fromberger@interchain.io>

* Addressed @creachadair's comments

Co-authored-by: mconcat <monoidconcat@gmail.com>
Co-authored-by: M. J. Fromberger <fromberger@interchain.io>

* Proto changes

* make proto-gen

* Fixed UTs

* bump

* lint

* lint2

* lint3

* lint4

* lint5

* lint6

* no_lint

Co-authored-by: mconcat <monoidconcat@gmail.com>
Co-authored-by: M. J. Fromberger <fromberger@interchain.io>
This commit is contained in:
Sergio Mena
2022-08-03 13:29:15 +02:00
committed by GitHub
parent 61619ab072
commit 2164883501
42 changed files with 378 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
abci/types/types.pb.go
+248 -182
View File
@@ -1235,6 +1235,9 @@ type RequestPrepareProposal struct {
BlockData [][]byte `protobuf:"bytes,1,rep,name=block_data,json=blockData,proto3" json:"block_data,omitempty"`
// If an application decides to populate block_data with extra information, they can not exceed this value.
BlockDataSize int64 `protobuf:"varint,2,opt,name=block_data_size,json=blockDataSize,proto3" json:"block_data_size,omitempty"`
// votes includes all votes from the previous block. This contains vote extension data that can be used in proposal
// preparation. The votes here will then form the last commit that gets sent in the proposed block.
Votes []*types1.Vote `protobuf:"bytes,3,rep,name=votes,proto3" json:"votes,omitempty"`
}
func (m *RequestPrepareProposal) Reset() { *m = RequestPrepareProposal{} }
@@ -1284,6 +1287,13 @@ func (m *RequestPrepareProposal) GetBlockDataSize() int64 {
return 0
}
func (m *RequestPrepareProposal) GetVotes() []*types1.Vote {
if m != nil {
return m.Votes
}
return nil
}
type Response struct {
// Types that are valid to be assigned to Value:
// *Response_Exception
@@ -3353,188 +3363,190 @@ func init() {
func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
var fileDescriptor_252557cfdd89a31a = []byte{
// 2894 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x73, 0x23, 0xc5,
0x15, 0xd7, 0xb7, 0x34, 0x4f, 0xd6, 0x87, 0x7b, 0x97, 0x5d, 0x31, 0xec, 0xda, 0xcb, 0x50, 0xc0,
0xb2, 0x80, 0x1d, 0x4c, 0x41, 0x96, 0x40, 0x02, 0x96, 0x56, 0x8b, 0x8c, 0x8d, 0xed, 0x8c, 0xb5,
0x4b, 0xbe, 0xd8, 0x61, 0xa4, 0x69, 0x4b, 0xc3, 0x4a, 0x33, 0xc3, 0x4c, 0xcb, 0xd8, 0x7b, 0x4c,
0x25, 0x17, 0x72, 0xe1, 0x98, 0x0b, 0xff, 0x47, 0x0e, 0xa9, 0x5c, 0x72, 0xa1, 0x2a, 0x17, 0x8e,
0x39, 0xa4, 0x48, 0x8a, 0x3d, 0xa4, 0x92, 0x7f, 0x20, 0xa7, 0x54, 0x52, 0xfd, 0x31, 0x5f, 0x92,
0xc6, 0x92, 0x21, 0xb7, 0xdc, 0xba, 0x5f, 0xbf, 0xf7, 0x66, 0xba, 0xa7, 0xfb, 0xf7, 0x7e, 0xef,
0xf5, 0xc0, 0x53, 0x04, 0x5b, 0x06, 0x76, 0xc7, 0xa6, 0x45, 0x36, 0xf5, 0x5e, 0xdf, 0xdc, 0x24,
0x67, 0x0e, 0xf6, 0x36, 0x1c, 0xd7, 0x26, 0x36, 0xaa, 0x85, 0x83, 0x1b, 0x74, 0x50, 0xbe, 0x1e,
0xd1, 0xee, 0xbb, 0x67, 0x0e, 0xb1, 0x37, 0x1d, 0xd7, 0xb6, 0x8f, 0xb9, 0xbe, 0x7c, 0x2d, 0x32,
0xcc, 0xfc, 0x44, 0xbd, 0xc5, 0x46, 0x85, 0xf1, 0x43, 0x7c, 0xe6, 0x8f, 0x5e, 0x9f, 0xb1, 0x75,
0x74, 0x57, 0x1f, 0xfb, 0xc3, 0xeb, 0x03, 0xdb, 0x1e, 0x8c, 0xf0, 0x26, 0xeb, 0xf5, 0x26, 0xc7,
0x9b, 0xc4, 0x1c, 0x63, 0x8f, 0xe8, 0x63, 0x47, 0x28, 0x5c, 0x1e, 0xd8, 0x03, 0x9b, 0x35, 0x37,
0x69, 0x8b, 0x4b, 0x95, 0xbf, 0x97, 0xa0, 0xa8, 0xe2, 0x4f, 0x26, 0xd8, 0x23, 0x68, 0x0b, 0x72,
0xb8, 0x3f, 0xb4, 0x1b, 0xe9, 0x1b, 0xe9, 0x9b, 0xe5, 0xad, 0x6b, 0x1b, 0x53, 0x93, 0xdb, 0x10,
0x7a, 0xed, 0xfe, 0xd0, 0xee, 0xa4, 0x54, 0xa6, 0x8b, 0x5e, 0x83, 0xfc, 0xf1, 0x68, 0xe2, 0x0d,
0x1b, 0x19, 0x66, 0x74, 0x3d, 0xc9, 0xe8, 0x2e, 0x55, 0xea, 0xa4, 0x54, 0xae, 0x4d, 0x1f, 0x65,
0x5a, 0xc7, 0x76, 0x23, 0x7b, 0xfe, 0xa3, 0x76, 0xac, 0x63, 0xf6, 0x28, 0xaa, 0x8b, 0x9a, 0x00,
0x1e, 0x26, 0x9a, 0xed, 0x10, 0xd3, 0xb6, 0x1a, 0x39, 0x66, 0xf9, 0x74, 0x92, 0xe5, 0x11, 0x26,
0x07, 0x4c, 0xb1, 0x93, 0x52, 0x25, 0xcf, 0xef, 0x50, 0x1f, 0xa6, 0x65, 0x12, 0xad, 0x3f, 0xd4,
0x4d, 0xab, 0x91, 0x3f, 0xdf, 0xc7, 0x8e, 0x65, 0x92, 0x16, 0x55, 0xa4, 0x3e, 0x4c, 0xbf, 0x43,
0xa7, 0xfc, 0xc9, 0x04, 0xbb, 0x67, 0x8d, 0xc2, 0xf9, 0x53, 0xfe, 0x31, 0x55, 0xa2, 0x53, 0x66,
0xda, 0xa8, 0x0d, 0xe5, 0x1e, 0x1e, 0x98, 0x96, 0xd6, 0x1b, 0xd9, 0xfd, 0x87, 0x8d, 0x22, 0x33,
0x56, 0x92, 0x8c, 0x9b, 0x54, 0xb5, 0x49, 0x35, 0x3b, 0x29, 0x15, 0x7a, 0x41, 0x0f, 0xbd, 0x05,
0xa5, 0xfe, 0x10, 0xf7, 0x1f, 0x6a, 0xe4, 0xb4, 0x51, 0x62, 0x3e, 0xd6, 0x93, 0x7c, 0xb4, 0xa8,
0x5e, 0xf7, 0xb4, 0x93, 0x52, 0x8b, 0x7d, 0xde, 0xa4, 0xf3, 0x37, 0xf0, 0xc8, 0x3c, 0xc1, 0x2e,
0xb5, 0x97, 0xce, 0x9f, 0xff, 0x1d, 0xae, 0xc9, 0x3c, 0x48, 0x86, 0xdf, 0x41, 0x6f, 0x83, 0x84,
0x2d, 0x43, 0x4c, 0x03, 0x98, 0x8b, 0x1b, 0x89, 0x7b, 0xc5, 0x32, 0xfc, 0x49, 0x94, 0xb0, 0x68,
0xa3, 0xdb, 0x50, 0xe8, 0xdb, 0xe3, 0xb1, 0x49, 0x1a, 0x65, 0x66, 0xbd, 0x96, 0x38, 0x01, 0xa6,
0xd5, 0x49, 0xa9, 0x42, 0x1f, 0xed, 0x43, 0x75, 0x64, 0x7a, 0x44, 0xf3, 0x2c, 0xdd, 0xf1, 0x86,
0x36, 0xf1, 0x1a, 0x2b, 0xcc, 0xc3, 0xb3, 0x49, 0x1e, 0xf6, 0x4c, 0x8f, 0x1c, 0xf9, 0xca, 0x9d,
0x94, 0x5a, 0x19, 0x45, 0x05, 0xd4, 0x9f, 0x7d, 0x7c, 0x8c, 0xdd, 0xc0, 0x61, 0xa3, 0x72, 0xbe,
0xbf, 0x03, 0xaa, 0xed, 0xdb, 0x53, 0x7f, 0x76, 0x54, 0x80, 0x7e, 0x0e, 0x97, 0x46, 0xb6, 0x6e,
0x04, 0xee, 0xb4, 0xfe, 0x70, 0x62, 0x3d, 0x6c, 0x54, 0x99, 0xd3, 0x17, 0x12, 0x5f, 0xd2, 0xd6,
0x0d, 0xdf, 0x45, 0x8b, 0x1a, 0x74, 0x52, 0xea, 0xea, 0x68, 0x5a, 0x88, 0x1e, 0xc0, 0x65, 0xdd,
0x71, 0x46, 0x67, 0xd3, 0xde, 0x6b, 0xcc, 0xfb, 0xad, 0x24, 0xef, 0xdb, 0xd4, 0x66, 0xda, 0x3d,
0xd2, 0x67, 0xa4, 0xa8, 0x0b, 0x75, 0xc7, 0xc5, 0x8e, 0xee, 0x62, 0xcd, 0x71, 0x6d, 0xc7, 0xf6,
0xf4, 0x51, 0xa3, 0xce, 0x7c, 0x3f, 0x9f, 0xe4, 0xfb, 0x90, 0xeb, 0x1f, 0x0a, 0xf5, 0x4e, 0x4a,
0xad, 0x39, 0x71, 0x51, 0xb3, 0x08, 0xf9, 0x13, 0x7d, 0x34, 0xc1, 0xca, 0xf3, 0x50, 0x8e, 0x00,
0x08, 0x6a, 0x40, 0x71, 0x8c, 0x3d, 0x4f, 0x1f, 0x60, 0x86, 0x37, 0x92, 0xea, 0x77, 0x95, 0x2a,
0xac, 0x44, 0x41, 0x43, 0x19, 0x07, 0x86, 0x14, 0x0e, 0xa8, 0xe1, 0x09, 0x76, 0x3d, 0x8a, 0x01,
0xc2, 0x50, 0x74, 0xd1, 0x33, 0x50, 0x61, 0x9b, 0x52, 0xf3, 0xc7, 0x29, 0x26, 0xe5, 0xd4, 0x15,
0x26, 0xbc, 0x2f, 0x94, 0xd6, 0xa1, 0xec, 0x6c, 0x39, 0x81, 0x4a, 0x96, 0xa9, 0x80, 0xb3, 0xe5,
0x08, 0x05, 0xe5, 0x07, 0x50, 0x9f, 0xc6, 0x10, 0x54, 0x87, 0xec, 0x43, 0x7c, 0x26, 0x9e, 0x47,
0x9b, 0xe8, 0xb2, 0x98, 0x16, 0x7b, 0x86, 0xa4, 0x8a, 0x39, 0xfe, 0x29, 0x13, 0x18, 0x07, 0xe0,
0x81, 0x6e, 0x43, 0x8e, 0x62, 0xb1, 0x80, 0x55, 0x79, 0x83, 0x03, 0xf5, 0x86, 0x0f, 0xd4, 0x1b,
0x5d, 0x1f, 0xa8, 0x9b, 0xa5, 0x2f, 0xbf, 0x5e, 0x4f, 0x7d, 0xfe, 0xd7, 0xf5, 0xb4, 0xca, 0x2c,
0xd0, 0x93, 0xf4, 0xac, 0xeb, 0xa6, 0xa5, 0x99, 0x86, 0x78, 0x4e, 0x91, 0xf5, 0x77, 0x0c, 0xb4,
0x0b, 0xf5, 0xbe, 0x6d, 0x79, 0xd8, 0xf2, 0x26, 0x9e, 0xc6, 0x03, 0x81, 0x00, 0xd3, 0xd9, 0xb3,
0xd8, 0xf2, 0x15, 0x0f, 0x99, 0x9e, 0x5a, 0xeb, 0xc7, 0x05, 0xe8, 0x2e, 0xc0, 0x89, 0x3e, 0x32,
0x0d, 0x9d, 0xd8, 0xae, 0xd7, 0xc8, 0xdd, 0xc8, 0xce, 0x75, 0x73, 0xdf, 0x57, 0xb9, 0xe7, 0x18,
0x3a, 0xc1, 0xcd, 0x1c, 0x7d, 0x5b, 0x35, 0x62, 0x89, 0x9e, 0x83, 0x9a, 0xee, 0x38, 0x9a, 0x47,
0x74, 0x82, 0xb5, 0xde, 0x19, 0xc1, 0x1e, 0x83, 0xd8, 0x15, 0xb5, 0xa2, 0x3b, 0xce, 0x11, 0x95,
0x36, 0xa9, 0x10, 0x3d, 0x0b, 0x55, 0x0a, 0xa7, 0xa6, 0x3e, 0xd2, 0x86, 0xd8, 0x1c, 0x0c, 0x09,
0x83, 0xd2, 0xac, 0x5a, 0x11, 0xd2, 0x0e, 0x13, 0x2a, 0x46, 0xb0, 0x11, 0x18, 0x94, 0x22, 0x04,
0x39, 0x43, 0x27, 0x3a, 0x5b, 0xc8, 0x15, 0x95, 0xb5, 0xa9, 0xcc, 0xd1, 0xc9, 0x50, 0x2c, 0x0f,
0x6b, 0xa3, 0x2b, 0x50, 0x10, 0x6e, 0xb3, 0xcc, 0xad, 0xe8, 0xd1, 0x6f, 0xe6, 0xb8, 0xf6, 0x09,
0x66, 0xb1, 0xa3, 0xa4, 0xf2, 0x8e, 0xf2, 0xab, 0x0c, 0xac, 0xce, 0x80, 0x2e, 0xf5, 0x3b, 0xd4,
0xbd, 0xa1, 0xff, 0x2c, 0xda, 0x46, 0xaf, 0x53, 0xbf, 0xba, 0x81, 0x5d, 0x11, 0xec, 0x1a, 0xd1,
0x25, 0xe2, 0x81, 0xbc, 0xc3, 0xc6, 0xc5, 0xd2, 0x08, 0x6d, 0x74, 0x00, 0xf5, 0x91, 0xee, 0x11,
0x8d, 0x83, 0x98, 0x16, 0x09, 0x7c, 0xb3, 0xd0, 0xbd, 0xa7, 0xfb, 0xb0, 0x47, 0x37, 0xbb, 0x70,
0x54, 0x1d, 0xc5, 0xa4, 0x48, 0x85, 0xcb, 0xbd, 0xb3, 0x47, 0xba, 0x45, 0x4c, 0x0b, 0x6b, 0x33,
0x5f, 0xee, 0xc9, 0x19, 0xa7, 0xed, 0x13, 0xd3, 0xc0, 0x56, 0xdf, 0xff, 0x64, 0x97, 0x02, 0xe3,
0xe0, 0x93, 0x7a, 0x8a, 0x0a, 0xd5, 0x78, 0xd8, 0x40, 0x55, 0xc8, 0x90, 0x53, 0xb1, 0x00, 0x19,
0x72, 0x8a, 0xbe, 0x07, 0x39, 0x3a, 0x49, 0x36, 0xf9, 0xea, 0x9c, 0x98, 0x2d, 0xec, 0xba, 0x67,
0x0e, 0x56, 0x99, 0xa6, 0xa2, 0x04, 0xa7, 0x21, 0x08, 0x25, 0xd3, 0x5e, 0x95, 0x17, 0xa0, 0x36,
0x15, 0x2b, 0x22, 0xdf, 0x2f, 0x1d, 0xfd, 0x7e, 0x4a, 0x0d, 0x2a, 0xb1, 0xc0, 0xa0, 0x5c, 0x81,
0xcb, 0xf3, 0x70, 0x5e, 0x19, 0x06, 0xf2, 0x18, 0x5e, 0xa3, 0xd7, 0xa0, 0x14, 0x00, 0x3d, 0x3f,
0x8d, 0xb3, 0x6b, 0xe5, 0x2b, 0xab, 0x81, 0x2a, 0x3d, 0x86, 0x74, 0x5b, 0xb3, 0xfd, 0x90, 0x61,
0x2f, 0x5e, 0xd4, 0x1d, 0xa7, 0xa3, 0x7b, 0x43, 0xe5, 0x23, 0x68, 0x24, 0x81, 0xf8, 0xd4, 0x34,
0x72, 0xc1, 0x36, 0xbc, 0x02, 0x85, 0x63, 0xdb, 0x1d, 0xeb, 0x84, 0x39, 0xab, 0xa8, 0xa2, 0x47,
0xb7, 0x27, 0x07, 0xf4, 0x2c, 0x13, 0xf3, 0x8e, 0xa2, 0xc1, 0x93, 0x89, 0x40, 0x4e, 0x4d, 0x4c,
0xcb, 0xc0, 0x7c, 0x3d, 0x2b, 0x2a, 0xef, 0x84, 0x8e, 0xf8, 0xcb, 0xf2, 0x0e, 0x7d, 0xac, 0xc7,
0xe6, 0xca, 0xfc, 0x4b, 0xaa, 0xe8, 0x29, 0x1a, 0x5c, 0x99, 0x8f, 0xe6, 0xe8, 0x3a, 0x00, 0xc7,
0x53, 0x71, 0xea, 0xb2, 0x37, 0x57, 0x54, 0x89, 0x49, 0xee, 0xd0, 0xa3, 0xf7, 0x1c, 0xd4, 0xc2,
0x61, 0xcd, 0x33, 0x1f, 0xf1, 0xad, 0x91, 0x55, 0x2b, 0x81, 0xce, 0x91, 0xf9, 0x08, 0x2b, 0xbf,
0x97, 0xa0, 0xa4, 0x62, 0xcf, 0xa1, 0xa0, 0x83, 0x9a, 0x20, 0xe1, 0xd3, 0x3e, 0xe6, 0x1c, 0x2e,
0x9d, 0xc8, 0x81, 0xb8, 0x76, 0xdb, 0xd7, 0xa4, 0x04, 0x24, 0x30, 0x43, 0xaf, 0x0a, 0x9e, 0x9a,
0x4c, 0x39, 0x85, 0x79, 0x94, 0xa8, 0xbe, 0xee, 0x13, 0xd5, 0x6c, 0x22, 0xe7, 0xe0, 0x56, 0x53,
0x4c, 0xf5, 0x55, 0xc1, 0x54, 0x73, 0x0b, 0x1e, 0x16, 0xa3, 0xaa, 0xad, 0x18, 0x55, 0xcd, 0x2f,
0x98, 0x66, 0x02, 0x57, 0x6d, 0xc5, 0xb8, 0x6a, 0x61, 0x81, 0x93, 0x04, 0xb2, 0xfa, 0xba, 0x4f,
0x56, 0x8b, 0x0b, 0xa6, 0x3d, 0xc5, 0x56, 0xef, 0xc6, 0xd9, 0x2a, 0x67, 0x9a, 0xcf, 0x24, 0x5a,
0x27, 0xd2, 0xd5, 0x1f, 0x46, 0xe8, 0xaa, 0x94, 0xc8, 0x15, 0xb9, 0x93, 0x39, 0x7c, 0xb5, 0x15,
0xe3, 0xab, 0xb0, 0x60, 0x0d, 0x12, 0x08, 0xeb, 0x3b, 0x51, 0xc2, 0x5a, 0x4e, 0xe4, 0xbc, 0x62,
0xd3, 0xcc, 0x63, 0xac, 0x6f, 0x04, 0x8c, 0x75, 0x25, 0x91, 0x72, 0x8b, 0x39, 0x4c, 0x53, 0xd6,
0x83, 0x19, 0xca, 0xca, 0x29, 0xe6, 0x73, 0x89, 0x2e, 0x16, 0x70, 0xd6, 0x83, 0x19, 0xce, 0x5a,
0x5d, 0xe0, 0x70, 0x01, 0x69, 0xfd, 0xc5, 0x7c, 0xd2, 0x9a, 0x4c, 0x2b, 0xc5, 0x6b, 0x2e, 0xc7,
0x5a, 0xb5, 0x04, 0xd6, 0xca, 0x99, 0xe5, 0x8b, 0x89, 0xee, 0x97, 0xa6, 0xad, 0xf7, 0xe6, 0xd0,
0xd6, 0x55, 0xe6, 0xfc, 0x66, 0xa2, 0xf3, 0x8b, 0xf0, 0xd6, 0x17, 0x28, 0x3d, 0x98, 0xc2, 0x23,
0x0a, 0xb1, 0xd8, 0x75, 0x6d, 0x57, 0x50, 0x42, 0xde, 0x51, 0x6e, 0x52, 0xc2, 0x12, 0x62, 0xcf,
0x39, 0x1c, 0x97, 0x85, 0xb2, 0x08, 0xde, 0x28, 0xbf, 0x4b, 0x87, 0xb6, 0x2c, 0xc6, 0x47, 0xc9,
0x8e, 0x24, 0xc8, 0x4e, 0x84, 0xfa, 0x66, 0xe2, 0xd4, 0x77, 0x1d, 0xca, 0x34, 0x44, 0x4d, 0xb1,
0x5a, 0xdd, 0xf1, 0x59, 0x2d, 0xba, 0x05, 0xab, 0x8c, 0x83, 0x70, 0xc4, 0x16, 0x71, 0x29, 0xc7,
0xe0, 0xba, 0x46, 0x07, 0xf8, 0x9e, 0xe7, 0x01, 0xea, 0x65, 0xb8, 0x14, 0xd1, 0x0d, 0x42, 0x1f,
0xa7, 0x72, 0xf5, 0x40, 0x7b, 0x5b, 0xc4, 0xc0, 0xf7, 0xc3, 0x05, 0x0a, 0x19, 0x33, 0x82, 0x5c,
0xdf, 0x36, 0xb0, 0x08, 0x4c, 0xac, 0x4d, 0x59, 0xf4, 0xc8, 0x1e, 0x88, 0xf0, 0x43, 0x9b, 0x54,
0x2b, 0x00, 0x57, 0x89, 0x63, 0xa7, 0xf2, 0xc7, 0x74, 0xe8, 0x2f, 0x24, 0xd1, 0xf3, 0xf8, 0x6e,
0xfa, 0x7f, 0xc3, 0x77, 0x33, 0xdf, 0x9a, 0xef, 0x46, 0x89, 0x41, 0x36, 0x4e, 0x0c, 0xfe, 0x95,
0x0e, 0xbf, 0x70, 0xc0, 0x5e, 0xbf, 0xdd, 0x8a, 0x84, 0x51, 0x3e, 0xcf, 0xbe, 0x97, 0x88, 0xf2,
0x22, 0x27, 0x29, 0xb0, 0xe7, 0xc6, 0x73, 0x92, 0x22, 0x8f, 0xfb, 0xac, 0x83, 0x6e, 0x83, 0xc4,
0x4a, 0x50, 0x9a, 0xed, 0x78, 0x02, 0xc7, 0x9f, 0x8a, 0xce, 0x95, 0x57, 0x9a, 0x36, 0x0e, 0xa9,
0xce, 0x81, 0xe3, 0xa9, 0x25, 0x47, 0xb4, 0x22, 0x04, 0x46, 0x8a, 0xf1, 0xe8, 0x6b, 0x20, 0xd1,
0xb7, 0xf7, 0x1c, 0xbd, 0x8f, 0x19, 0x26, 0x4b, 0x6a, 0x28, 0x50, 0x1e, 0x00, 0x9a, 0x8d, 0x0a,
0xa8, 0x03, 0x05, 0x7c, 0x82, 0x2d, 0xe2, 0x31, 0x1e, 0x51, 0xde, 0xba, 0x32, 0x87, 0xa4, 0x62,
0x8b, 0x34, 0x1b, 0x74, 0x91, 0xff, 0xf9, 0xf5, 0x7a, 0x9d, 0x6b, 0xbf, 0x64, 0x8f, 0x4d, 0x82,
0xc7, 0x0e, 0x39, 0x53, 0x85, 0xbd, 0xf2, 0x97, 0x0c, 0x65, 0x8c, 0xb1, 0x88, 0x31, 0x77, 0x6d,
0xfd, 0x03, 0x94, 0x89, 0x64, 0x0b, 0xcb, 0xad, 0xf7, 0x1a, 0xc0, 0x40, 0xf7, 0xb4, 0x4f, 0x75,
0x8b, 0x60, 0x43, 0x2c, 0x7a, 0x44, 0x82, 0x64, 0x28, 0xd1, 0xde, 0xc4, 0xc3, 0x86, 0x48, 0x5c,
0x82, 0x7e, 0x64, 0x9e, 0xc5, 0xef, 0x36, 0xcf, 0xf8, 0x2a, 0x97, 0xa6, 0x56, 0x39, 0xc2, 0xe6,
0xa4, 0x28, 0x9b, 0xa3, 0xef, 0xe6, 0xb8, 0xa6, 0xed, 0x9a, 0xe4, 0x8c, 0x7d, 0x9a, 0xac, 0x1a,
0xf4, 0x69, 0x7e, 0x3c, 0xc6, 0x63, 0xc7, 0xb6, 0x47, 0x1a, 0x07, 0xaf, 0x32, 0x33, 0x5d, 0x11,
0xc2, 0x36, 0xc3, 0xb0, 0x5f, 0x67, 0xc2, 0xe3, 0x17, 0xb2, 0xf6, 0xff, 0xbb, 0x05, 0x56, 0x7e,
0xc3, 0x52, 0xf9, 0x38, 0x27, 0x40, 0x47, 0xb0, 0x1a, 0x1c, 0x7f, 0x6d, 0xc2, 0x60, 0xc1, 0xdf,
0xd0, 0xcb, 0xe2, 0x47, 0xfd, 0x24, 0x2e, 0xf6, 0xd0, 0x4f, 0xe0, 0xea, 0x14, 0xb4, 0x05, 0xae,
0x33, 0x4b, 0x22, 0xdc, 0x13, 0x71, 0x84, 0xf3, 0x3d, 0x87, 0x6b, 0x95, 0xfd, 0x8e, 0x87, 0x6e,
0x87, 0x66, 0x87, 0x51, 0x86, 0x33, 0xf7, 0xeb, 0x3f, 0x03, 0x15, 0x17, 0x13, 0xdd, 0xb4, 0xb4,
0x58, 0xfe, 0xbd, 0xc2, 0x85, 0x22, 0xab, 0x3f, 0x84, 0x27, 0xe6, 0x32, 0x1d, 0xf4, 0x7d, 0x90,
0x42, 0x92, 0x94, 0x4e, 0x48, 0x65, 0x83, 0xf4, 0x2c, 0xd4, 0x55, 0xfe, 0x90, 0x0e, 0x5d, 0xc6,
0x13, 0xbe, 0x36, 0x14, 0x5c, 0xec, 0x4d, 0x46, 0x3c, 0x05, 0xab, 0x6e, 0xbd, 0xbc, 0x1c, 0x47,
0xa2, 0xd2, 0xc9, 0x88, 0xa8, 0xc2, 0x58, 0x79, 0x00, 0x05, 0x2e, 0x41, 0x65, 0x28, 0xde, 0xdb,
0xdf, 0xdd, 0x3f, 0xf8, 0x60, 0xbf, 0x9e, 0x42, 0x00, 0x85, 0xed, 0x56, 0xab, 0x7d, 0xd8, 0xad,
0xa7, 0x91, 0x04, 0xf9, 0xed, 0xe6, 0x81, 0xda, 0xad, 0x67, 0xa8, 0x58, 0x6d, 0xbf, 0xd7, 0x6e,
0x75, 0xeb, 0x59, 0xb4, 0x0a, 0x15, 0xde, 0xd6, 0xee, 0x1e, 0xa8, 0xef, 0x6f, 0x77, 0xeb, 0xb9,
0x88, 0xe8, 0xa8, 0xbd, 0x7f, 0xa7, 0xad, 0xd6, 0xf3, 0xca, 0x2b, 0x34, 0xc7, 0x4b, 0x60, 0x55,
0x61, 0x36, 0x97, 0x8e, 0x64, 0x73, 0xca, 0x6f, 0x33, 0x20, 0x27, 0x53, 0x25, 0xf4, 0xde, 0xd4,
0xc4, 0xb7, 0x2e, 0xc0, 0xb3, 0xa6, 0x66, 0x8f, 0x9e, 0x85, 0xaa, 0x8b, 0x8f, 0x31, 0xe9, 0x0f,
0x39, 0x75, 0xe3, 0x11, 0xb3, 0xa2, 0x56, 0x84, 0x94, 0x19, 0x79, 0x5c, 0xed, 0x63, 0xdc, 0x27,
0x1a, 0x87, 0x22, 0xbe, 0xe9, 0x24, 0xaa, 0x46, 0xa5, 0x47, 0x5c, 0xa8, 0x7c, 0x74, 0xa1, 0xb5,
0x94, 0x20, 0xaf, 0xb6, 0xbb, 0xea, 0x4f, 0xeb, 0x59, 0x84, 0xa0, 0xca, 0x9a, 0xda, 0xd1, 0xfe,
0xf6, 0xe1, 0x51, 0xe7, 0x80, 0xae, 0xe5, 0x25, 0xa8, 0xf9, 0x6b, 0xe9, 0x0b, 0xf3, 0xca, 0x6d,
0xb8, 0x9a, 0xc0, 0xf3, 0x16, 0x64, 0xb4, 0xca, 0x7f, 0xd2, 0x50, 0x9b, 0x3a, 0x5a, 0x68, 0x0b,
0xf2, 0x3c, 0x71, 0x48, 0xba, 0x15, 0x61, 0xc8, 0x20, 0xce, 0x21, 0x57, 0x45, 0x6f, 0x41, 0x09,
0x8b, 0x92, 0xcb, 0xbc, 0x23, 0xcc, 0x4b, 0x45, 0x7e, 0x51, 0x46, 0x98, 0x06, 0x16, 0xe8, 0x6d,
0x90, 0x02, 0x8c, 0x10, 0xd9, 0xea, 0xd3, 0xb3, 0xe6, 0x01, 0xba, 0x08, 0xfb, 0xd0, 0x06, 0xbd,
0x11, 0xd2, 0xc4, 0xdc, 0x6c, 0xba, 0x22, 0xcc, 0xb9, 0x82, 0x30, 0xf6, 0xf5, 0x95, 0x16, 0x94,
0x23, 0xf3, 0x41, 0x4f, 0x81, 0x34, 0xd6, 0x4f, 0x45, 0x29, 0x8f, 0x17, 0x63, 0x4a, 0x63, 0xfd,
0x94, 0x57, 0xf1, 0xae, 0x42, 0x91, 0x0e, 0x0e, 0x74, 0x4f, 0xe4, 0xfd, 0x85, 0xb1, 0x7e, 0xfa,
0xae, 0xee, 0x29, 0x1f, 0x42, 0x35, 0x5e, 0xc6, 0xa2, 0x7b, 0xd8, 0xb5, 0x27, 0x96, 0xc1, 0x7c,
0xe4, 0x55, 0xde, 0x41, 0xaf, 0x41, 0xfe, 0xc4, 0xe6, 0x30, 0x37, 0xff, 0xb0, 0xdf, 0xb7, 0x09,
0x8e, 0x94, 0xc1, 0xb8, 0xb6, 0xf2, 0x08, 0xf2, 0x0c, 0xb6, 0x28, 0x04, 0xb1, 0x82, 0x94, 0xa0,
0xc8, 0xb4, 0x8d, 0x3e, 0x04, 0xd0, 0x09, 0x71, 0xcd, 0xde, 0x24, 0x74, 0xbc, 0x3e, 0x1f, 0xf6,
0xb6, 0x7d, 0xbd, 0xe6, 0x35, 0x81, 0x7f, 0x97, 0x43, 0xd3, 0x08, 0x06, 0x46, 0x1c, 0x2a, 0xfb,
0x50, 0x8d, 0xdb, 0x46, 0x4b, 0xc3, 0x2b, 0x73, 0x4a, 0xc3, 0x01, 0x0d, 0x0b, 0x48, 0x5c, 0x96,
0x17, 0x1f, 0x59, 0x47, 0xf9, 0x2c, 0x0d, 0xa5, 0xee, 0xa9, 0x38, 0x10, 0x09, 0x75, 0xaf, 0xd0,
0x34, 0x13, 0xad, 0xf2, 0xf0, 0x42, 0x5a, 0x36, 0x28, 0xcf, 0xbd, 0x13, 0x1c, 0xf9, 0xdc, 0xb2,
0x69, 0xb2, 0x5f, 0xa7, 0x14, 0x30, 0xf7, 0x26, 0x48, 0xc1, 0xae, 0xa2, 0xb9, 0x86, 0x6e, 0x18,
0x2e, 0xf6, 0x3c, 0x31, 0x37, 0xbf, 0xcb, 0xca, 0xa8, 0xf6, 0xa7, 0xa2, 0x8e, 0x94, 0x55, 0x79,
0x47, 0x31, 0xa0, 0x36, 0x15, 0xf0, 0xd0, 0x9b, 0x50, 0x74, 0x26, 0x3d, 0xcd, 0x5f, 0x9e, 0xa9,
0xc3, 0xe3, 0xf3, 0xce, 0x49, 0x6f, 0x64, 0xf6, 0x77, 0xf1, 0x99, 0xff, 0x32, 0xce, 0xa4, 0xb7,
0xcb, 0x57, 0x91, 0x3f, 0x25, 0x13, 0x7d, 0xca, 0x09, 0x94, 0xfc, 0x4d, 0x81, 0x7e, 0x14, 0x3d,
0x27, 0x7e, 0x71, 0x3d, 0x31, 0x08, 0x0b, 0xf7, 0x91, 0x63, 0x72, 0x0b, 0x56, 0x3d, 0x73, 0x60,
0x61, 0x43, 0x0b, 0xb3, 0x1d, 0xf6, 0xb4, 0x92, 0x5a, 0xe3, 0x03, 0x7b, 0x7e, 0xaa, 0xa3, 0xfc,
0x3b, 0x0d, 0x25, 0xff, 0xc0, 0xa2, 0x57, 0x22, 0xfb, 0xae, 0x3a, 0xa7, 0x24, 0xe4, 0x2b, 0x86,
0x95, 0xd0, 0xf8, 0xbb, 0x66, 0x2e, 0xfe, 0xae, 0x49, 0x25, 0x6d, 0xff, 0x6e, 0x21, 0x77, 0xe1,
0xbb, 0x85, 0x97, 0x00, 0x11, 0x9b, 0xe8, 0x23, 0xed, 0xc4, 0x26, 0xa6, 0x35, 0xd0, 0xf8, 0x62,
0x73, 0x2e, 0x56, 0x67, 0x23, 0xf7, 0xd9, 0xc0, 0x21, 0x5b, 0xf7, 0x5f, 0xa6, 0xa1, 0x14, 0x44,
0xd5, 0x8b, 0x16, 0x36, 0xaf, 0x40, 0x41, 0x04, 0x0e, 0x5e, 0xd9, 0x14, 0xbd, 0xa0, 0xc6, 0x9e,
0x8b, 0xd4, 0xd8, 0x65, 0x28, 0x8d, 0x31, 0xd1, 0x19, 0x3e, 0xf3, 0x84, 0x33, 0xe8, 0xdf, 0x7a,
0x03, 0xca, 0x91, 0x1a, 0x33, 0x3d, 0x79, 0xfb, 0xed, 0x0f, 0xea, 0x29, 0xb9, 0xf8, 0xd9, 0x17,
0x37, 0xb2, 0xfb, 0xf8, 0x53, 0xba, 0x67, 0xd5, 0x76, 0xab, 0xd3, 0x6e, 0xed, 0xd6, 0xd3, 0x72,
0xf9, 0xb3, 0x2f, 0x6e, 0x14, 0x55, 0xcc, 0x2a, 0x49, 0xb7, 0x3a, 0xb0, 0x12, 0xfd, 0x2a, 0xf1,
0xd8, 0x83, 0xa0, 0x7a, 0xe7, 0xde, 0xe1, 0xde, 0x4e, 0x6b, 0xbb, 0xdb, 0xd6, 0xee, 0x1f, 0x74,
0xdb, 0xf5, 0x34, 0xba, 0x0a, 0x97, 0xf6, 0x76, 0xde, 0xed, 0x74, 0xb5, 0xd6, 0xde, 0x4e, 0x7b,
0xbf, 0xab, 0x6d, 0x77, 0xbb, 0xdb, 0xad, 0xdd, 0x7a, 0x66, 0xeb, 0x1f, 0x00, 0xb5, 0xed, 0x66,
0x6b, 0x87, 0xc6, 0x4d, 0xb3, 0xaf, 0x8b, 0x4a, 0x5d, 0x8e, 0xe5, 0xfb, 0xe7, 0x5e, 0x99, 0xcb,
0xe7, 0x17, 0x2a, 0xd1, 0x5d, 0xc8, 0xb3, 0x52, 0x00, 0x3a, 0xff, 0x0e, 0x5d, 0x5e, 0x50, 0xb9,
0xa4, 0x2f, 0xc3, 0x8e, 0xc7, 0xb9, 0x97, 0xea, 0xf2, 0xf9, 0x85, 0x4c, 0xa4, 0x82, 0x14, 0xe6,
0xf2, 0x8b, 0x2f, 0xd9, 0xe5, 0x25, 0x8a, 0x9b, 0xd4, 0x67, 0x98, 0x50, 0x2c, 0xbe, 0x74, 0x96,
0x97, 0x00, 0x30, 0xb4, 0x07, 0x45, 0x3f, 0x07, 0x5c, 0x74, 0x0d, 0x2e, 0x2f, 0x2c, 0x3c, 0xd2,
0x4f, 0xc0, 0x73, 0xf5, 0xf3, 0xef, 0xf4, 0xe5, 0x05, 0x55, 0x54, 0xb4, 0x03, 0x05, 0xc1, 0x92,
0x17, 0x5c, 0x6d, 0xcb, 0x8b, 0x0a, 0x89, 0x74, 0xd1, 0xc2, 0x22, 0xc8, 0xe2, 0x3f, 0x15, 0xe4,
0x25, 0x0a, 0xc4, 0xe8, 0x1e, 0x40, 0x24, 0x33, 0x5f, 0xe2, 0x17, 0x04, 0x79, 0x99, 0xc2, 0x2f,
0x3a, 0x80, 0x52, 0x90, 0x28, 0x2d, 0xfc, 0x21, 0x40, 0x5e, 0x5c, 0x81, 0x45, 0x0f, 0xa0, 0x12,
0xcf, 0x10, 0x96, 0xbb, 0xe6, 0x97, 0x97, 0x2c, 0xad, 0x52, 0xff, 0xf1, 0x74, 0x61, 0xb9, 0x6b,
0x7f, 0x79, 0xc9, 0x4a, 0x2b, 0xfa, 0x18, 0x56, 0x67, 0xe9, 0xfc, 0xf2, 0x7f, 0x01, 0xc8, 0x17,
0xa8, 0xbd, 0xa2, 0x31, 0xa0, 0x39, 0x69, 0xc0, 0x05, 0x7e, 0x0a, 0x90, 0x2f, 0x52, 0x8a, 0x45,
0x06, 0xd4, 0xa6, 0xb9, 0xf5, 0xb2, 0x3f, 0x09, 0xc8, 0x4b, 0x97, 0x65, 0x9b, 0xed, 0x2f, 0xbf,
0x59, 0x4b, 0x7f, 0xf5, 0xcd, 0x5a, 0xfa, 0x6f, 0xdf, 0xac, 0xa5, 0x3f, 0x7f, 0xbc, 0x96, 0xfa,
0xea, 0xf1, 0x5a, 0xea, 0xcf, 0x8f, 0xd7, 0x52, 0x3f, 0x7b, 0x71, 0x60, 0x92, 0xe1, 0xa4, 0xb7,
0xd1, 0xb7, 0xc7, 0x9b, 0xd1, 0xff, 0xa2, 0xe6, 0xfd, 0xab, 0xd5, 0x2b, 0xb0, 0x70, 0xf8, 0xea,
0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x5c, 0x29, 0x35, 0x72, 0xcb, 0x25, 0x00, 0x00,
// 2917 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x93, 0x23, 0xc5,
0xb5, 0xd6, 0x5b, 0xaa, 0xd3, 0xad, 0x47, 0xe7, 0x0c, 0x33, 0x42, 0xcc, 0x74, 0x0f, 0x45, 0x00,
0xc3, 0x00, 0xdd, 0x97, 0x26, 0xe0, 0x0e, 0x17, 0xee, 0x85, 0x96, 0x46, 0x83, 0x9a, 0x69, 0xba,
0xfb, 0x66, 0x6b, 0x06, 0xbf, 0x98, 0xa2, 0xa4, 0xca, 0x96, 0x8a, 0x91, 0xaa, 0x8a, 0xaa, 0x54,
0xd3, 0x3d, 0x4b, 0x87, 0xbd, 0xc1, 0xe1, 0x08, 0x96, 0xde, 0xf0, 0x3f, 0xbc, 0x70, 0x78, 0xe3,
0x0d, 0x11, 0xde, 0xb0, 0xf4, 0xc2, 0x81, 0x1d, 0xb0, 0x70, 0xd8, 0x7f, 0xc0, 0x2b, 0x87, 0x1d,
0xf9, 0xa8, 0x97, 0xa4, 0x6a, 0xa9, 0xc1, 0x3b, 0xef, 0x32, 0x4f, 0x9e, 0x73, 0xb2, 0x32, 0x2b,
0xf3, 0x3b, 0xdf, 0x39, 0x55, 0xf0, 0x14, 0x25, 0x96, 0x41, 0xdc, 0xb1, 0x69, 0xd1, 0x2d, 0xbd,
0xd7, 0x37, 0xb7, 0xe8, 0x99, 0x43, 0xbc, 0x4d, 0xc7, 0xb5, 0xa9, 0x8d, 0xaa, 0xe1, 0xe0, 0x26,
0x1b, 0x6c, 0x5c, 0x8f, 0x68, 0xf7, 0xdd, 0x33, 0x87, 0xda, 0x5b, 0x8e, 0x6b, 0xdb, 0xc7, 0x42,
0xbf, 0x71, 0x2d, 0x32, 0xcc, 0xfd, 0x44, 0xbd, 0xc5, 0x46, 0xa5, 0xf1, 0x23, 0x72, 0xe6, 0x8f,
0x5e, 0x9f, 0xb1, 0x75, 0x74, 0x57, 0x1f, 0xfb, 0xc3, 0x1b, 0x03, 0xdb, 0x1e, 0x8c, 0xc8, 0x16,
0xef, 0xf5, 0x26, 0xc7, 0x5b, 0xd4, 0x1c, 0x13, 0x8f, 0xea, 0x63, 0x47, 0x2a, 0x5c, 0x1e, 0xd8,
0x03, 0x9b, 0x37, 0xb7, 0x58, 0x4b, 0x48, 0xd5, 0xbf, 0x94, 0xa0, 0x88, 0xc9, 0x27, 0x13, 0xe2,
0x51, 0xb4, 0x0d, 0x39, 0xd2, 0x1f, 0xda, 0xf5, 0xf4, 0x8d, 0xf4, 0xcd, 0x95, 0xed, 0x6b, 0x9b,
0x53, 0x8b, 0xdb, 0x94, 0x7a, 0xed, 0xfe, 0xd0, 0xee, 0xa4, 0x30, 0xd7, 0x45, 0xaf, 0x41, 0xfe,
0x78, 0x34, 0xf1, 0x86, 0xf5, 0x0c, 0x37, 0xba, 0x9e, 0x64, 0x74, 0x97, 0x29, 0x75, 0x52, 0x58,
0x68, 0xb3, 0xa9, 0x4c, 0xeb, 0xd8, 0xae, 0x67, 0xcf, 0x9f, 0x6a, 0xd7, 0x3a, 0xe6, 0x53, 0x31,
0x5d, 0xd4, 0x04, 0xf0, 0x08, 0xd5, 0x6c, 0x87, 0x9a, 0xb6, 0x55, 0xcf, 0x71, 0xcb, 0xa7, 0x93,
0x2c, 0x8f, 0x08, 0x3d, 0xe0, 0x8a, 0x9d, 0x14, 0x56, 0x3c, 0xbf, 0xc3, 0x7c, 0x98, 0x96, 0x49,
0xb5, 0xfe, 0x50, 0x37, 0xad, 0x7a, 0xfe, 0x7c, 0x1f, 0xbb, 0x96, 0x49, 0x5b, 0x4c, 0x91, 0xf9,
0x30, 0xfd, 0x0e, 0x5b, 0xf2, 0x27, 0x13, 0xe2, 0x9e, 0xd5, 0x0b, 0xe7, 0x2f, 0xf9, 0xff, 0x99,
0x12, 0x5b, 0x32, 0xd7, 0x46, 0x6d, 0x58, 0xe9, 0x91, 0x81, 0x69, 0x69, 0xbd, 0x91, 0xdd, 0x7f,
0x54, 0x2f, 0x72, 0x63, 0x35, 0xc9, 0xb8, 0xc9, 0x54, 0x9b, 0x4c, 0xb3, 0x93, 0xc2, 0xd0, 0x0b,
0x7a, 0xe8, 0x2d, 0x28, 0xf5, 0x87, 0xa4, 0xff, 0x48, 0xa3, 0xa7, 0xf5, 0x12, 0xf7, 0xb1, 0x91,
0xe4, 0xa3, 0xc5, 0xf4, 0xba, 0xa7, 0x9d, 0x14, 0x2e, 0xf6, 0x45, 0x93, 0xad, 0xdf, 0x20, 0x23,
0xf3, 0x84, 0xb8, 0xcc, 0x5e, 0x39, 0x7f, 0xfd, 0x77, 0x84, 0x26, 0xf7, 0xa0, 0x18, 0x7e, 0x07,
0xbd, 0x0d, 0x0a, 0xb1, 0x0c, 0xb9, 0x0c, 0xe0, 0x2e, 0x6e, 0x24, 0x9e, 0x15, 0xcb, 0xf0, 0x17,
0x51, 0x22, 0xb2, 0x8d, 0x6e, 0x43, 0xa1, 0x6f, 0x8f, 0xc7, 0x26, 0xad, 0xaf, 0x70, 0xeb, 0xf5,
0xc4, 0x05, 0x70, 0xad, 0x4e, 0x0a, 0x4b, 0x7d, 0xb4, 0x0f, 0x95, 0x91, 0xe9, 0x51, 0xcd, 0xb3,
0x74, 0xc7, 0x1b, 0xda, 0xd4, 0xab, 0xaf, 0x72, 0x0f, 0xcf, 0x26, 0x79, 0xd8, 0x33, 0x3d, 0x7a,
0xe4, 0x2b, 0x77, 0x52, 0xb8, 0x3c, 0x8a, 0x0a, 0x98, 0x3f, 0xfb, 0xf8, 0x98, 0xb8, 0x81, 0xc3,
0x7a, 0xf9, 0x7c, 0x7f, 0x07, 0x4c, 0xdb, 0xb7, 0x67, 0xfe, 0xec, 0xa8, 0x00, 0xfd, 0x18, 0x2e,
0x8d, 0x6c, 0xdd, 0x08, 0xdc, 0x69, 0xfd, 0xe1, 0xc4, 0x7a, 0x54, 0xaf, 0x70, 0xa7, 0x2f, 0x24,
0x3e, 0xa4, 0xad, 0x1b, 0xbe, 0x8b, 0x16, 0x33, 0xe8, 0xa4, 0xf0, 0xda, 0x68, 0x5a, 0x88, 0x1e,
0xc2, 0x65, 0xdd, 0x71, 0x46, 0x67, 0xd3, 0xde, 0xab, 0xdc, 0xfb, 0xad, 0x24, 0xef, 0x3b, 0xcc,
0x66, 0xda, 0x3d, 0xd2, 0x67, 0xa4, 0xa8, 0x0b, 0x35, 0xc7, 0x25, 0x8e, 0xee, 0x12, 0xcd, 0x71,
0x6d, 0xc7, 0xf6, 0xf4, 0x51, 0xbd, 0xc6, 0x7d, 0x3f, 0x9f, 0xe4, 0xfb, 0x50, 0xe8, 0x1f, 0x4a,
0xf5, 0x4e, 0x0a, 0x57, 0x9d, 0xb8, 0xa8, 0x59, 0x84, 0xfc, 0x89, 0x3e, 0x9a, 0x10, 0xf5, 0x79,
0x58, 0x89, 0x00, 0x08, 0xaa, 0x43, 0x71, 0x4c, 0x3c, 0x4f, 0x1f, 0x10, 0x8e, 0x37, 0x0a, 0xf6,
0xbb, 0x6a, 0x05, 0x56, 0xa3, 0xa0, 0xa1, 0x8e, 0x03, 0x43, 0x06, 0x07, 0xcc, 0xf0, 0x84, 0xb8,
0x1e, 0xc3, 0x00, 0x69, 0x28, 0xbb, 0xe8, 0x19, 0x28, 0xf3, 0x43, 0xa9, 0xf9, 0xe3, 0x0c, 0x93,
0x72, 0x78, 0x95, 0x0b, 0x1f, 0x48, 0xa5, 0x0d, 0x58, 0x71, 0xb6, 0x9d, 0x40, 0x25, 0xcb, 0x55,
0xc0, 0xd9, 0x76, 0xa4, 0x82, 0xfa, 0x3f, 0x50, 0x9b, 0xc6, 0x10, 0x54, 0x83, 0xec, 0x23, 0x72,
0x26, 0xe7, 0x63, 0x4d, 0x74, 0x59, 0x2e, 0x8b, 0xcf, 0xa1, 0x60, 0xb9, 0xc6, 0xdf, 0x67, 0x02,
0xe3, 0x00, 0x3c, 0xd0, 0x6d, 0xc8, 0x31, 0x2c, 0x96, 0xb0, 0xda, 0xd8, 0x14, 0x40, 0xbd, 0xe9,
0x03, 0xf5, 0x66, 0xd7, 0x07, 0xea, 0x66, 0xe9, 0xcb, 0xaf, 0x37, 0x52, 0x9f, 0xff, 0x69, 0x23,
0x8d, 0xb9, 0x05, 0x7a, 0x92, 0xdd, 0x75, 0xdd, 0xb4, 0x34, 0xd3, 0x90, 0xf3, 0x14, 0x79, 0x7f,
0xd7, 0x40, 0xf7, 0xa0, 0xd6, 0xb7, 0x2d, 0x8f, 0x58, 0xde, 0xc4, 0xd3, 0x44, 0x20, 0x90, 0x60,
0x3a, 0x7b, 0x17, 0x5b, 0xbe, 0xe2, 0x21, 0xd7, 0xc3, 0xd5, 0x7e, 0x5c, 0x80, 0xee, 0x02, 0x9c,
0xe8, 0x23, 0xd3, 0xd0, 0xa9, 0xed, 0x7a, 0xf5, 0xdc, 0x8d, 0xec, 0x5c, 0x37, 0x0f, 0x7c, 0x95,
0xfb, 0x8e, 0xa1, 0x53, 0xd2, 0xcc, 0xb1, 0xa7, 0xc5, 0x11, 0x4b, 0xf4, 0x1c, 0x54, 0x75, 0xc7,
0xd1, 0x3c, 0xaa, 0x53, 0xa2, 0xf5, 0xce, 0x28, 0xf1, 0x38, 0xc4, 0xae, 0xe2, 0xb2, 0xee, 0x38,
0x47, 0x4c, 0xda, 0x64, 0x42, 0xf4, 0x2c, 0x54, 0x18, 0x9c, 0x9a, 0xfa, 0x48, 0x1b, 0x12, 0x73,
0x30, 0xa4, 0x1c, 0x4a, 0xb3, 0xb8, 0x2c, 0xa5, 0x1d, 0x2e, 0x54, 0x8d, 0xe0, 0x20, 0x70, 0x28,
0x45, 0x08, 0x72, 0x86, 0x4e, 0x75, 0xbe, 0x91, 0xab, 0x98, 0xb7, 0x99, 0xcc, 0xd1, 0xe9, 0x50,
0x6e, 0x0f, 0x6f, 0xa3, 0x2b, 0x50, 0x90, 0x6e, 0xb3, 0xdc, 0xad, 0xec, 0xb1, 0x77, 0xe6, 0xb8,
0xf6, 0x09, 0xe1, 0xb1, 0xa3, 0x84, 0x45, 0x47, 0xfd, 0x59, 0x06, 0xd6, 0x66, 0x40, 0x97, 0xf9,
0x1d, 0xea, 0xde, 0xd0, 0x9f, 0x8b, 0xb5, 0xd1, 0xeb, 0xcc, 0xaf, 0x6e, 0x10, 0x57, 0x06, 0xbb,
0x7a, 0x74, 0x8b, 0x44, 0x20, 0xef, 0xf0, 0x71, 0xb9, 0x35, 0x52, 0x1b, 0x1d, 0x40, 0x6d, 0xa4,
0x7b, 0x54, 0x13, 0x20, 0xa6, 0x45, 0x02, 0xdf, 0x2c, 0x74, 0xef, 0xe9, 0x3e, 0xec, 0xb1, 0xc3,
0x2e, 0x1d, 0x55, 0x46, 0x31, 0x29, 0xc2, 0x70, 0xb9, 0x77, 0xf6, 0x58, 0xb7, 0xa8, 0x69, 0x11,
0x6d, 0xe6, 0xcd, 0x3d, 0x39, 0xe3, 0xb4, 0x7d, 0x62, 0x1a, 0xc4, 0xea, 0xfb, 0xaf, 0xec, 0x52,
0x60, 0x1c, 0xbc, 0x52, 0x4f, 0xc5, 0x50, 0x89, 0x87, 0x0d, 0x54, 0x81, 0x0c, 0x3d, 0x95, 0x1b,
0x90, 0xa1, 0xa7, 0xe8, 0xbf, 0x20, 0xc7, 0x16, 0xc9, 0x17, 0x5f, 0x99, 0x13, 0xb3, 0xa5, 0x5d,
0xf7, 0xcc, 0x21, 0x98, 0x6b, 0xaa, 0x6a, 0x70, 0x1b, 0x82, 0x50, 0x32, 0xed, 0x55, 0x7d, 0x01,
0xaa, 0x53, 0xb1, 0x22, 0xf2, 0xfe, 0xd2, 0xd1, 0xf7, 0xa7, 0x56, 0xa1, 0x1c, 0x0b, 0x0c, 0xea,
0x15, 0xb8, 0x3c, 0x0f, 0xe7, 0xd5, 0x61, 0x20, 0x8f, 0xe1, 0x35, 0x7a, 0x0d, 0x4a, 0x01, 0xd0,
0x8b, 0xdb, 0x38, 0xbb, 0x57, 0xbe, 0x32, 0x0e, 0x54, 0xd9, 0x35, 0x64, 0xc7, 0x9a, 0x9f, 0x87,
0x0c, 0x7f, 0xf0, 0xa2, 0xee, 0x38, 0x1d, 0xdd, 0x1b, 0xaa, 0x1f, 0x41, 0x3d, 0x09, 0xc4, 0xa7,
0x96, 0x91, 0x0b, 0x8e, 0xe1, 0x15, 0x28, 0x1c, 0xdb, 0xee, 0x58, 0xa7, 0xdc, 0x59, 0x19, 0xcb,
0x1e, 0x3b, 0x9e, 0x02, 0xd0, 0xb3, 0x5c, 0x2c, 0x3a, 0xaa, 0x06, 0x4f, 0x26, 0x02, 0x39, 0x33,
0x31, 0x2d, 0x83, 0x88, 0xfd, 0x2c, 0x63, 0xd1, 0x09, 0x1d, 0x89, 0x87, 0x15, 0x1d, 0x36, 0xad,
0xc7, 0xd7, 0xca, 0xfd, 0x2b, 0x58, 0xf6, 0xd4, 0x5f, 0xa6, 0xe1, 0xca, 0x7c, 0x38, 0x47, 0xd7,
0x01, 0x04, 0xa0, 0xca, 0x6b, 0x97, 0xbd, 0xb9, 0x8a, 0x15, 0x2e, 0xb9, 0xc3, 0xee, 0xde, 0x73,
0x50, 0x0d, 0x87, 0x35, 0xcf, 0x7c, 0x2c, 0xce, 0x46, 0x16, 0x97, 0x03, 0x9d, 0x23, 0xf3, 0x31,
0x41, 0x2f, 0x41, 0xfe, 0xc4, 0x66, 0x60, 0x90, 0xe5, 0xe7, 0xf3, 0xca, 0xec, 0xb5, 0x79, 0x60,
0x53, 0x82, 0x85, 0x92, 0xfa, 0x1b, 0x05, 0x4a, 0x98, 0x78, 0x0e, 0xc3, 0x28, 0xd4, 0x04, 0x85,
0x9c, 0xf6, 0x89, 0xa0, 0x7c, 0xe9, 0x44, 0xca, 0x24, 0xb4, 0xdb, 0xbe, 0x26, 0xe3, 0x2b, 0x81,
0x19, 0x7a, 0x55, 0xd2, 0xda, 0x64, 0x86, 0x2a, 0xcd, 0xa3, 0xbc, 0xf6, 0x75, 0x9f, 0xd7, 0x66,
0x13, 0x29, 0x8a, 0xb0, 0x9a, 0x22, 0xb6, 0xaf, 0x4a, 0x62, 0x9b, 0x5b, 0x30, 0x59, 0x8c, 0xd9,
0xb6, 0x62, 0xcc, 0x36, 0xbf, 0x60, 0x99, 0x09, 0xd4, 0xb6, 0x15, 0xa3, 0xb6, 0x85, 0x05, 0x4e,
0x12, 0xb8, 0xed, 0xeb, 0x3e, 0xb7, 0x2d, 0x2e, 0x58, 0xf6, 0x14, 0xb9, 0xbd, 0x1b, 0x27, 0xb7,
0x82, 0x98, 0x3e, 0x93, 0x68, 0x9d, 0xc8, 0x6e, 0xff, 0x37, 0xc2, 0x6e, 0x95, 0x44, 0x6a, 0x29,
0x9c, 0xcc, 0xa1, 0xb7, 0xad, 0x18, 0xbd, 0x85, 0x05, 0x7b, 0x90, 0xc0, 0x6f, 0xdf, 0x89, 0xf2,
0xdb, 0x95, 0x44, 0x8a, 0x2c, 0x0f, 0xcd, 0x3c, 0x82, 0xfb, 0x46, 0x40, 0x70, 0x57, 0x13, 0x19,
0xba, 0x5c, 0xc3, 0x34, 0xc3, 0x3d, 0x98, 0x61, 0xb8, 0x82, 0x91, 0x3e, 0x97, 0xe8, 0x62, 0x01,
0xc5, 0x3d, 0x98, 0xa1, 0xb8, 0x95, 0x05, 0x0e, 0x17, 0x70, 0xdc, 0x9f, 0xcc, 0xe7, 0xb8, 0xc9,
0x2c, 0x54, 0x3e, 0xe6, 0x72, 0x24, 0x57, 0x4b, 0x20, 0xb9, 0x82, 0x88, 0xbe, 0x98, 0xe8, 0x7e,
0x69, 0x96, 0x7b, 0x7f, 0x0e, 0xcb, 0x5d, 0xe3, 0xce, 0x6f, 0x26, 0x3a, 0xbf, 0x08, 0xcd, 0x7d,
0x81, 0xb1, 0x89, 0x29, 0x3c, 0x62, 0x88, 0x4c, 0x5c, 0xd7, 0x76, 0x25, 0x83, 0x14, 0x1d, 0xf5,
0x26, 0xe3, 0x37, 0x21, 0xf6, 0x9c, 0x43, 0x89, 0x79, 0xe4, 0x8b, 0xe0, 0x8d, 0xfa, 0xeb, 0x74,
0x68, 0xcb, 0x29, 0x41, 0x94, 0x1b, 0x29, 0x92, 0x1b, 0x45, 0x98, 0x72, 0x26, 0xce, 0x94, 0x37,
0x60, 0x85, 0x45, 0xb4, 0x29, 0x12, 0xac, 0x3b, 0x3e, 0x09, 0x46, 0xb7, 0x60, 0x8d, 0x53, 0x16,
0x81, 0xef, 0x32, 0x8c, 0xe5, 0x38, 0xb8, 0x57, 0xd9, 0x80, 0x38, 0xf3, 0x22, 0x9e, 0xbd, 0x0c,
0x97, 0x22, 0xba, 0x41, 0xa4, 0x14, 0xcc, 0xaf, 0x16, 0x68, 0xef, 0xc8, 0x90, 0xf9, 0x7e, 0xb8,
0x41, 0x21, 0xc1, 0x46, 0x90, 0xeb, 0xdb, 0x06, 0x91, 0x71, 0x8c, 0xb7, 0x19, 0xe9, 0x1e, 0xd9,
0x03, 0x19, 0xad, 0x58, 0x93, 0x69, 0x05, 0xe0, 0xaa, 0x08, 0xec, 0x54, 0x7f, 0x97, 0x0e, 0xfd,
0x85, 0x9c, 0x7b, 0x1e, 0x3d, 0x4e, 0xff, 0x7b, 0xe8, 0x71, 0xe6, 0x3b, 0xd3, 0xe3, 0x28, 0x8f,
0xc8, 0xc6, 0x79, 0xc4, 0xdf, 0xd3, 0xe1, 0x1b, 0x0e, 0xc8, 0xee, 0x77, 0xdb, 0x91, 0x90, 0x14,
0xe4, 0xf9, 0xfb, 0x92, 0xa4, 0x40, 0xa6, 0x30, 0x05, 0x3e, 0x6f, 0x3c, 0x85, 0x29, 0x0a, 0x9a,
0xc0, 0x3b, 0xe8, 0x36, 0x28, 0xbc, 0x62, 0xa5, 0xd9, 0x8e, 0x27, 0x71, 0xfc, 0xa9, 0xe8, 0x5a,
0x45, 0x61, 0x6a, 0xf3, 0x90, 0xe9, 0x1c, 0x38, 0x1e, 0x2e, 0x39, 0xb2, 0x15, 0xe1, 0x3b, 0x4a,
0x8c, 0x76, 0x5f, 0x03, 0x85, 0x3d, 0xbd, 0xe7, 0xe8, 0x7d, 0xc2, 0x31, 0x59, 0xc1, 0xa1, 0x40,
0x7d, 0x08, 0x68, 0x36, 0x2a, 0xa0, 0x0e, 0x14, 0xc8, 0x09, 0xb1, 0xa8, 0xc7, 0x59, 0xc7, 0x14,
0x67, 0x90, 0x9c, 0x96, 0x58, 0xb4, 0x59, 0x67, 0x9b, 0xfc, 0xb7, 0xaf, 0x37, 0x6a, 0x42, 0xfb,
0x25, 0x7b, 0x6c, 0x52, 0x32, 0x76, 0xe8, 0x19, 0x96, 0xf6, 0xea, 0x1f, 0x33, 0x8c, 0x60, 0xc6,
0x22, 0xc6, 0xdc, 0xbd, 0xf5, 0x2f, 0x50, 0x26, 0x92, 0x5c, 0x2c, 0xb7, 0xdf, 0xeb, 0x00, 0x03,
0xdd, 0xd3, 0x3e, 0xd5, 0x2d, 0x4a, 0x0c, 0xb9, 0xe9, 0x11, 0x09, 0x6a, 0x40, 0x89, 0xf5, 0x26,
0x1e, 0x31, 0x64, 0x9e, 0x13, 0xf4, 0x23, 0xeb, 0x2c, 0x7e, 0xbf, 0x75, 0xc6, 0x77, 0xb9, 0x34,
0xb5, 0xcb, 0x11, 0xf2, 0xa7, 0x44, 0xc9, 0x1f, 0x7b, 0x36, 0xc7, 0x35, 0x6d, 0xd7, 0xa4, 0x67,
0xfc, 0xd5, 0x64, 0x71, 0xd0, 0x67, 0xe9, 0xf4, 0x98, 0x8c, 0x1d, 0xdb, 0x1e, 0x69, 0x02, 0xbc,
0x56, 0xb8, 0xe9, 0xaa, 0x14, 0xb6, 0x39, 0x86, 0xfd, 0x3c, 0x13, 0x5e, 0xbf, 0x90, 0xe4, 0xff,
0xc7, 0x6d, 0xb0, 0xfa, 0x0b, 0x9e, 0xf9, 0xc7, 0x39, 0x01, 0x3a, 0x82, 0xb5, 0xe0, 0xfa, 0x6b,
0x13, 0x0e, 0x0b, 0xfe, 0x81, 0x5e, 0x16, 0x3f, 0x6a, 0x27, 0x71, 0xb1, 0x87, 0x7e, 0x00, 0x57,
0xa7, 0xa0, 0x2d, 0x70, 0x9d, 0x59, 0x12, 0xe1, 0x9e, 0x88, 0x23, 0x9c, 0xef, 0x39, 0xdc, 0xab,
0xec, 0xf7, 0xbc, 0x74, 0xbb, 0x2c, 0x99, 0x8c, 0x32, 0x9c, 0xb9, 0x6f, 0xff, 0x19, 0x28, 0xbb,
0x84, 0xea, 0xa6, 0xa5, 0xc5, 0xd2, 0xf5, 0x55, 0x21, 0x94, 0x45, 0x80, 0x43, 0x78, 0x62, 0x2e,
0xd3, 0x41, 0xff, 0x0d, 0x4a, 0x48, 0x92, 0xd2, 0x09, 0x99, 0x6f, 0x90, 0xcd, 0x85, 0xba, 0xea,
0x6f, 0xd3, 0xa1, 0xcb, 0x78, 0x7e, 0xd8, 0x86, 0x82, 0x4b, 0xbc, 0xc9, 0x48, 0x64, 0x6c, 0x95,
0xed, 0x97, 0x97, 0xe3, 0x48, 0x4c, 0x3a, 0x19, 0x51, 0x2c, 0x8d, 0xd5, 0x87, 0x50, 0x10, 0x12,
0xb4, 0x02, 0xc5, 0xfb, 0xfb, 0xf7, 0xf6, 0x0f, 0x3e, 0xd8, 0xaf, 0xa5, 0x10, 0x40, 0x61, 0xa7,
0xd5, 0x6a, 0x1f, 0x76, 0x6b, 0x69, 0xa4, 0x40, 0x7e, 0xa7, 0x79, 0x80, 0xbb, 0xb5, 0x0c, 0x13,
0xe3, 0xf6, 0x7b, 0xed, 0x56, 0xb7, 0x96, 0x45, 0x6b, 0x50, 0x16, 0x6d, 0xed, 0xee, 0x01, 0x7e,
0x7f, 0xa7, 0x5b, 0xcb, 0x45, 0x44, 0x47, 0xed, 0xfd, 0x3b, 0x6d, 0x5c, 0xcb, 0xab, 0xaf, 0xb0,
0x94, 0x30, 0x81, 0x55, 0x85, 0xc9, 0x5f, 0x3a, 0x92, 0xfc, 0xa9, 0xbf, 0xca, 0x40, 0x23, 0x99,
0x2a, 0xa1, 0xf7, 0xa6, 0x16, 0xbe, 0x7d, 0x01, 0x9e, 0x35, 0xb5, 0x7a, 0xf4, 0x2c, 0x54, 0x5c,
0x72, 0x4c, 0x68, 0x7f, 0x28, 0xa8, 0x9b, 0x88, 0x98, 0x65, 0x5c, 0x96, 0x52, 0x6e, 0xe4, 0x09,
0xb5, 0x8f, 0x49, 0x9f, 0x6a, 0x02, 0x8a, 0xc4, 0xa1, 0x53, 0x98, 0x1a, 0x93, 0x1e, 0x09, 0xa1,
0xfa, 0xd1, 0x85, 0xf6, 0x52, 0x81, 0x3c, 0x6e, 0x77, 0xf1, 0x0f, 0x6b, 0x59, 0x84, 0xa0, 0xc2,
0x9b, 0xda, 0xd1, 0xfe, 0xce, 0xe1, 0x51, 0xe7, 0x80, 0xed, 0xe5, 0x25, 0xa8, 0xfa, 0x7b, 0xe9,
0x0b, 0xf3, 0xea, 0x6d, 0xb8, 0x9a, 0xc0, 0xf3, 0x16, 0xe4, 0xbf, 0xea, 0x3f, 0xd3, 0x50, 0x9d,
0xba, 0x5a, 0x68, 0x1b, 0xf2, 0x22, 0x71, 0x48, 0xfa, 0x88, 0xc2, 0x91, 0x41, 0xde, 0x43, 0xa1,
0x8a, 0xde, 0x82, 0x12, 0x91, 0x15, 0x9a, 0x79, 0x57, 0x58, 0xa4, 0xc8, 0x7e, 0x0d, 0x47, 0x9a,
0x06, 0x16, 0xe8, 0x6d, 0x50, 0x02, 0x8c, 0x90, 0xd9, 0xea, 0xd3, 0x73, 0x32, 0x6c, 0x5f, 0x45,
0xda, 0x87, 0x36, 0xe8, 0x8d, 0x90, 0x26, 0xe6, 0x66, 0xd3, 0x15, 0x69, 0x2e, 0x14, 0xa4, 0xb1,
0xaf, 0xaf, 0xb6, 0x60, 0x25, 0xb2, 0x1e, 0xf4, 0x14, 0x28, 0x63, 0xfd, 0x54, 0x56, 0xfe, 0x44,
0xed, 0xa6, 0x34, 0xd6, 0x4f, 0x45, 0xd1, 0xef, 0x2a, 0x14, 0xd9, 0xe0, 0x40, 0xf7, 0x64, 0x95,
0xa0, 0x30, 0xd6, 0x4f, 0xdf, 0xd5, 0x3d, 0xf5, 0x43, 0xa8, 0xc4, 0xab, 0x5e, 0xec, 0x0c, 0xbb,
0xf6, 0xc4, 0x32, 0xb8, 0x8f, 0x3c, 0x16, 0x1d, 0xf4, 0x9a, 0x5f, 0x46, 0xc8, 0x24, 0x5c, 0xf6,
0x07, 0x36, 0x25, 0x91, 0xaa, 0x99, 0xac, 0x27, 0x3c, 0x86, 0x3c, 0x87, 0x2d, 0x06, 0x41, 0xbc,
0x7e, 0x25, 0x29, 0x32, 0x6b, 0xa3, 0x0f, 0x01, 0x74, 0x4a, 0x5d, 0xb3, 0x37, 0x09, 0x1d, 0x6f,
0xcc, 0x87, 0xbd, 0x1d, 0x5f, 0xaf, 0x79, 0x4d, 0xe2, 0xdf, 0xe5, 0xd0, 0x34, 0x82, 0x81, 0x11,
0x87, 0xea, 0x3e, 0x54, 0xe2, 0xb6, 0xd1, 0x4a, 0xf2, 0xea, 0x9c, 0x4a, 0x72, 0x40, 0xc3, 0x02,
0x12, 0x97, 0x15, 0xb5, 0x4a, 0xde, 0x51, 0x3f, 0x4b, 0x43, 0xa9, 0x7b, 0x2a, 0x2f, 0x44, 0x42,
0x99, 0x2c, 0x34, 0xcd, 0x44, 0x8b, 0x42, 0xa2, 0xee, 0x96, 0x0d, 0xaa, 0x79, 0xef, 0x04, 0x57,
0x3e, 0xb7, 0x6c, 0x9a, 0xec, 0x97, 0x35, 0x25, 0xcc, 0xbd, 0x09, 0x4a, 0x70, 0xaa, 0x58, 0xae,
0xa1, 0x1b, 0x86, 0x4b, 0x3c, 0x4f, 0xae, 0xcd, 0xef, 0xf2, 0xaa, 0xab, 0xfd, 0xa9, 0x2c, 0x3b,
0x65, 0xb1, 0xe8, 0xa8, 0x06, 0x54, 0xa7, 0x02, 0x1e, 0x7a, 0x13, 0x8a, 0xce, 0xa4, 0xa7, 0xf9,
0xdb, 0x33, 0x75, 0x79, 0x7c, 0xde, 0x39, 0xe9, 0x8d, 0xcc, 0xfe, 0x3d, 0x72, 0xe6, 0x3f, 0x8c,
0x33, 0xe9, 0xdd, 0x13, 0xbb, 0x28, 0x66, 0xc9, 0x44, 0x67, 0x39, 0x81, 0x92, 0x7f, 0x28, 0xd0,
0xff, 0x45, 0xef, 0x89, 0x5f, 0x8b, 0x4f, 0x0c, 0xc2, 0xd2, 0x7d, 0xe4, 0x9a, 0xdc, 0x82, 0x35,
0xcf, 0x1c, 0x58, 0xc4, 0xd0, 0xc2, 0x6c, 0x87, 0xcf, 0x56, 0xc2, 0x55, 0x31, 0xb0, 0xe7, 0xa7,
0x3a, 0xea, 0x3f, 0xd2, 0x50, 0xf2, 0x2f, 0x2c, 0x7a, 0x25, 0x72, 0xee, 0x2a, 0x73, 0x4a, 0x42,
0xbe, 0x62, 0x58, 0x38, 0x8d, 0x3f, 0x6b, 0xe6, 0xe2, 0xcf, 0x9a, 0x54, 0x01, 0xf7, 0x3f, 0x45,
0xe4, 0x2e, 0xfc, 0x29, 0xe2, 0x25, 0x40, 0xd4, 0xa6, 0xfa, 0x48, 0x3b, 0xb1, 0xa9, 0x69, 0x0d,
0x34, 0xb1, 0xd9, 0x82, 0x8b, 0xd5, 0xf8, 0xc8, 0x03, 0x3e, 0x70, 0xc8, 0xf7, 0xfd, 0xa7, 0x69,
0x28, 0x05, 0x51, 0xf5, 0xa2, 0x75, 0xd0, 0x2b, 0x50, 0x90, 0x81, 0x43, 0x14, 0x42, 0x65, 0x2f,
0x28, 0xc9, 0xe7, 0x22, 0x25, 0xf9, 0x06, 0x94, 0xc6, 0x84, 0xea, 0x1c, 0x9f, 0x45, 0xc2, 0x19,
0xf4, 0x6f, 0xbd, 0x01, 0x2b, 0x91, 0x92, 0x34, 0xbb, 0x79, 0xfb, 0xed, 0x0f, 0x6a, 0xa9, 0x46,
0xf1, 0xb3, 0x2f, 0x6e, 0x64, 0xf7, 0xc9, 0xa7, 0xec, 0xcc, 0xe2, 0x76, 0xab, 0xd3, 0x6e, 0xdd,
0xab, 0xa5, 0x1b, 0x2b, 0x9f, 0x7d, 0x71, 0xa3, 0x88, 0x09, 0xaf, 0x24, 0xdd, 0xea, 0xc0, 0x6a,
0xf4, 0xad, 0xc4, 0x63, 0x0f, 0x82, 0xca, 0x9d, 0xfb, 0x87, 0x7b, 0xbb, 0xad, 0x9d, 0x6e, 0x5b,
0x7b, 0x70, 0xd0, 0x6d, 0xd7, 0xd2, 0xe8, 0x2a, 0x5c, 0xda, 0xdb, 0x7d, 0xb7, 0xd3, 0xd5, 0x5a,
0x7b, 0xbb, 0xed, 0xfd, 0xae, 0xb6, 0xd3, 0xed, 0xee, 0xb4, 0xee, 0xd5, 0x32, 0xdb, 0x7f, 0x05,
0xa8, 0xee, 0x34, 0x5b, 0xbb, 0x2c, 0x6e, 0x9a, 0x7d, 0x5d, 0x56, 0xea, 0x72, 0x3c, 0xdf, 0x3f,
0xf7, 0x0b, 0x7b, 0xe3, 0xfc, 0x42, 0x25, 0xba, 0x0b, 0x79, 0x5e, 0x0a, 0x40, 0xe7, 0x7f, 0x72,
0x6f, 0x2c, 0xa8, 0x5c, 0xb2, 0x87, 0xe1, 0xd7, 0xe3, 0xdc, 0x6f, 0xf0, 0x8d, 0xf3, 0x0b, 0x99,
0x08, 0x83, 0x12, 0xe6, 0xf2, 0x8b, 0xbf, 0xc9, 0x37, 0x96, 0x28, 0x6e, 0x32, 0x9f, 0x61, 0x42,
0xb1, 0xf8, 0x1b, 0x75, 0x63, 0x09, 0x00, 0x43, 0x7b, 0x50, 0xf4, 0x73, 0xc0, 0x45, 0x5f, 0xcd,
0x1b, 0x0b, 0x0b, 0x8f, 0xec, 0x15, 0x88, 0x5c, 0xfd, 0xfc, 0x5f, 0x00, 0x1a, 0x0b, 0xaa, 0xa8,
0x68, 0x17, 0x0a, 0x92, 0x25, 0x2f, 0xf8, 0x12, 0xde, 0x58, 0x54, 0x48, 0x64, 0x9b, 0x16, 0x16,
0x41, 0x16, 0xff, 0xd8, 0xd0, 0x58, 0xa2, 0x40, 0x8c, 0xee, 0x03, 0x44, 0x32, 0xf3, 0x25, 0xfe,
0x58, 0x68, 0x2c, 0x53, 0xf8, 0x45, 0x07, 0x50, 0x0a, 0x12, 0xa5, 0x85, 0xff, 0x0f, 0x34, 0x16,
0x57, 0x60, 0xd1, 0x43, 0x28, 0xc7, 0x33, 0x84, 0xe5, 0xfe, 0x0a, 0x68, 0x2c, 0x59, 0x5a, 0x65,
0xfe, 0xe3, 0xe9, 0xc2, 0x72, 0x7f, 0x09, 0x34, 0x96, 0xac, 0xb4, 0xa2, 0x8f, 0x61, 0x6d, 0x96,
0xce, 0x2f, 0xff, 0xd3, 0x40, 0xe3, 0x02, 0xb5, 0x57, 0x34, 0x06, 0x34, 0x27, 0x0d, 0xb8, 0xc0,
0x3f, 0x04, 0x8d, 0x8b, 0x94, 0x62, 0x91, 0x01, 0xd5, 0x69, 0x6e, 0xbd, 0xec, 0x3f, 0x05, 0x8d,
0xa5, 0xcb, 0xb2, 0xcd, 0xf6, 0x97, 0xdf, 0xac, 0xa7, 0xbf, 0xfa, 0x66, 0x3d, 0xfd, 0xe7, 0x6f,
0xd6, 0xd3, 0x9f, 0x7f, 0xbb, 0x9e, 0xfa, 0xea, 0xdb, 0xf5, 0xd4, 0x1f, 0xbe, 0x5d, 0x4f, 0xfd,
0xe8, 0xc5, 0x81, 0x49, 0x87, 0x93, 0xde, 0x66, 0xdf, 0x1e, 0x6f, 0x45, 0x7f, 0xa3, 0x9a, 0xf7,
0x6b, 0x57, 0xaf, 0xc0, 0xc3, 0xe1, 0xab, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x54, 0x3f, 0x72,
0x96, 0xfa, 0x25, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -5130,6 +5142,20 @@ func (m *RequestPrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
_ = i
var l int
_ = l
if len(m.Votes) > 0 {
for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Votes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
}
if m.BlockDataSize != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.BlockDataSize))
i--
@@ -7347,6 +7373,12 @@ func (m *RequestPrepareProposal) Size() (n int) {
if m.BlockDataSize != 0 {
n += 1 + sovTypes(uint64(m.BlockDataSize))
}
if len(m.Votes) > 0 {
for _, e := range m.Votes {
l = e.Size()
n += 1 + l + sovTypes(uint64(l))
}
}
return n
}
@@ -10507,6 +10539,40 @@ func (m *RequestPrepareProposal) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Votes", 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
}
m.Votes = append(m.Votes, &types1.Vote{})
if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
behaviour/doc.go
+4 -4
View File
@@ -1,10 +1,10 @@
/*
Package Behaviour provides a mechanism for reactors to report behaviour of peers.
Package Behavior provides a mechanism for reactors to report behavior of peers.
Instead of a reactor calling the switch directly it will call the behaviour module which will
Instead of a reactor calling the switch directly it will call the behavior module which will
handle the stoping and marking peer as good on behalf of the reactor.
There are four different behaviours a reactor can report.
There are four different behaviors a reactor can report.
1. bad message
@@ -39,4 +39,4 @@ type blockPart struct {
This message will request the peer be marked as good
*/
package behaviour
package behaviour //nolint:misspell
behaviour/peer_behaviour.go
+3 -3
View File
@@ -1,12 +1,12 @@
package behaviour
package behaviour //nolint:misspell
import (
"github.com/tendermint/tendermint/p2p"
)
// PeerBehaviour is a struct describing a behaviour a peer performed.
// PeerBehaviour is a struct describing a behavior a peer performed.
// `peerID` identifies the peer and reason characterizes the specific
// behaviour performed by the peer.
// behavior performed by the peer.
type PeerBehaviour struct {
peerID p2p.ID
reason interface{}
behaviour/reporter.go
+13 -13
View File
@@ -1,4 +1,4 @@
package behaviour
package behaviour //nolint:misspell
import (
"errors"
@@ -7,13 +7,13 @@ import (
"github.com/tendermint/tendermint/p2p"
)
// Reporter provides an interface for reactors to report the behaviour
// Reporter provides an interface for reactors to report the behavior
// of peers synchronously to other components.
type Reporter interface {
Report(behaviour PeerBehaviour) error
Report(behavior PeerBehaviour) error
}
// SwitchReporter reports peer behaviour to an internal Switch.
// SwitchReporter reports peer behavior to an internal Switch.
type SwitchReporter struct {
sw *p2p.Switch
}
@@ -25,14 +25,14 @@ func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
}
}
// Report reports the behaviour of a peer to the Switch.
func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
peer := spbr.sw.Peers().Get(behaviour.peerID)
// Report reports the behavior of a peer to the Switch.
func (spbr *SwitchReporter) Report(behavior PeerBehaviour) error {
peer := spbr.sw.Peers().Get(behavior.peerID)
if peer == nil {
return errors.New("peer not found")
}
switch reason := behaviour.reason.(type) {
switch reason := behavior.reason.(type) {
case consensusVote, blockPart:
spbr.sw.MarkPeerAsGood(peer)
case badMessage:
@@ -48,14 +48,14 @@ func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
// MockReporter is a concrete implementation of the Reporter
// interface used in reactor tests to ensure reactors report the correct
// behaviour in manufactured scenarios.
// behavior in manufactured scenarios.
type MockReporter struct {
mtx tmsync.RWMutex
pb map[p2p.ID][]PeerBehaviour
}
// NewMockReporter returns a Reporter which records all reported
// behaviours in memory.
// behaviors in memory.
func NewMockReporter() *MockReporter {
return &MockReporter{
pb: map[p2p.ID][]PeerBehaviour{},
@@ -63,15 +63,15 @@ func NewMockReporter() *MockReporter {
}
// Report stores the PeerBehaviour produced by the peer identified by peerID.
func (mpbr *MockReporter) Report(behaviour PeerBehaviour) error {
func (mpbr *MockReporter) Report(behavior PeerBehaviour) error {
mpbr.mtx.Lock()
defer mpbr.mtx.Unlock()
mpbr.pb[behaviour.peerID] = append(mpbr.pb[behaviour.peerID], behaviour)
mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
return nil
}
// GetBehaviours returns all behaviours reported on the peer identified by peerID.
// GetBehaviours returns all behaviors reported on the peer identified by peerID.
func (mpbr *MockReporter) GetBehaviours(peerID p2p.ID) []PeerBehaviour {
mpbr.mtx.RLock()
defer mpbr.mtx.RUnlock()
behaviour/reporter_test.go
+31 -31
View File
@@ -1,41 +1,41 @@
package behaviour_test
package behaviour_test //nolint:misspell
import (
"sync"
"testing"
bh "github.com/tendermint/tendermint/behaviour"
bh "github.com/tendermint/tendermint/behaviour" //nolint:misspell
"github.com/tendermint/tendermint/p2p"
)
// TestMockReporter tests the MockReporter's ability to store reported
// peer behaviour in memory indexed by the peerID.
// peer behavior in memory indexed by the peerID.
func TestMockReporter(t *testing.T) {
var peerID p2p.ID = "MockPeer"
pr := bh.NewMockReporter()
behaviours := pr.GetBehaviours(peerID)
if len(behaviours) != 0 {
t.Error("Expected to have no behaviours reported")
behaviors := pr.GetBehaviours(peerID)
if len(behaviors) != 0 {
t.Error("Expected to have no behaviors reported")
}
badMessage := bh.BadMessage(peerID, "bad message")
if err := pr.Report(badMessage); err != nil {
t.Error(err)
}
behaviours = pr.GetBehaviours(peerID)
if len(behaviours) != 1 {
t.Error("Expected the peer have one reported behaviour")
behaviors = pr.GetBehaviours(peerID)
if len(behaviors) != 1 {
t.Error("Expected the peer have one reported behavior")
}
if behaviours[0] != badMessage {
if behaviors[0] != badMessage {
t.Error("Expected Bad Message to have been reported")
}
}
type scriptItem struct {
peerID p2p.ID
behaviour bh.PeerBehaviour
peerID p2p.ID
behavior bh.PeerBehaviour
}
// equalBehaviours returns true if a and b contain the same PeerBehaviours with
@@ -44,26 +44,26 @@ func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
aHistogram := map[bh.PeerBehaviour]int{}
bHistogram := map[bh.PeerBehaviour]int{}
for _, behaviour := range a {
aHistogram[behaviour]++
for _, behavior := range a {
aHistogram[behavior]++
}
for _, behaviour := range b {
bHistogram[behaviour]++
for _, behavior := range b {
bHistogram[behavior]++
}
if len(aHistogram) != len(bHistogram) {
return false
}
for _, behaviour := range a {
if aHistogram[behaviour] != bHistogram[behaviour] {
for _, behavior := range a {
if aHistogram[behavior] != bHistogram[behavior] {
return false
}
}
for _, behaviour := range b {
if bHistogram[behaviour] != aHistogram[behaviour] {
for _, behavior := range b {
if bHistogram[behavior] != aHistogram[behavior] {
return false
}
}
@@ -72,8 +72,8 @@ func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
}
// TestEqualPeerBehaviours tests that equalBehaviours can tell that two slices
// of peer behaviours can be compared for the behaviours they contain and the
// freequencies that those behaviours occur.
// of peer behaviors can be compared for the behaviors they contain and the
// freequencies that those behaviors occur.
func TestEqualPeerBehaviours(t *testing.T) {
var (
peerID p2p.ID = "MockPeer"
@@ -85,7 +85,7 @@ func TestEqualPeerBehaviours(t *testing.T) {
}{
// Empty sets
{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{}},
// Single behaviours
// Single behaviors
{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{consensusVote}},
// Equal Frequencies
{[]bh.PeerBehaviour{consensusVote, consensusVote},
@@ -100,9 +100,9 @@ func TestEqualPeerBehaviours(t *testing.T) {
}{
// Comparing empty sets to non empty sets
{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{consensusVote}},
// Different behaviours
// Different behaviors
{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{blockPart}},
// Same behaviour with different frequencies
// Same behavior with different frequencies
{[]bh.PeerBehaviour{consensusVote},
[]bh.PeerBehaviour{consensusVote, consensusVote}},
}
@@ -128,8 +128,8 @@ func TestEqualPeerBehaviours(t *testing.T) {
func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
var (
behaviourScript = []struct {
peerID p2p.ID
behaviours []bh.PeerBehaviour
peerID p2p.ID
behaviors []bh.PeerBehaviour
}{
{"1", []bh.PeerBehaviour{bh.ConsensusVote("1", "")}},
{"2", []bh.PeerBehaviour{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
@@ -166,7 +166,7 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
for {
select {
case pb := <-scriptItems:
if err := pr.Report(pb.behaviour); err != nil {
if err := pr.Report(pb.behavior); err != nil {
t.Error(err)
}
case <-done:
@@ -181,7 +181,7 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
go func() {
defer sendingWg.Done()
for _, item := range behaviourScript {
for _, reason := range item.behaviours {
for _, reason := range item.behaviors {
scriptItems <- scriptItem{item.peerID, reason}
}
}
@@ -197,9 +197,9 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
for _, items := range behaviourScript {
reported := pr.GetBehaviours(items.peerID)
if !equalBehaviours(reported, items.behaviours) {
if !equalBehaviours(reported, items.behaviors) {
t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
items.peerID, items.behaviours, reported)
items.peerID, items.behaviors, reported)
}
}
}
blockchain/v1/reactor.go
+2 -2
View File
@@ -5,7 +5,7 @@ import (
"reflect"
"time"
"github.com/tendermint/tendermint/behaviour"
"github.com/tendermint/tendermint/behaviour" //nolint:misspell
bc "github.com/tendermint/tendermint/blockchain"
"github.com/tendermint/tendermint/libs/log"
"github.com/tendermint/tendermint/p2p"
@@ -100,7 +100,7 @@ func NewBlockchainReactor(state sm.State, blockExec *sm.BlockExecutor, store *st
fsm := NewFSM(startHeight, bcR)
bcR.fsm = fsm
bcR.BaseReactor = *p2p.NewBaseReactor("BlockchainReactor", bcR)
// bcR.swReporter = behaviour.NewSwitchReporter(bcR.BaseReactor.Switch)
// bcR.swReporter = behavior.NewSwitchReporter(bcR.BaseReactor.Switch)
return bcR
}
blockchain/v2/processor_test.go
+1 -1
View File
@@ -82,7 +82,7 @@ func executeProcessorTests(t *testing.T, tests []testFields) {
}
}()
// First step must always initialise the currentState as state.
// First step must always initialize the currentState as state.
if step.currentState != nil {
state = makeState(step.currentState)
}
blockchain/v2/reactor.go
+2 -2
View File
@@ -5,7 +5,7 @@ import (
"fmt"
"time"
"github.com/tendermint/tendermint/behaviour"
"github.com/tendermint/tendermint/behaviour" //nolint:misspell
bc "github.com/tendermint/tendermint/blockchain"
"github.com/tendermint/tendermint/libs/log"
tmsync "github.com/tendermint/tendermint/libs/sync"
@@ -139,7 +139,7 @@ func (r *BlockchainReactor) Start() error {
return nil
}
// startSync begins a fast sync, signalled by r.events being non-nil. If state is non-nil,
// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil,
// the scheduler and processor is updated with this state on startup.
func (r *BlockchainReactor) startSync(state *state.State) error {
r.mtx.Lock()
blockchain/v2/reactor_test.go
+2 -2
View File
@@ -14,7 +14,7 @@ import (
dbm "github.com/tendermint/tm-db"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/behaviour"
"github.com/tendermint/tendermint/behaviour" //nolint:misspell
bc "github.com/tendermint/tendermint/blockchain"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/libs/log"
@@ -301,7 +301,7 @@ func newTestReactor(p testReactorParams) *BlockchainReactor {
// t.Run(tt.name, func(t *testing.T) {
// reactor := newTestReactor(params)
// reactor.Start()
// reactor.reporter = behaviour.NewMockReporter()
// reactor.reporter = behavior.NewMockReporter()
// mockSwitch := &mockSwitchIo{switchedToConsensus: false}
// reactor.io = mockSwitch
// // time for go routines to start
blockchain/v2/scheduler_test.go
+1 -1
View File
@@ -2225,7 +2225,7 @@ func TestScHandle(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
var sc *scheduler
for i, step := range tt.steps {
// First step must always initialise the currentState as state.
// First step must always initialize the currentState as state.
if step.currentSc != nil {
sc = newTestScheduler(*step.currentSc)
}
cmd/tendermint/commands/init.go
+1 -1
View File
@@ -14,7 +14,7 @@ import (
tmtime "github.com/tendermint/tendermint/types/time"
)
// InitFilesCmd initialises a fresh Tendermint Core instance.
// InitFilesCmd initializes a fresh Tendermint Core instance.
var InitFilesCmd = &cobra.Command{
Use: "init",
Short: "Initialize Tendermint",
cmd/tendermint/commands/light.go
+1 -1
View File
@@ -101,7 +101,7 @@ func init() {
}
func runProxy(cmd *cobra.Command, args []string) error {
// Initialise logger.
// Initialize logger.
logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
var option log.Option
if verbose {
config/config.go
+1 -1
View File
@@ -370,7 +370,7 @@ type RPCConfig struct {
//
// Enabling this parameter will cause the WebSocket connection to be closed
// instead if it cannot read fast enough, allowing for greater
// predictability in subscription behaviour.
// predictability in subscription behavior.
CloseOnSlowClient bool `mapstructure:"experimental_close_on_slow_client"`
// How long to wait for a tx to be committed during /broadcast_tx_commit
config/toml.go
+1 -1
View File
@@ -230,7 +230,7 @@ experimental_websocket_write_buffer_size = {{ .RPC.WebSocketWriteBufferSize }}
#
# Enabling this experimental parameter will cause the WebSocket connection to
# be closed instead if it cannot read fast enough, allowing for greater
# predictability in subscription behaviour.
# predictability in subscription behavior.
experimental_close_on_slow_client = {{ .RPC.CloseOnSlowClient }}
# How long to wait for a tx to be committed during /broadcast_tx_commit.
consensus/byzantine_test.go
+3 -1
View File
@@ -187,6 +187,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
}
var commit *types.Commit
var votes []*types.Vote
switch {
case lazyProposer.Height == lazyProposer.state.InitialHeight:
// We're creating a proposal for the first block.
@@ -195,6 +196,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
case lazyProposer.LastCommit.HasTwoThirdsMajority():
// Make the commit from LastCommit
commit = lazyProposer.LastCommit.MakeCommit()
votes = lazyProposer.LastCommit.GetVotes()
default: // This shouldn't happen.
lazyProposer.Logger.Error("enterPropose: Cannot propose anything: No commit for the previous block")
return
@@ -212,7 +214,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
proposerAddr := lazyProposer.privValidatorPubKey.Address()
block, blockParts := lazyProposer.blockExec.CreateProposalBlock(
lazyProposer.Height, lazyProposer.state, commit, proposerAddr,
lazyProposer.Height, lazyProposer.state, commit, proposerAddr, votes,
)
// Flush the WAL. Otherwise, we may not recompute the same proposal to sign,
consensus/replay.go
+1 -1
View File
@@ -55,7 +55,7 @@ func (cs *State) readReplayMessage(msg *TimedWALMessage, newStepSub types.Subscr
return fmt.Errorf("roundState mismatch. Got %v; Expected %v", m2, m)
}
case <-newStepSub.Cancelled():
return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was cancelled")
return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was canceled")
case <-ticker:
return fmt.Errorf("failed to read off newStepSub.Out()")
}
consensus/replay_test.go
+1 -1
View File
@@ -98,7 +98,7 @@ func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Confi
select {
case <-newBlockSub.Out():
case <-newBlockSub.Cancelled():
t.Fatal("newBlockSub was cancelled")
t.Fatal("newBlockSub was canceled")
case <-time.After(120 * time.Second):
t.Fatal("Timed out waiting for new block (see trace above)")
}
consensus/state.go
+5 -3
View File
@@ -821,7 +821,7 @@ func (cs *State) handleMsg(mi msgInfo) {
// We unlock here to yield to any routines that need to read the the RoundState.
// Previously, this code held the lock from the point at which the final block
// part was recieved until the block executed against the application.
// part was received until the block executed against the application.
// This prevented the reactor from being able to retrieve the most updated
// version of the RoundState. The reactor needs the updated RoundState to
// gossip the now completed block.
@@ -1193,6 +1193,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
}
var commit *types.Commit
var votes []*types.Vote
switch {
case cs.Height == cs.state.InitialHeight:
// We're creating a proposal for the first block.
@@ -1202,6 +1203,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
case cs.LastCommit.HasTwoThirdsMajority():
// Make the commit from LastCommit
commit = cs.LastCommit.MakeCommit()
votes = cs.LastCommit.GetVotes()
default: // This shouldn't happen.
cs.Logger.Error("propose step; cannot propose anything without commit for the previous block")
@@ -1217,7 +1219,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
proposerAddr := cs.privValidatorPubKey.Address()
return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr, votes)
}
// Enter: `timeoutPropose` after entering Propose.
@@ -2034,7 +2036,7 @@ func (cs *State) addVote(vote *types.Vote, peerID p2p.ID) (added bool, err error
}
// Height mismatch is ignored.
// Not necessarily a bad peer, but not favourable behaviour.
// Not necessarily a bad peer, but not favorable behavior.
if vote.Height != cs.Height {
cs.Logger.Debug("vote ignored and not added", "vote_height", vote.Height, "cs_height", cs.Height, "peer", peerID)
return
libs/pubsub/pubsub.go
+1 -1
View File
@@ -27,7 +27,7 @@
// select {
// case msg <- subscription.Out():
// // handle msg.Data() and msg.Events()
// case <-subscription.Cancelled():
// case <-subscription.Canceled():
// return subscription.Err()
// }
// }
libs/pubsub/subscription.go
+1 -1
View File
@@ -46,7 +46,7 @@ func (s *Subscription) Out() <-chan Message {
// nolint: misspell
// Cancelled returns a channel that's closed when the subscription is
// terminated and supposed to be used in a select statement.
func (s *Subscription) Cancelled() <-chan struct{} {
func (s *Subscription) Cancelled() <-chan struct{} { // nolint: misspell
return s.canceled
}
light/provider/http/http.go
+1 -1
View File
@@ -193,7 +193,7 @@ func (p *http) signedHeader(ctx context.Context, height *int64) (*types.SignedHe
time.Sleep(backoffTimeout(uint16(attempt)))
continue
// either context was cancelled or connection refused.
// either context was canceled or connection refused.
default:
return nil, err
}
node/node_test.go
+3 -1
View File
@@ -52,7 +52,7 @@ func TestNodeStartStop(t *testing.T) {
select {
case <-blocksSub.Out():
case <-blocksSub.Cancelled():
t.Fatal("blocksSub was cancelled")
t.Fatal("blocksSub was canceled")
case <-time.After(10 * time.Second):
t.Fatal("timed out waiting for the node to produce a block")
}
@@ -309,6 +309,7 @@ func TestCreateProposalBlock(t *testing.T) {
height,
state, commit,
proposerAddr,
nil,
)
// check that the part set does not exceed the maximum block size
@@ -387,6 +388,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
height,
state, commit,
proposerAddr,
nil,
)
pb, err := block.ToProto()
p2p/netaddress.go
+1 -1
View File
@@ -329,7 +329,7 @@ func (na *NetAddress) ReachabilityTo(o *NetAddress) int {
case o.IP.To4() != nil:
return Ipv4
case tunneled:
// only prioritise ipv6 if we aren't tunnelling it.
// only prioritize ipv6 if we aren't tunneling it.
return Ipv6Weak
}
return Ipv6Strong
p2p/pex/addrbook_test.go
+1 -1
View File
@@ -771,7 +771,7 @@ func countOldAndNewAddrsInSelection(addrs []*p2p.NetAddress, book *addrBook) (nO
return
}
// Analyse the layout of the selection specified by 'addrs'
// Analyze the layout of the selection specified by 'addrs'
// Returns:
// - seqLens - the lengths of the sequences of addresses of same type
// - seqTypes - the types of sequences in selection
p2p/pex/pex_reactor.go
+1 -1
View File
@@ -489,7 +489,7 @@ func (r *Reactor) ensurePeers() {
}
// TODO: consider moving some checks from toDial into here
// so we don't even consider dialing peers that we want to wait
// before dialling again, or have dialed too many times already
// before dialing again, or have dialed too many times already
toDial[try.ID] = try
}
p2p/transport.go
+2 -2
View File
@@ -20,7 +20,7 @@ const (
defaultHandshakeTimeout = 3 * time.Second
)
// IPResolver is a behaviour subset of net.Resolver.
// IPResolver is a behavior subset of net.Resolver.
type IPResolver interface {
LookupIPAddr(context.Context, string) ([]net.IPAddr, error)
}
@@ -70,7 +70,7 @@ type Transport interface {
}
// transportLifecycle bundles the methods for callers to control start and stop
// behaviour.
// behavior.
type transportLifecycle interface {
Close() error
Listen(NetAddress) error
proto/tendermint/abci/types.proto
+3
View File
@@ -132,6 +132,9 @@ message RequestPrepareProposal {
repeated bytes block_data = 1;
// If an application decides to populate block_data with extra information, they can not exceed this value.
int64 block_data_size = 2;
// votes includes all votes from the previous block. This contains vote extension data that can be used in proposal
// preparation. The votes here will then form the last commit that gets sent in the proposed block.
repeated types.Vote votes = 3;
}
//----------------------------------------
rpc/client/interface.go
+1 -1
View File
@@ -138,7 +138,7 @@ type MempoolClient interface {
}
// EvidenceClient is used for submitting an evidence of the malicious
// behaviour.
// behavior.
type EvidenceClient interface {
BroadcastEvidence(context.Context, types.Evidence) (*ctypes.ResultBroadcastEvidence, error)
}
rpc/client/local/local.go
+1 -1
View File
@@ -259,7 +259,7 @@ func (c *Local) eventsRoutine(
return
}
c.Logger.Error("subscription was cancelled, resubscribing...", "err", sub.Err(), "query", q.String())
c.Logger.Error("subscription was canceled, resubscribing...", "err", sub.Err(), "query", q.String())
sub = c.resubscribe(subscriber, q)
if sub == nil { // client was stopped
return
rpc/core/events.go
+2 -2
View File
@@ -66,7 +66,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er
if closeIfSlow {
var (
err = errors.New("subscription was cancelled (reason: slow client)")
err = errors.New("subscription was canceled (reason: slow client)")
resp = rpctypes.RPCServerError(subscriptionID, err)
)
if !ctx.WSConn.TryWriteRPCResponse(resp) {
@@ -85,7 +85,7 @@ func Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, er
reason = sub.Err().Error()
}
var (
err = fmt.Errorf("subscription was cancelled (reason: %s)", reason)
err = fmt.Errorf("subscription was canceled (reason: %s)", reason)
resp = rpctypes.RPCServerError(subscriptionID, err)
)
if !ctx.WSConn.TryWriteRPCResponse(resp) {
rpc/core/mempool.go
+1 -1
View File
@@ -128,7 +128,7 @@ func BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadc
} else {
reason = deliverTxSub.Err().Error()
}
err = fmt.Errorf("deliverTxSub was cancelled (reason: %s)", reason)
err = fmt.Errorf("deliverTxSub was canceled (reason: %s)", reason)
env.Logger.Error("Error on broadcastTxCommit", "err", err)
return &ctypes.ResultBroadcastTxCommit{
CheckTx: *checkTxRes,
rpc/jsonrpc/server/ws_handler.go
+1 -1
View File
@@ -49,7 +49,7 @@ func NewWebsocketManager(
CheckOrigin: func(r *http.Request) bool {
// TODO ???
//
// The default behaviour would be relevant to browser-based clients,
// The default behavior would be relevant to browser-based clients,
// afaik. I suppose having a pass-through is a workaround for allowing
// for more complex security schemes, shifting the burden of
// AuthN/AuthZ outside the Tendermint RPC.
state/execution.go
+6 -1
View File
@@ -97,6 +97,7 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
height int64,
state State, commit *types.Commit,
proposerAddr []byte,
votes []*types.Vote,
) (*types.Block, *types.PartSet) {
maxBytes := state.ConsensusParams.Block.MaxBytes
@@ -110,7 +111,11 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
txs := blockExec.mempool.ReapMaxBytesMaxGas(maxDataBytes, maxGas)
preparedProposal, err := blockExec.proxyApp.PrepareProposalSync(
abci.RequestPrepareProposal{BlockData: txs.ToSliceOfBytes(), BlockDataSize: maxDataBytes},
abci.RequestPrepareProposal{
BlockData: txs.ToSliceOfBytes(),
BlockDataSize: maxDataBytes,
Votes: types.VotesToProto(votes),
},
)
if err != nil {
// The App MUST ensure that only valid (and hence 'processable') transactions
state/execution_test.go
+1 -1
View File
@@ -408,7 +408,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
assert.EqualValues(t, 10, event.ValidatorUpdates[0].VotingPower)
}
case <-updatesSub.Cancelled():
t.Fatalf("updatesSub was cancelled (reason: %v)", updatesSub.Err())
t.Fatalf("updatesSub was canceled (reason: %v)", updatesSub.Err())
case <-time.After(1 * time.Second):
t.Fatal("Did not receive EventValidatorSetUpdates within 1 sec.")
}
state/state_test.go
+1 -1
View File
@@ -41,7 +41,7 @@ func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, sm.State) {
return tearDown, stateDB, state
}
// TestStateCopy tests the correct copying behaviour of State.
// TestStateCopy tests the correct copying behavior of State.
func TestStateCopy(t *testing.T) {
tearDown, _, state := setupTestCase(t)
defer tearDown(t)
statesync/syncer.go
+1 -1
View File
@@ -267,7 +267,7 @@ func (s *syncer) Sync(snapshot *snapshot, chunks *chunkQueue) (sm.State, *types.
return sm.State{}, nil, err
}
// Spawn chunk fetchers. They will terminate when the chunk queue is closed or context cancelled.
// Spawn chunk fetchers. They will terminate when the chunk queue is closed or context canceled.
fetchCtx, cancel := context.WithCancel(context.TODO())
defer cancel()
for i := int32(0); i < s.chunkFetchers; i++ {
test/maverick/consensus/replay.go
+1 -1
View File
@@ -56,7 +56,7 @@ func (cs *State) readReplayMessage(msg *tmcon.TimedWALMessage, newStepSub types.
return fmt.Errorf("roundState mismatch. Got %v; Expected %v", m2, m)
}
case <-newStepSub.Cancelled():
return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was cancelled")
return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was canceled")
case <-ticker:
return fmt.Errorf("failed to read off newStepSub.Out()")
}
test/maverick/consensus/state.go
+4 -2
View File
@@ -396,7 +396,7 @@ func (cs *State) addVote(
}
// Height mismatch is ignored.
// Not necessarily a bad peer, but not favourable behaviour.
// Not necessarily a bad peer, but not favorable behavior.
if vote.Height != cs.Height {
cs.Logger.Debug("vote ignored and not added", "voteHeight", vote.Height, "csHeight", cs.Height, "peerID", peerID)
return
@@ -1265,6 +1265,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
}
var commit *types.Commit
var votes []*types.Vote
switch {
case cs.Height == cs.state.InitialHeight:
// We're creating a proposal for the first block.
@@ -1273,6 +1274,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
case cs.LastCommit.HasTwoThirdsMajority():
// Make the commit from LastCommit
commit = cs.LastCommit.MakeCommit()
votes = cs.LastCommit.GetVotes()
default: // This shouldn't happen.
cs.Logger.Error("enterPropose: Cannot propose anything: No commit for the previous block")
return
@@ -1286,7 +1288,7 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
}
proposerAddr := cs.privValidatorPubKey.Address()
return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr, votes)
}
// Enter: any +2/3 prevotes at next round.
types/block.go
+2 -1
View File
@@ -509,7 +509,8 @@ func (h *Header) StringIndented(indent string) string {
indent, h.LastResultsHash,
indent, h.EvidenceHash,
indent, h.ProposerAddress,
indent, h.Hash())
indent, h.Hash(),
)
}
// ToProto converts Header to protobuf
types/vote.go
+16
View File
@@ -220,6 +220,22 @@ func (vote *Vote) ToProto() *tmproto.Vote {
}
}
func VotesToProto(votes []*Vote) []*tmproto.Vote {
if votes == nil {
return nil
}
res := make([]*tmproto.Vote, 0, len(votes))
for _, vote := range votes {
v := vote.ToProto()
// protobuf crashes when serializing "repeated" fields with nil elements
if v != nil {
res = append(res, v)
}
}
return res
}
// FromProto converts a proto generetad type to a handwritten type
// return type, nil if everything converts safely, otherwise nil, error
func VoteFromProto(pv *tmproto.Vote) (*Vote, error) {
types/vote_set.go
+4
View File
@@ -226,6 +226,10 @@ func (voteSet *VoteSet) getVote(valIndex int32, blockKey string) (vote *Vote, ok
return nil, false
}
func (voteSet *VoteSet) GetVotes() []*Vote {
return voteSet.votes
}
// Assumes signature is valid.
// If conflicting vote exists, returns it.
func (voteSet *VoteSet) addVerifiedVote(
version/version.go
+1 -1
View File
@@ -15,7 +15,7 @@ const (
)
var (
// P2PProtocol versions all p2p behaviour and msgs.
// P2PProtocol versions all p2p behaviur and msgs.
// This includes proposer selection.
P2PProtocol uint64 = 8