zolfa
/
tendermint
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 221 Wiki Activity
Browse Source

types: add AppVersion to ConsensusParams (#5031) 

Co-authored-by: JamesRay <66258875@qq.com>

making it possible to change app version via EndBlock
pull/5044/head
Anton Kaliaev 4 years ago
committed by GitHub
parent
0b13059216
commit
ceac02b891
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 573 additions and 286 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -1
      CHANGELOG_PENDING.md
  2. +231
    -170
      abci/types/types.pb.go
  3. +3
    -3
      consensus/replay.go
  4. +1
    -0
      proto/tendermint/abci/types/types.proto
  5. +1
    -3
      proto/tendermint/consensus/walmsgs.pb.go
  6. +1
    -3
      proto/tendermint/crypto/keys/types.pb.go
  7. +289
    -40
      proto/tendermint/types/params.pb.go
  8. +9
    -0
      proto/tendermint/types/params.proto
  9. +3
    -1
      state/execution.go
  10. +3
    -5
      state/execution_test.go
  11. +6
    -22
      state/helpers_test.go
  12. +0
    -36
      state/state_test.go
  13. +2
    -2
      state/validation_test.go
  14. +10
    -0
      types/params.go
  15. +11
    -0
      types/params_test.go

+ 3
- 1
CHANGELOG_PENDING.md View File

@ -25,7 +25,7 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
- [crypto] \#4940 All keys have become `[]byte` instead of `[<size>]byte`. The byte method no longer returns the marshaled value but just the `[]byte` form of the data.
- [crypto] \4988 Removal of key type multisig
- The key has been moved to the Cosmos-SDK (https://github.com/cosmos/cosmos-sdk/blob/master/crypto/types/multisig/multisignature.go)
- [crypto] \#4989 Remove `Simple` prefixes from `SimpleProof`, `SimpleValueOp` & `SimpleProofNode`.
- [crypto] \#4989 Remove `Simple` prefixes from `SimpleProof`, `SimpleValueOp` & `SimpleProofNode`.
- `merkle.Proof` has been renamed to `ProofOps`.
- Protobuf messages `Proof` & `ProofOp` has been moved to `proto/crypto/merkle`
- `SimpleHashFromByteSlices` has been renamed to `HashFromByteSlices`
@ -91,6 +91,8 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
- [p2p] \#4981 Expose `SaveAs` func on NodeKey (@melekes)
- [evidence] [#4821](https://github.com/tendermint/tendermint/pull/4821) Amnesia evidence can be detected, verified and committed (@cmwaters)
- [rpc] \#5017 Add `/check_tx` endpoint to check transactions without executing them or adding them to the mempool (@melekes)
- [abci] \#5031 Add `AppVersion` to consensus parameters (@james-ray)
... making it possible to update your ABCI application version via `EndBlock` response
### IMPROVEMENTS:


+ 231
- 170
abci/types/types.pb.go View File

@ -2420,6 +2420,7 @@ type ConsensusParams struct {
Block *BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
Evidence *types1.EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
Validator *types1.ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
Version *types1.VersionParams `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
}
func (m *ConsensusParams) Reset() { *m = ConsensusParams{} }
@ -2476,6 +2477,13 @@ func (m *ConsensusParams) GetValidator() *types1.ValidatorParams {
return nil
}
func (m *ConsensusParams) GetVersion() *types1.VersionParams {
if m != nil {
return m.Version
}
return nil
}
// BlockParams contains limits on the block size.
type BlockParams struct {
// Note: must be greater than 0
@ -3132,173 +3140,174 @@ func init() {
func init() { proto.RegisterFile("tendermint/abci/types/types.proto", fileDescriptor_59fda1d591595b39) }
var fileDescriptor_59fda1d591595b39 = []byte{
// 2645 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x72, 0x1b, 0xc7,
0xf1, 0xc7, 0x02, 0x20, 0x3e, 0x9a, 0x04, 0x08, 0x8e, 0x68, 0x19, 0xc6, 0x5f, 0x26, 0xe5, 0x95,
0x65, 0xcb, 0xb6, 0xfe, 0xa0, 0x4d, 0x57, 0xb9, 0xe4, 0x48, 0x89, 0x43, 0x50, 0x54, 0xc0, 0x48,
0x16, 0xa9, 0x25, 0xa9, 0xc8, 0x49, 0x95, 0x37, 0x83, 0xdd, 0x21, 0xb0, 0x26, 0xb0, 0xbb, 0xc6,
0x0e, 0x28, 0x22, 0x95, 0x43, 0x2a, 0x97, 0x54, 0x6e, 0xca, 0x03, 0xe4, 0x1d, 0x72, 0x48, 0x95,
0xf3, 0x02, 0xa9, 0x72, 0xe5, 0xe4, 0x63, 0x4e, 0x4e, 0x4a, 0xca, 0x29, 0x79, 0x87, 0x54, 0x6a,
0x3e, 0xf6, 0x0b, 0x9f, 0x0b, 0x47, 0xb7, 0x5c, 0x50, 0x33, 0xbd, 0xdd, 0x3d, 0x33, 0x3d, 0x33,
0xdd, 0xbf, 0xee, 0x01, 0xbc, 0x41, 0x89, 0x6d, 0x92, 0x7e, 0xcf, 0xb2, 0xe9, 0x16, 0x6e, 0x19,
0xd6, 0x16, 0x1d, 0xba, 0xc4, 0x13, 0xbf, 0x75, 0xb7, 0xef, 0x50, 0x07, 0xbd, 0x12, 0xb2, 0xd4,
0x19, 0x4b, 0x9d, 0x7f, 0xac, 0xbd, 0x19, 0x91, 0x34, 0xfa, 0x43, 0x97, 0x3a, 0x5b, 0x3d, 0xd2,
0x3f, 0xeb, 0x92, 0xa8, 0x70, 0xed, 0x4a, 0x84, 0x6b, 0x4c, 0x75, 0x4d, 0x1d, 0xd7, 0x71, 0x46,
0x86, 0x71, 0x9e, 0xd7, 0xc7, 0x34, 0xb8, 0xb8, 0x8f, 0x7b, 0xfe, 0xe7, 0xcd, 0xb6, 0xe3, 0xb4,
0xbb, 0x64, 0x8b, 0xf7, 0x5a, 0x83, 0xd3, 0x2d, 0x6a, 0xf5, 0x88, 0x47, 0x71, 0xcf, 0x95, 0x0c,
0xeb, 0x6d, 0xa7, 0xed, 0xf0, 0xe6, 0x16, 0x6b, 0x09, 0xaa, 0xfa, 0xaf, 0x02, 0xe4, 0x35, 0xf2,
0xe5, 0x80, 0x78, 0x14, 0xdd, 0x82, 0x2c, 0x31, 0x3a, 0x4e, 0x35, 0x7d, 0x55, 0xb9, 0xb1, 0xbc,
0xad, 0xd6, 0x27, 0xae, 0xb7, 0x2e, 0xb9, 0xf7, 0x8c, 0x8e, 0xd3, 0x4c, 0x69, 0x5c, 0x02, 0xdd,
0x86, 0xa5, 0xd3, 0xee, 0xc0, 0xeb, 0x54, 0x33, 0x5c, 0xf4, 0xda, 0x6c, 0xd1, 0x7b, 0x8c, 0xb5,
0x99, 0xd2, 0x84, 0x0c, 0x1b, 0xd6, 0xb2, 0x4f, 0x9d, 0x6a, 0x36, 0xc9, 0xb0, 0xfb, 0xf6, 0x29,
0x1f, 0x96, 0x49, 0xa0, 0x26, 0x80, 0x47, 0xa8, 0xee, 0xb8, 0xd4, 0x72, 0xec, 0xea, 0x12, 0x97,
0x7f, 0x7b, 0xb6, 0xfc, 0x11, 0xa1, 0x07, 0x9c, 0xbd, 0x99, 0xd2, 0x8a, 0x9e, 0xdf, 0x61, 0x9a,
0x2c, 0xdb, 0xa2, 0xba, 0xd1, 0xc1, 0x96, 0x5d, 0xcd, 0x25, 0xd1, 0xb4, 0x6f, 0x5b, 0x74, 0x97,
0xb1, 0x33, 0x4d, 0x96, 0xdf, 0x61, 0xa6, 0xf8, 0x72, 0x40, 0xfa, 0xc3, 0x6a, 0x3e, 0x89, 0x29,
0x1e, 0x31, 0x56, 0x66, 0x0a, 0x2e, 0x83, 0xee, 0xc3, 0x72, 0x8b, 0xb4, 0x2d, 0x5b, 0x6f, 0x75,
0x1d, 0xe3, 0xac, 0x5a, 0xe0, 0x2a, 0x6e, 0xcc, 0x56, 0xd1, 0x60, 0x02, 0x0d, 0xc6, 0xdf, 0x4c,
0x69, 0xd0, 0x0a, 0x7a, 0xa8, 0x01, 0x05, 0xa3, 0x43, 0x8c, 0x33, 0x9d, 0x5e, 0x54, 0x8b, 0x5c,
0xd3, 0xf5, 0xd9, 0x9a, 0x76, 0x19, 0xf7, 0xf1, 0x45, 0x33, 0xa5, 0xe5, 0x0d, 0xd1, 0x64, 0x76,
0x31, 0x49, 0xd7, 0x3a, 0x27, 0x7d, 0xa6, 0xe5, 0x52, 0x12, 0xbb, 0xdc, 0x15, 0xfc, 0x5c, 0x4f,
0xd1, 0xf4, 0x3b, 0x68, 0x0f, 0x8a, 0xc4, 0x36, 0xe5, 0xc2, 0x96, 0xb9, 0xa2, 0xb7, 0xe6, 0x9c,
0x30, 0xdb, 0xf4, 0x97, 0x55, 0x20, 0xb2, 0x8d, 0x7e, 0x00, 0x39, 0xc3, 0xe9, 0xf5, 0x2c, 0x5a,
0x5d, 0xe1, 0x3a, 0xde, 0x9c, 0xb3, 0x24, 0xce, 0xdb, 0x4c, 0x69, 0x52, 0x0a, 0x1d, 0x43, 0xb9,
0x6b, 0x79, 0x54, 0xf7, 0x6c, 0xec, 0x7a, 0x1d, 0x87, 0x7a, 0xd5, 0x12, 0xd7, 0xf3, 0xde, 0x6c,
0x3d, 0x0f, 0x2c, 0x8f, 0x1e, 0xf9, 0x22, 0xcd, 0x94, 0x56, 0xea, 0x46, 0x09, 0x4c, 0xab, 0x73,
0x7a, 0x4a, 0xfa, 0x81, 0xda, 0x6a, 0x39, 0x89, 0xd6, 0x03, 0x26, 0xe3, 0x6b, 0x61, 0x5a, 0x9d,
0x28, 0x01, 0x61, 0xb8, 0xd4, 0x75, 0xb0, 0x19, 0x28, 0xd5, 0x8d, 0xce, 0xc0, 0x3e, 0xab, 0xae,
0x72, 0xd5, 0x5b, 0x73, 0x26, 0xec, 0x60, 0xd3, 0x57, 0xb4, 0xcb, 0xc4, 0x9a, 0x29, 0x6d, 0xad,
0x3b, 0x4a, 0x44, 0x26, 0xac, 0x63, 0xd7, 0xed, 0x0e, 0x47, 0xc7, 0xa8, 0xf0, 0x31, 0xde, 0x9f,
0x3d, 0xc6, 0x0e, 0x93, 0x1c, 0x1d, 0x04, 0xe1, 0x31, 0x6a, 0x23, 0x0f, 0x4b, 0xe7, 0xb8, 0x3b,
0x20, 0xea, 0xdb, 0xb0, 0x1c, 0x71, 0x1f, 0xa8, 0x0a, 0xf9, 0x1e, 0xf1, 0x3c, 0xdc, 0x26, 0x55,
0xe5, 0xaa, 0x72, 0xa3, 0xa8, 0xf9, 0x5d, 0xb5, 0x0c, 0x2b, 0x51, 0x67, 0xa1, 0xf6, 0x02, 0x41,
0xe6, 0x00, 0x98, 0xe0, 0x39, 0xe9, 0x7b, 0xec, 0xd6, 0x4b, 0x41, 0xd9, 0x45, 0xd7, 0xa0, 0xc4,
0x8f, 0x98, 0xee, 0x7f, 0x67, 0xce, 0x2c, 0xab, 0xad, 0x70, 0xe2, 0x63, 0xc9, 0xb4, 0x09, 0xcb,
0xee, 0xb6, 0x1b, 0xb0, 0x64, 0x38, 0x0b, 0xb8, 0xdb, 0xae, 0x64, 0x50, 0xbf, 0x07, 0x95, 0x51,
0x7f, 0x81, 0x2a, 0x90, 0x39, 0x23, 0x43, 0x39, 0x1e, 0x6b, 0xa2, 0x75, 0xb9, 0x2c, 0x3e, 0x46,
0x51, 0x93, 0x6b, 0xfc, 0x43, 0x3a, 0x10, 0x0e, 0x5c, 0x04, 0xf3, 0x71, 0xcc, 0x1f, 0x73, 0xe9,
0xe5, 0xed, 0x5a, 0x5d, 0x38, 0xeb, 0xba, 0xef, 0xac, 0xeb, 0xc7, 0xbe, 0xb3, 0x6e, 0x14, 0xbe,
0xfe, 0x76, 0x33, 0xf5, 0xec, 0x6f, 0x9b, 0x8a, 0xc6, 0x25, 0xd0, 0x6b, 0xec, 0x16, 0x63, 0xcb,
0xd6, 0x2d, 0x53, 0x8e, 0x93, 0xe7, 0xfd, 0x7d, 0x13, 0x3d, 0x82, 0x8a, 0xe1, 0xd8, 0x1e, 0xb1,
0xbd, 0x81, 0xa7, 0x8b, 0x60, 0x20, 0x1d, 0xf0, 0xb4, 0x9b, 0xb5, 0xeb, 0xb3, 0x1f, 0x72, 0x6e,
0x6d, 0xd5, 0x88, 0x13, 0xd0, 0x03, 0x80, 0x73, 0xdc, 0xb5, 0x4c, 0x4c, 0x9d, 0xbe, 0x57, 0xcd,
0x5e, 0xcd, 0xcc, 0x50, 0xf6, 0xd8, 0x67, 0x3c, 0x71, 0x4d, 0x4c, 0x49, 0x23, 0xcb, 0x66, 0xae,
0x45, 0xe4, 0xd1, 0x5b, 0xb0, 0x8a, 0x5d, 0x57, 0xf7, 0x28, 0xa6, 0x44, 0x6f, 0x0d, 0x29, 0xf1,
0xb8, 0x93, 0x5e, 0xd1, 0x4a, 0xd8, 0x75, 0x8f, 0x18, 0xb5, 0xc1, 0x88, 0xaa, 0x19, 0xec, 0x36,
0xf7, 0x87, 0x08, 0x41, 0xd6, 0xc4, 0x14, 0x73, 0x6b, 0xad, 0x68, 0xbc, 0xcd, 0x68, 0x2e, 0xa6,
0x1d, 0x69, 0x03, 0xde, 0x46, 0x97, 0x21, 0xd7, 0x21, 0x56, 0xbb, 0x43, 0xf9, 0xb2, 0x33, 0x9a,
0xec, 0xb1, 0x8d, 0x71, 0xfb, 0xce, 0x39, 0xe1, 0x21, 0xa5, 0xa0, 0x89, 0x8e, 0xfa, 0x2c, 0x0d,
0x6b, 0x63, 0x3e, 0x93, 0xe9, 0xed, 0x60, 0xaf, 0xe3, 0x8f, 0xc5, 0xda, 0xe8, 0x23, 0xa6, 0x17,
0x9b, 0xa4, 0x2f, 0x43, 0x61, 0x35, 0x6a, 0x01, 0xb1, 0xf8, 0x26, 0xff, 0x2e, 0xd7, 0x2c, 0xb9,
0xd1, 0x09, 0x54, 0xba, 0xd8, 0xa3, 0xba, 0xf0, 0x35, 0x3a, 0x8f, 0x6a, 0x99, 0x99, 0x9e, 0xf7,
0x01, 0xf6, 0x7d, 0x14, 0x3b, 0xd7, 0x52, 0x5d, 0xb9, 0x1b, 0xa3, 0xa2, 0x27, 0xb0, 0xde, 0x1a,
0xfe, 0x02, 0xdb, 0xd4, 0xb2, 0x89, 0x3e, 0xb6, 0x3d, 0x9b, 0x53, 0x54, 0xef, 0x9d, 0x5b, 0x26,
0xb1, 0x0d, 0x7f, 0x5f, 0x2e, 0x05, 0x2a, 0x82, 0x7d, 0xf3, 0xd4, 0x27, 0x50, 0x8e, 0xfb, 0x7e,
0x54, 0x86, 0x34, 0xbd, 0x90, 0xc6, 0x48, 0xd3, 0x0b, 0xf4, 0x11, 0x64, 0x99, 0x3a, 0x6e, 0x88,
0xf2, 0xd4, 0xe0, 0x2c, 0xa5, 0x8f, 0x87, 0x2e, 0xd1, 0x38, 0xbf, 0xaa, 0x06, 0x97, 0x20, 0x88,
0x07, 0xa3, 0xba, 0xd5, 0x77, 0x60, 0x75, 0xc4, 0xd5, 0x47, 0x76, 0x54, 0x89, 0xee, 0xa8, 0xba,
0x0a, 0xa5, 0x98, 0x47, 0x57, 0x2f, 0xc3, 0xfa, 0x24, 0xd7, 0xac, 0xda, 0x01, 0x3d, 0xe6, 0x5c,
0xd1, 0x6d, 0x28, 0x04, 0xbe, 0x59, 0x5c, 0xc2, 0x69, 0x76, 0xf3, 0x45, 0xb4, 0x40, 0x80, 0xdd,
0x41, 0x76, 0x8e, 0xf9, 0x39, 0x49, 0xf3, 0xe9, 0xe7, 0xb1, 0xeb, 0x36, 0xb1, 0xd7, 0x51, 0x7f,
0x0e, 0xd5, 0x69, 0x1e, 0x77, 0x64, 0x31, 0xd9, 0xe0, 0x78, 0x5e, 0x86, 0xdc, 0xa9, 0xd3, 0xef,
0x61, 0xca, 0x95, 0x95, 0x34, 0xd9, 0x63, 0xc7, 0x56, 0x78, 0xdf, 0x0c, 0x27, 0x8b, 0x8e, 0xaa,
0xc3, 0x6b, 0x53, 0xfd, 0x2d, 0x13, 0xb1, 0x6c, 0x93, 0x08, 0xab, 0x96, 0x34, 0xd1, 0x09, 0x15,
0x89, 0xc9, 0x8a, 0x0e, 0x1b, 0xd6, 0xe3, 0x2b, 0xe6, 0xfa, 0x8b, 0x9a, 0xec, 0xa9, 0x7f, 0x2e,
0x42, 0x41, 0x23, 0x9e, 0xcb, 0x5c, 0x01, 0x6a, 0x42, 0x91, 0x5c, 0x18, 0x44, 0x20, 0x2a, 0x65,
0x0e, 0xfe, 0x10, 0x32, 0x7b, 0x3e, 0x3f, 0x0b, 0xf8, 0x81, 0x30, 0xfa, 0x38, 0x86, 0x26, 0xaf,
0xcd, 0x53, 0x12, 0x85, 0x93, 0x77, 0xe2, 0x70, 0xf2, 0xcd, 0x39, 0xb2, 0x23, 0x78, 0xf2, 0xe3,
0x18, 0x9e, 0x9c, 0x37, 0x70, 0x0c, 0x50, 0xee, 0x4f, 0x00, 0x94, 0xf3, 0x96, 0x3f, 0x05, 0x51,
0xee, 0x4f, 0x40, 0x94, 0x37, 0xe6, 0xce, 0x65, 0x22, 0xa4, 0xbc, 0x13, 0x87, 0x94, 0xf3, 0xcc,
0x31, 0x82, 0x29, 0x1f, 0x4c, 0xc2, 0x94, 0xef, 0xcc, 0xd1, 0x31, 0x15, 0x54, 0xee, 0x8e, 0x81,
0xca, 0xb7, 0xe6, 0xa8, 0x9a, 0x80, 0x2a, 0xf7, 0x63, 0xa8, 0x12, 0x12, 0xd9, 0x66, 0x0a, 0xac,
0xbc, 0x37, 0x0e, 0x2b, 0xdf, 0x9e, 0x77, 0xd4, 0x26, 0xe1, 0xca, 0x4f, 0x46, 0x70, 0xe5, 0xf5,
0x79, 0xab, 0x1a, 0x05, 0x96, 0x27, 0x53, 0x80, 0xe5, 0xcd, 0x39, 0x8a, 0xe6, 0x20, 0xcb, 0x93,
0x29, 0xc8, 0x72, 0x9e, 0xda, 0x39, 0xd0, 0xb2, 0x35, 0x0b, 0x5a, 0xbe, 0x3f, 0x6f, 0xca, 0xc9,
0xb0, 0x25, 0x99, 0x89, 0x2d, 0x3f, 0x98, 0x33, 0xc8, 0xe2, 0xe0, 0xf2, 0x1d, 0x16, 0xde, 0x47,
0x5c, 0x12, 0x73, 0x85, 0xa4, 0xdf, 0x77, 0xfa, 0x12, 0xb7, 0x89, 0x8e, 0x7a, 0x83, 0x01, 0x8e,
0xd0, 0xf1, 0xcc, 0x00, 0xa2, 0x3c, 0xf0, 0x44, 0xdc, 0x8c, 0xfa, 0x27, 0x25, 0x94, 0xe5, 0xd1,
0x39, 0x0a, 0x56, 0x8a, 0x12, 0xac, 0x44, 0xf0, 0x69, 0x3a, 0x8e, 0x4f, 0x37, 0x61, 0x99, 0x85,
0x92, 0x11, 0xe8, 0x89, 0x5d, 0x1f, 0x7a, 0xa2, 0x77, 0x61, 0x8d, 0x63, 0x08, 0x81, 0x62, 0x65,
0xfc, 0xc8, 0xf2, 0x60, 0xb8, 0xca, 0x3e, 0x88, 0xa3, 0x2b, 0x02, 0xc9, 0xff, 0xc3, 0xa5, 0x08,
0x6f, 0x10, 0xa2, 0x04, 0xc6, 0xaa, 0x04, 0xdc, 0x3b, 0x32, 0x56, 0x7d, 0x1a, 0x1a, 0x28, 0x84,
0xb5, 0x08, 0xb2, 0x86, 0x63, 0x12, 0x19, 0x40, 0x78, 0x9b, 0x41, 0xdd, 0xae, 0xd3, 0x96, 0x61,
0x82, 0x35, 0x19, 0x57, 0xe0, 0x53, 0x8b, 0xc2, 0x59, 0xaa, 0x7f, 0x54, 0x42, 0x7d, 0x21, 0xd2,
0x9d, 0x04, 0x4a, 0x95, 0x97, 0x09, 0x4a, 0xd3, 0xff, 0x1d, 0x28, 0x55, 0xff, 0xad, 0x84, 0x5b,
0x1a, 0xc0, 0xcd, 0xef, 0x66, 0x82, 0x30, 0xfc, 0x2e, 0xf1, 0x0d, 0x92, 0xe1, 0x57, 0x66, 0x0a,
0x39, 0xbe, 0x0d, 0xf1, 0x4c, 0x21, 0x2f, 0x02, 0x32, 0xef, 0xa0, 0x4f, 0xa0, 0xe8, 0xf6, 0x1d,
0xe7, 0x54, 0x77, 0x5c, 0x4f, 0xfa, 0xe5, 0x18, 0xc0, 0x12, 0x95, 0xa0, 0xba, 0xa8, 0x26, 0xd5,
0x0f, 0x19, 0xeb, 0x81, 0xeb, 0x69, 0x05, 0x57, 0xb6, 0x22, 0x00, 0xa3, 0x18, 0xc3, 0xbf, 0x57,
0xa0, 0xc8, 0x16, 0xe1, 0xb9, 0xd8, 0x20, 0xdc, 0xbd, 0x16, 0xb5, 0x90, 0xa0, 0x9a, 0x80, 0xc6,
0xdd, 0x3c, 0x7a, 0x08, 0x39, 0x72, 0x4e, 0x6c, 0xca, 0x76, 0x8b, 0x19, 0xf8, 0xca, 0x54, 0x58,
0x49, 0x6c, 0xda, 0xa8, 0x32, 0xb3, 0xfe, 0xf3, 0xdb, 0xcd, 0x8a, 0x90, 0xb9, 0xe9, 0xf4, 0x2c,
0x4a, 0x7a, 0x2e, 0x1d, 0x6a, 0x52, 0x8b, 0xfa, 0x9b, 0x34, 0x43, 0x77, 0xb1, 0x10, 0x30, 0xd1,
0xd0, 0xfe, 0xf5, 0x49, 0x47, 0xb0, 0x7e, 0x32, 0xe3, 0xbf, 0x0e, 0xd0, 0xc6, 0x9e, 0xfe, 0x14,
0xdb, 0x94, 0x98, 0x72, 0x07, 0x8a, 0x6d, 0xec, 0xfd, 0x84, 0x13, 0x18, 0x68, 0x63, 0x9f, 0x07,
0x1e, 0x31, 0xf9, 0x56, 0x64, 0xb4, 0x7c, 0x1b, 0x7b, 0x27, 0x1e, 0x31, 0x23, 0x6b, 0xcd, 0xbf,
0x8c, 0xb5, 0xc6, 0xed, 0x5d, 0x18, 0xb5, 0xf7, 0x6f, 0xd3, 0xe1, 0x3d, 0x09, 0xc1, 0xf0, 0xff,
0xa6, 0x2d, 0x7e, 0xcf, 0x93, 0xe3, 0x78, 0x1c, 0x46, 0x9f, 0xc1, 0x5a, 0x70, 0x3f, 0xf5, 0x01,
0xbf, 0xb7, 0xfe, 0x29, 0x5c, 0xec, 0x9a, 0x57, 0xce, 0xe3, 0x64, 0x0f, 0x7d, 0x0e, 0xaf, 0x8e,
0x78, 0xa3, 0x60, 0x80, 0xf4, 0x42, 0x4e, 0xe9, 0x95, 0xb8, 0x53, 0xf2, 0xf5, 0x87, 0xd6, 0xcb,
0xbc, 0x94, 0x5b, 0xb3, 0xcf, 0x12, 0xb2, 0x28, 0xc2, 0x98, 0x78, 0x26, 0xae, 0x41, 0xa9, 0x4f,
0x28, 0xb6, 0x6c, 0x3d, 0x96, 0xfe, 0xae, 0x08, 0xa2, 0x08, 0x0e, 0xea, 0x63, 0x78, 0x65, 0x22,
0xc6, 0x40, 0xdf, 0x87, 0x62, 0x08, 0x52, 0x94, 0x99, 0x39, 0x64, 0x90, 0x0b, 0x85, 0x12, 0xea,
0x57, 0x4a, 0xa8, 0x38, 0x9e, 0x63, 0xdd, 0x87, 0x5c, 0x9f, 0x78, 0x83, 0xae, 0xc8, 0x77, 0xca,
0xdb, 0x1f, 0x2e, 0x82, 0x51, 0x18, 0x75, 0xd0, 0xa5, 0x9a, 0x54, 0xa1, 0x3e, 0x82, 0x9c, 0xa0,
0x20, 0x80, 0xdc, 0xce, 0xee, 0xee, 0xde, 0xe1, 0x71, 0x25, 0x85, 0x8a, 0xb0, 0xb4, 0xd3, 0x38,
0xd0, 0x8e, 0x2b, 0x0a, 0x23, 0x6b, 0x7b, 0x3f, 0xde, 0xdb, 0x3d, 0xae, 0xa4, 0xd1, 0x1a, 0x94,
0x44, 0x5b, 0xbf, 0x77, 0xa0, 0x7d, 0xba, 0x73, 0x5c, 0xc9, 0x44, 0x48, 0x47, 0x7b, 0x0f, 0xef,
0xee, 0x69, 0x95, 0xac, 0xfa, 0x01, 0xcb, 0xa4, 0xa6, 0x40, 0x98, 0x30, 0x67, 0x52, 0x22, 0x39,
0x93, 0xfa, 0xbb, 0x34, 0xd4, 0xa6, 0x23, 0x12, 0x74, 0x38, 0xb2, 0xe2, 0x5b, 0x0b, 0x83, 0x9a,
0x91, 0x65, 0xa3, 0xeb, 0x50, 0xee, 0x93, 0x53, 0x42, 0x8d, 0x8e, 0x40, 0x4b, 0x22, 0xde, 0x95,
0xb4, 0x92, 0xa4, 0x72, 0x21, 0x4f, 0xb0, 0x7d, 0x41, 0x0c, 0xaa, 0x8b, 0x24, 0x4e, 0x9c, 0xbf,
0x22, 0x63, 0x63, 0xd4, 0x23, 0x41, 0x54, 0x8f, 0xe6, 0x19, 0xb1, 0x08, 0x4b, 0xda, 0xde, 0xb1,
0xf6, 0x59, 0x25, 0x8d, 0x10, 0x94, 0x79, 0x53, 0x3f, 0x7a, 0xb8, 0x73, 0x78, 0xd4, 0x3c, 0x60,
0x46, 0xbc, 0x04, 0xab, 0xbe, 0x11, 0x7d, 0x62, 0x56, 0xfd, 0x8b, 0x02, 0xab, 0x23, 0xd7, 0x03,
0xdd, 0x82, 0x25, 0x01, 0xc1, 0x95, 0x99, 0x45, 0x7c, 0x7e, 0xdf, 0xe5, 0x8d, 0x12, 0x02, 0xe8,
// 2661 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7,
0xf5, 0xe7, 0x92, 0x14, 0x2f, 0x47, 0x22, 0x45, 0x8d, 0x15, 0x87, 0xe1, 0xdf, 0x91, 0x9c, 0x75,
0x9c, 0x38, 0x97, 0x3f, 0x95, 0x28, 0x40, 0x60, 0xd7, 0x6e, 0x53, 0x51, 0x96, 0x4b, 0xd5, 0x8e,
0x25, 0xaf, 0x24, 0xd7, 0x69, 0x81, 0x6c, 0x87, 0xbb, 0x23, 0x72, 0x23, 0x72, 0x77, 0xc3, 0x1d,
0xca, 0x62, 0xd1, 0x87, 0xa2, 0x40, 0x51, 0xf4, 0xcd, 0xfd, 0x00, 0xfd, 0x0e, 0x7d, 0x28, 0x90,
0x7e, 0x81, 0x02, 0x79, 0xcc, 0x63, 0x9f, 0xd2, 0xc2, 0xee, 0x53, 0xfb, 0x1d, 0x8a, 0x62, 0x2e,
0x7b, 0xe3, 0x75, 0x99, 0xfa, 0xad, 0x2f, 0xc4, 0xcc, 0xd9, 0x73, 0xce, 0xcc, 0x9c, 0x99, 0x39,
0xe7, 0x77, 0xce, 0x10, 0xde, 0xa0, 0xc4, 0x36, 0x49, 0xbf, 0x67, 0xd9, 0x74, 0x0b, 0xb7, 0x0c,
0x6b, 0x8b, 0x0e, 0x5d, 0xe2, 0x89, 0xdf, 0xba, 0xdb, 0x77, 0xa8, 0x83, 0x5e, 0x09, 0x59, 0xea,
0x8c, 0xa5, 0xce, 0x3f, 0xd6, 0xde, 0x8c, 0x48, 0x1a, 0xfd, 0xa1, 0x4b, 0x9d, 0xad, 0x1e, 0xe9,
0x9f, 0x75, 0x49, 0x54, 0xb8, 0x76, 0x25, 0xc2, 0x35, 0xa6, 0xba, 0xa6, 0x8e, 0xeb, 0x38, 0x23,
0xc3, 0x38, 0xcf, 0xeb, 0x63, 0x1a, 0x5c, 0xdc, 0xc7, 0x3d, 0xff, 0xf3, 0x66, 0xdb, 0x71, 0xda,
0x5d, 0xb2, 0xc5, 0x7b, 0xad, 0xc1, 0xe9, 0x16, 0xb5, 0x7a, 0xc4, 0xa3, 0xb8, 0xe7, 0x4a, 0x86,
0xf5, 0xb6, 0xd3, 0x76, 0x78, 0x73, 0x8b, 0xb5, 0x04, 0x55, 0xfd, 0x57, 0x01, 0xf2, 0x1a, 0xf9,
0x72, 0x40, 0x3c, 0x8a, 0x6e, 0x42, 0x96, 0x18, 0x1d, 0xa7, 0x9a, 0xbe, 0xaa, 0xdc, 0x58, 0xde,
0x56, 0xeb, 0x13, 0xd7, 0x5b, 0x97, 0xdc, 0x7b, 0x46, 0xc7, 0x69, 0xa6, 0x34, 0x2e, 0x81, 0x6e,
0xc3, 0xd2, 0x69, 0x77, 0xe0, 0x75, 0xaa, 0x19, 0x2e, 0x7a, 0x6d, 0xb6, 0xe8, 0x3d, 0xc6, 0xda,
0x4c, 0x69, 0x42, 0x86, 0x0d, 0x6b, 0xd9, 0xa7, 0x4e, 0x35, 0x9b, 0x64, 0xd8, 0x7d, 0xfb, 0x94,
0x0f, 0xcb, 0x24, 0x50, 0x13, 0xc0, 0x23, 0x54, 0x77, 0x5c, 0x6a, 0x39, 0x76, 0x75, 0x89, 0xcb,
0xbf, 0x3d, 0x5b, 0xfe, 0x88, 0xd0, 0x03, 0xce, 0xde, 0x4c, 0x69, 0x45, 0xcf, 0xef, 0x30, 0x4d,
0x96, 0x6d, 0x51, 0xdd, 0xe8, 0x60, 0xcb, 0xae, 0xe6, 0x92, 0x68, 0xda, 0xb7, 0x2d, 0xba, 0xcb,
0xd8, 0x99, 0x26, 0xcb, 0xef, 0x30, 0x53, 0x7c, 0x39, 0x20, 0xfd, 0x61, 0x35, 0x9f, 0xc4, 0x14,
0x8f, 0x18, 0x2b, 0x33, 0x05, 0x97, 0x41, 0xf7, 0x61, 0xb9, 0x45, 0xda, 0x96, 0xad, 0xb7, 0xba,
0x8e, 0x71, 0x56, 0x2d, 0x70, 0x15, 0x37, 0x66, 0xab, 0x68, 0x30, 0x81, 0x06, 0xe3, 0x6f, 0xa6,
0x34, 0x68, 0x05, 0x3d, 0xd4, 0x80, 0x82, 0xd1, 0x21, 0xc6, 0x99, 0x4e, 0x2f, 0xaa, 0x45, 0xae,
0xe9, 0xfa, 0x6c, 0x4d, 0xbb, 0x8c, 0xfb, 0xf8, 0xa2, 0x99, 0xd2, 0xf2, 0x86, 0x68, 0x32, 0xbb,
0x98, 0xa4, 0x6b, 0x9d, 0x93, 0x3e, 0xd3, 0x72, 0x29, 0x89, 0x5d, 0xee, 0x0a, 0x7e, 0xae, 0xa7,
0x68, 0xfa, 0x1d, 0xb4, 0x07, 0x45, 0x62, 0x9b, 0x72, 0x61, 0xcb, 0x5c, 0xd1, 0x5b, 0x73, 0x4e,
0x98, 0x6d, 0xfa, 0xcb, 0x2a, 0x10, 0xd9, 0x46, 0x3f, 0x80, 0x9c, 0xe1, 0xf4, 0x7a, 0x16, 0xad,
0xae, 0x70, 0x1d, 0x6f, 0xce, 0x59, 0x12, 0xe7, 0x6d, 0xa6, 0x34, 0x29, 0x85, 0x8e, 0xa1, 0xdc,
0xb5, 0x3c, 0xaa, 0x7b, 0x36, 0x76, 0xbd, 0x8e, 0x43, 0xbd, 0x6a, 0x89, 0xeb, 0x79, 0x6f, 0xb6,
0x9e, 0x07, 0x96, 0x47, 0x8f, 0x7c, 0x91, 0x66, 0x4a, 0x2b, 0x75, 0xa3, 0x04, 0xa6, 0xd5, 0x39,
0x3d, 0x25, 0xfd, 0x40, 0x6d, 0xb5, 0x9c, 0x44, 0xeb, 0x01, 0x93, 0xf1, 0xb5, 0x30, 0xad, 0x4e,
0x94, 0x80, 0x30, 0x5c, 0xea, 0x3a, 0xd8, 0x0c, 0x94, 0xea, 0x46, 0x67, 0x60, 0x9f, 0x55, 0x57,
0xb9, 0xea, 0xad, 0x39, 0x13, 0x76, 0xb0, 0xe9, 0x2b, 0xda, 0x65, 0x62, 0xcd, 0x94, 0xb6, 0xd6,
0x1d, 0x25, 0x22, 0x13, 0xd6, 0xb1, 0xeb, 0x76, 0x87, 0xa3, 0x63, 0x54, 0xf8, 0x18, 0x1f, 0xcc,
0x1e, 0x63, 0x87, 0x49, 0x8e, 0x0e, 0x82, 0xf0, 0x18, 0xb5, 0x91, 0x87, 0xa5, 0x73, 0xdc, 0x1d,
0x10, 0xf5, 0x6d, 0x58, 0x8e, 0xb8, 0x0f, 0x54, 0x85, 0x7c, 0x8f, 0x78, 0x1e, 0x6e, 0x93, 0xaa,
0x72, 0x55, 0xb9, 0x51, 0xd4, 0xfc, 0xae, 0x5a, 0x86, 0x95, 0xa8, 0xb3, 0x50, 0x7b, 0x81, 0x20,
0x73, 0x00, 0x4c, 0xf0, 0x9c, 0xf4, 0x3d, 0x76, 0xeb, 0xa5, 0xa0, 0xec, 0xa2, 0x6b, 0x50, 0xe2,
0x47, 0x4c, 0xf7, 0xbf, 0x33, 0x67, 0x96, 0xd5, 0x56, 0x38, 0xf1, 0xb1, 0x64, 0xda, 0x84, 0x65,
0x77, 0xdb, 0x0d, 0x58, 0x32, 0x9c, 0x05, 0xdc, 0x6d, 0x57, 0x32, 0xa8, 0xdf, 0x83, 0xca, 0xa8,
0xbf, 0x40, 0x15, 0xc8, 0x9c, 0x91, 0xa1, 0x1c, 0x8f, 0x35, 0xd1, 0xba, 0x5c, 0x16, 0x1f, 0xa3,
0xa8, 0xc9, 0x35, 0xfe, 0x31, 0x1d, 0x08, 0x07, 0x2e, 0x82, 0xf9, 0x38, 0xe6, 0x8f, 0xb9, 0xf4,
0xf2, 0x76, 0xad, 0x2e, 0x9c, 0x75, 0xdd, 0x77, 0xd6, 0xf5, 0x63, 0xdf, 0x59, 0x37, 0x0a, 0x5f,
0x7f, 0xbb, 0x99, 0x7a, 0xf6, 0xb7, 0x4d, 0x45, 0xe3, 0x12, 0xe8, 0x35, 0x76, 0x8b, 0xb1, 0x65,
0xeb, 0x96, 0x29, 0xc7, 0xc9, 0xf3, 0xfe, 0xbe, 0x89, 0x1e, 0x41, 0xc5, 0x70, 0x6c, 0x8f, 0xd8,
0xde, 0xc0, 0xd3, 0x45, 0x30, 0x90, 0x0e, 0x78, 0xda, 0xcd, 0xda, 0xf5, 0xd9, 0x0f, 0x39, 0xb7,
0xb6, 0x6a, 0xc4, 0x09, 0xe8, 0x01, 0xc0, 0x39, 0xee, 0x5a, 0x26, 0xa6, 0x4e, 0xdf, 0xab, 0x66,
0xaf, 0x66, 0x66, 0x28, 0x7b, 0xec, 0x33, 0x9e, 0xb8, 0x26, 0xa6, 0xa4, 0x91, 0x65, 0x33, 0xd7,
0x22, 0xf2, 0xe8, 0x2d, 0x58, 0xc5, 0xae, 0xab, 0x7b, 0x14, 0x53, 0xa2, 0xb7, 0x86, 0x94, 0x78,
0xdc, 0x49, 0xaf, 0x68, 0x25, 0xec, 0xba, 0x47, 0x8c, 0xda, 0x60, 0x44, 0xd5, 0x0c, 0x76, 0x9b,
0xfb, 0x43, 0x84, 0x20, 0x6b, 0x62, 0x8a, 0xb9, 0xb5, 0x56, 0x34, 0xde, 0x66, 0x34, 0x17, 0xd3,
0x8e, 0xb4, 0x01, 0x6f, 0xa3, 0xcb, 0x90, 0xeb, 0x10, 0xab, 0xdd, 0xa1, 0x7c, 0xd9, 0x19, 0x4d,
0xf6, 0xd8, 0xc6, 0xb8, 0x7d, 0xe7, 0x9c, 0xf0, 0x90, 0x52, 0xd0, 0x44, 0x47, 0x7d, 0x96, 0x86,
0xb5, 0x31, 0x9f, 0xc9, 0xf4, 0x76, 0xb0, 0xd7, 0xf1, 0xc7, 0x62, 0x6d, 0xf4, 0x31, 0xd3, 0x8b,
0x4d, 0xd2, 0x97, 0xa1, 0xb0, 0x1a, 0xb5, 0x80, 0x58, 0x7c, 0x93, 0x7f, 0x97, 0x6b, 0x96, 0xdc,
0xe8, 0x04, 0x2a, 0x5d, 0xec, 0x51, 0x5d, 0xf8, 0x1a, 0x9d, 0x47, 0xb5, 0xcc, 0x4c, 0xcf, 0xfb,
0x00, 0xfb, 0x3e, 0x8a, 0x9d, 0x6b, 0xa9, 0xae, 0xdc, 0x8d, 0x51, 0xd1, 0x13, 0x58, 0x6f, 0x0d,
0x7f, 0x81, 0x6d, 0x6a, 0xd9, 0x44, 0x1f, 0xdb, 0x9e, 0xcd, 0x29, 0xaa, 0xf7, 0xce, 0x2d, 0x93,
0xd8, 0x86, 0xbf, 0x2f, 0x97, 0x02, 0x15, 0xc1, 0xbe, 0x79, 0xea, 0x13, 0x28, 0xc7, 0x7d, 0x3f,
0x2a, 0x43, 0x9a, 0x5e, 0x48, 0x63, 0xa4, 0xe9, 0x05, 0xfa, 0x18, 0xb2, 0x4c, 0x1d, 0x37, 0x44,
0x79, 0x6a, 0x70, 0x96, 0xd2, 0xc7, 0x43, 0x97, 0x68, 0x9c, 0x5f, 0x55, 0x83, 0x4b, 0x10, 0xc4,
0x83, 0x51, 0xdd, 0xea, 0x3b, 0xb0, 0x3a, 0xe2, 0xea, 0x23, 0x3b, 0xaa, 0x44, 0x77, 0x54, 0x5d,
0x85, 0x52, 0xcc, 0xa3, 0xab, 0x97, 0x61, 0x7d, 0x92, 0x6b, 0x56, 0xed, 0x80, 0x1e, 0x73, 0xae,
0xe8, 0x36, 0x14, 0x02, 0xdf, 0x2c, 0x2e, 0xe1, 0x34, 0xbb, 0xf9, 0x22, 0x5a, 0x20, 0xc0, 0xee,
0x20, 0x3b, 0xc7, 0xfc, 0x9c, 0xa4, 0xf9, 0xf4, 0xf3, 0xd8, 0x75, 0x9b, 0xd8, 0xeb, 0xa8, 0x3f,
0x87, 0xea, 0x34, 0x8f, 0x3b, 0xb2, 0x98, 0x6c, 0x70, 0x3c, 0x2f, 0x43, 0xee, 0xd4, 0xe9, 0xf7,
0x30, 0xe5, 0xca, 0x4a, 0x9a, 0xec, 0xb1, 0x63, 0x2b, 0xbc, 0x6f, 0x86, 0x93, 0x45, 0x47, 0xd5,
0xe1, 0xb5, 0xa9, 0xfe, 0x96, 0x89, 0x58, 0xb6, 0x49, 0x84, 0x55, 0x4b, 0x9a, 0xe8, 0x84, 0x8a,
0xc4, 0x64, 0x45, 0x87, 0x0d, 0xeb, 0xf1, 0x15, 0x73, 0xfd, 0x45, 0x4d, 0xf6, 0xd4, 0xbf, 0x14,
0xa1, 0xa0, 0x11, 0xcf, 0x65, 0xae, 0x00, 0x35, 0xa1, 0x48, 0x2e, 0x0c, 0x22, 0x10, 0x95, 0x32,
0x07, 0x7f, 0x08, 0x99, 0x3d, 0x9f, 0x9f, 0x05, 0xfc, 0x40, 0x18, 0xdd, 0x8a, 0xa1, 0xc9, 0x6b,
0xf3, 0x94, 0x44, 0xe1, 0xe4, 0x9d, 0x38, 0x9c, 0x7c, 0x73, 0x8e, 0xec, 0x08, 0x9e, 0xbc, 0x15,
0xc3, 0x93, 0xf3, 0x06, 0x8e, 0x01, 0xca, 0xfd, 0x09, 0x80, 0x72, 0xde, 0xf2, 0xa7, 0x20, 0xca,
0xfd, 0x09, 0x88, 0xf2, 0xc6, 0xdc, 0xb9, 0x4c, 0x84, 0x94, 0x77, 0xe2, 0x90, 0x72, 0x9e, 0x39,
0x46, 0x30, 0xe5, 0x83, 0x49, 0x98, 0xf2, 0x9d, 0x39, 0x3a, 0xa6, 0x82, 0xca, 0xdd, 0x31, 0x50,
0xf9, 0xd6, 0x1c, 0x55, 0x13, 0x50, 0xe5, 0x7e, 0x0c, 0x55, 0x42, 0x22, 0xdb, 0x4c, 0x81, 0x95,
0xf7, 0xc6, 0x61, 0xe5, 0xdb, 0xf3, 0x8e, 0xda, 0x24, 0x5c, 0xf9, 0xc9, 0x08, 0xae, 0xbc, 0x3e,
0x6f, 0x55, 0xa3, 0xc0, 0xf2, 0x64, 0x0a, 0xb0, 0x7c, 0x7f, 0x8e, 0xa2, 0x39, 0xc8, 0xf2, 0x64,
0x0a, 0xb2, 0x9c, 0xa7, 0x76, 0x0e, 0xb4, 0x6c, 0xcd, 0x82, 0x96, 0x1f, 0xcc, 0x9b, 0x72, 0x32,
0x6c, 0x49, 0x66, 0x62, 0xcb, 0x0f, 0xe7, 0x0c, 0xb2, 0x38, 0xb8, 0x7c, 0x87, 0x85, 0xf7, 0x11,
0x97, 0xc4, 0x5c, 0x21, 0xe9, 0xf7, 0x9d, 0xbe, 0xc4, 0x6d, 0xa2, 0xa3, 0xde, 0x60, 0x80, 0x23,
0x74, 0x3c, 0x33, 0x80, 0x28, 0x0f, 0x3c, 0x11, 0x37, 0xa3, 0xfe, 0x59, 0x09, 0x65, 0x79, 0x74,
0x8e, 0x82, 0x95, 0xa2, 0x04, 0x2b, 0x11, 0x7c, 0x9a, 0x8e, 0xe3, 0xd3, 0x4d, 0x58, 0x66, 0xa1,
0x64, 0x04, 0x7a, 0x62, 0xd7, 0x87, 0x9e, 0xe8, 0x5d, 0x58, 0xe3, 0x18, 0x42, 0xa0, 0x58, 0x19,
0x3f, 0xb2, 0x3c, 0x18, 0xae, 0xb2, 0x0f, 0xe2, 0xe8, 0x8a, 0x40, 0xf2, 0xff, 0x70, 0x29, 0xc2,
0x1b, 0x84, 0x28, 0x81, 0xb1, 0x2a, 0x01, 0xf7, 0x8e, 0x8c, 0x55, 0x9f, 0x86, 0x06, 0x0a, 0x61,
0x2d, 0x82, 0xac, 0xe1, 0x98, 0x44, 0x06, 0x10, 0xde, 0x66, 0x50, 0xb7, 0xeb, 0xb4, 0x65, 0x98,
0x60, 0x4d, 0xc6, 0x15, 0xf8, 0xd4, 0xa2, 0x70, 0x96, 0xea, 0x9f, 0x94, 0x50, 0x5f, 0x88, 0x74,
0x27, 0x81, 0x52, 0xe5, 0x65, 0x82, 0xd2, 0xf4, 0x7f, 0x07, 0x4a, 0xd5, 0x7f, 0x2b, 0xe1, 0x96,
0x06, 0x70, 0xf3, 0xbb, 0x99, 0x20, 0x0c, 0xbf, 0x4b, 0x7c, 0x83, 0x64, 0xf8, 0x95, 0x99, 0x42,
0x8e, 0x6f, 0x43, 0x3c, 0x53, 0xc8, 0x8b, 0x80, 0xcc, 0x3b, 0xe8, 0x13, 0x28, 0xba, 0x7d, 0xc7,
0x39, 0xd5, 0x1d, 0xd7, 0x93, 0x7e, 0x39, 0x06, 0xb0, 0x44, 0x25, 0xa8, 0x2e, 0xaa, 0x49, 0xf5,
0x43, 0xc6, 0x7a, 0xe0, 0x7a, 0x5a, 0xc1, 0x95, 0xad, 0x08, 0xc0, 0x28, 0xc6, 0xf0, 0xef, 0x15,
0x28, 0xb2, 0x45, 0x78, 0x2e, 0x36, 0x08, 0x77, 0xaf, 0x45, 0x2d, 0x24, 0xa8, 0x26, 0xa0, 0x71,
0x37, 0x8f, 0x1e, 0x42, 0x8e, 0x9c, 0x13, 0x9b, 0xb2, 0xdd, 0x62, 0x06, 0xbe, 0x32, 0x15, 0x56,
0x12, 0x9b, 0x36, 0xaa, 0xcc, 0xac, 0xff, 0xfc, 0x76, 0xb3, 0x22, 0x64, 0xde, 0x77, 0x7a, 0x16,
0x25, 0x3d, 0x97, 0x0e, 0x35, 0xa9, 0x45, 0xfd, 0x6d, 0x9a, 0xa1, 0xbb, 0x58, 0x08, 0x98, 0x68,
0x68, 0xff, 0xfa, 0xa4, 0x23, 0x58, 0x3f, 0x99, 0xf1, 0x5f, 0x07, 0x68, 0x63, 0x4f, 0x7f, 0x8a,
0x6d, 0x4a, 0x4c, 0xb9, 0x03, 0xc5, 0x36, 0xf6, 0x7e, 0xc2, 0x09, 0x0c, 0xb4, 0xb1, 0xcf, 0x03,
0x8f, 0x98, 0x7c, 0x2b, 0x32, 0x5a, 0xbe, 0x8d, 0xbd, 0x13, 0x8f, 0x98, 0x91, 0xb5, 0xe6, 0x5f,
0xc6, 0x5a, 0xe3, 0xf6, 0x2e, 0x8c, 0xda, 0xfb, 0x77, 0xe9, 0xf0, 0x9e, 0x84, 0x60, 0xf8, 0x7f,
0xd3, 0x16, 0x7f, 0xe0, 0xc9, 0x71, 0x3c, 0x0e, 0xa3, 0xcf, 0x60, 0x2d, 0xb8, 0x9f, 0xfa, 0x80,
0xdf, 0x5b, 0xff, 0x14, 0x2e, 0x76, 0xcd, 0x2b, 0xe7, 0x71, 0xb2, 0x87, 0x3e, 0x87, 0x57, 0x47,
0xbc, 0x51, 0x30, 0x40, 0x7a, 0x21, 0xa7, 0xf4, 0x4a, 0xdc, 0x29, 0xf9, 0xfa, 0x43, 0xeb, 0x65,
0x5e, 0xca, 0xad, 0xd9, 0x67, 0x09, 0x59, 0x14, 0x61, 0x4c, 0x3c, 0x13, 0xd7, 0xa0, 0xd4, 0x27,
0x14, 0x5b, 0xb6, 0x1e, 0x4b, 0x7f, 0x57, 0x04, 0x51, 0x04, 0x07, 0xf5, 0x31, 0xbc, 0x32, 0x11,
0x63, 0xa0, 0xef, 0x43, 0x31, 0x04, 0x29, 0xca, 0xcc, 0x1c, 0x32, 0xc8, 0x85, 0x42, 0x09, 0xf5,
0x2b, 0x25, 0x54, 0x1c, 0xcf, 0xb1, 0xee, 0x43, 0xae, 0x4f, 0xbc, 0x41, 0x57, 0xe4, 0x3b, 0xe5,
0xed, 0x8f, 0x16, 0xc1, 0x28, 0x8c, 0x3a, 0xe8, 0x52, 0x4d, 0xaa, 0x50, 0x1f, 0x41, 0x4e, 0x50,
0x10, 0x40, 0x6e, 0x67, 0x77, 0x77, 0xef, 0xf0, 0xb8, 0x92, 0x42, 0x45, 0x58, 0xda, 0x69, 0x1c,
0x68, 0xc7, 0x15, 0x85, 0x91, 0xb5, 0xbd, 0x1f, 0xef, 0xed, 0x1e, 0x57, 0xd2, 0x68, 0x0d, 0x4a,
0xa2, 0xad, 0xdf, 0x3b, 0xd0, 0x3e, 0xdd, 0x39, 0xae, 0x64, 0x22, 0xa4, 0xa3, 0xbd, 0x87, 0x77,
0xf7, 0xb4, 0x4a, 0x56, 0xfd, 0x90, 0x65, 0x52, 0x53, 0x20, 0x4c, 0x98, 0x33, 0x29, 0x91, 0x9c,
0x49, 0xfd, 0x7d, 0x1a, 0x6a, 0xd3, 0x11, 0x09, 0x3a, 0x1c, 0x59, 0xf1, 0xcd, 0x85, 0x41, 0xcd,
0xc8, 0xb2, 0xd1, 0x75, 0x28, 0xf7, 0xc9, 0x29, 0xa1, 0x46, 0x47, 0xa0, 0x25, 0x11, 0xef, 0x4a,
0x5a, 0x49, 0x52, 0xb9, 0x90, 0x27, 0xd8, 0xbe, 0x20, 0x06, 0xd5, 0x45, 0x12, 0x27, 0xce, 0x5f,
0x91, 0xb1, 0x31, 0xea, 0x91, 0x20, 0xaa, 0x47, 0xf3, 0x8c, 0x58, 0x84, 0x25, 0x6d, 0xef, 0x58,
0xfb, 0xac, 0x92, 0x46, 0x08, 0xca, 0xbc, 0xa9, 0x1f, 0x3d, 0xdc, 0x39, 0x3c, 0x6a, 0x1e, 0x30,
0x23, 0x5e, 0x82, 0x55, 0xdf, 0x88, 0x3e, 0x31, 0xab, 0xfe, 0x26, 0x0d, 0xab, 0x23, 0xd7, 0x03,
0xdd, 0x84, 0x25, 0x01, 0xc1, 0x95, 0x99, 0x45, 0x7c, 0x7e, 0xdf, 0xe5, 0x8d, 0x12, 0x02, 0xe8,
0x0e, 0x14, 0x88, 0xac, 0x54, 0xc8, 0x2b, 0x79, 0x75, 0xbc, 0xda, 0xe2, 0xd7, 0x32, 0xa4, 0x68,
0x20, 0xc1, 0x42, 0x68, 0x70, 0xe7, 0x65, 0xb6, 0xf8, 0xc6, 0xb8, 0x78, 0xe0, 0x2d, 0xa4, 0x7c,
0x28, 0xa3, 0xee, 0xc2, 0x72, 0x64, 0x52, 0xe8, 0xff, 0xa0, 0xd8, 0xc3, 0x17, 0xb2, 0x56, 0x25,
0x4a, 0x10, 0x85, 0x1e, 0xbe, 0xe0, 0x65, 0x2a, 0xf4, 0x2a, 0xe4, 0xd9, 0xc7, 0x36, 0x16, 0xce,
0x23, 0xa3, 0xe5, 0x7a, 0xf8, 0xe2, 0x47, 0xd8, 0x53, 0x0d, 0x28, 0xc7, 0x0b, 0x39, 0xec, 0x34,
0xf5, 0x9d, 0x81, 0x6d, 0x72, 0x1d, 0x4b, 0x9a, 0xe8, 0xa0, 0xdb, 0xb0, 0x74, 0xee, 0x08, 0xdf,
0x33, 0xeb, 0xd6, 0x3d, 0x76, 0x28, 0x89, 0x94, 0x83, 0x84, 0x8c, 0xfa, 0x10, 0xca, 0xdc, 0x8b,
0xec, 0x50, 0xda, 0xb7, 0x5a, 0x03, 0x4a, 0xa2, 0x15, 0xc9, 0x95, 0x09, 0x15, 0xc9, 0x00, 0x67,
0x04, 0x28, 0x25, 0x23, 0xca, 0x61, 0xbc, 0xa3, 0xfe, 0x4a, 0x81, 0x25, 0xae, 0x90, 0xb9, 0x18,
0x5e, 0xe3, 0x91, 0x08, 0x96, 0xb5, 0x91, 0x01, 0x80, 0xfd, 0x81, 0xfc, 0xf9, 0x5e, 0x9f, 0xe5,
0xdc, 0x82, 0x69, 0x35, 0xae, 0x48, 0x2f, 0xb7, 0x1e, 0x2a, 0x88, 0x78, 0xba, 0x88, 0x5a, 0xf5,
0x99, 0x02, 0x85, 0xe3, 0x0b, 0x79, 0x42, 0xa7, 0x94, 0x7e, 0xd8, 0xec, 0xf7, 0xf9, 0xec, 0x45,
0xb1, 0x44, 0x74, 0x64, 0x2d, 0x29, 0x13, 0xd4, 0xa9, 0xee, 0x05, 0x37, 0x31, 0xbb, 0x58, 0x3a,
0xe9, 0x97, 0xf0, 0xa4, 0xdb, 0xb9, 0x0d, 0xc5, 0xe0, 0xb4, 0x30, 0x18, 0x8f, 0x4d, 0xb3, 0x4f,
0x3c, 0x4f, 0x1a, 0xd9, 0xef, 0xf2, 0x0a, 0xa3, 0xf3, 0x54, 0x96, 0x52, 0x32, 0x9a, 0xe8, 0xa8,
0x16, 0xac, 0x8e, 0x04, 0x26, 0xf4, 0x43, 0xc8, 0xbb, 0x83, 0x96, 0xee, 0xef, 0xd3, 0xc8, 0xf1,
0x94, 0x08, 0xef, 0x8c, 0x0c, 0xbd, 0xfa, 0xe1, 0xa0, 0xd5, 0xb5, 0x8c, 0xfb, 0x64, 0xe8, 0xcf,
0xc8, 0x1d, 0xb4, 0xee, 0x8b, 0x3d, 0x15, 0x43, 0xa5, 0xa3, 0x43, 0xfd, 0x12, 0x0a, 0xfe, 0x31,
0x41, 0x77, 0xa3, 0x97, 0x40, 0x19, 0xbf, 0x43, 0x93, 0xe2, 0xa6, 0x1c, 0x24, 0x14, 0x64, 0x89,
0x87, 0x67, 0xb5, 0x6d, 0x62, 0xea, 0x61, 0x4e, 0xc1, 0xc7, 0x2c, 0x68, 0xab, 0xe2, 0xc3, 0x03,
0x3f, 0xa1, 0x50, 0xff, 0xa1, 0x40, 0xc1, 0xbf, 0x93, 0x13, 0x8f, 0x4f, 0x6c, 0x4a, 0xe9, 0xef,
0x3a, 0xa5, 0x69, 0xf5, 0x5d, 0xbf, 0x9a, 0x9e, 0x5d, 0xb8, 0x9a, 0x7e, 0x13, 0x10, 0x75, 0x28,
0xee, 0xea, 0xe7, 0x0e, 0xb5, 0xec, 0xb6, 0x2e, 0x2c, 0x2b, 0xf0, 0x52, 0x85, 0x7f, 0x79, 0xcc,
0x3f, 0x1c, 0x72, 0x23, 0xff, 0x5a, 0x81, 0x42, 0x10, 0xdd, 0x16, 0xad, 0xe6, 0x5d, 0x86, 0x9c,
0xf4, 0xe0, 0xa2, 0x9c, 0x27, 0x7b, 0x41, 0xc1, 0x39, 0x1b, 0x29, 0x38, 0xd7, 0xa0, 0xd0, 0x23,
0x14, 0xf3, 0x40, 0x2f, 0xb2, 0xb7, 0xa0, 0xff, 0xee, 0x35, 0x58, 0x8e, 0x94, 0x57, 0x51, 0x1e,
0x32, 0x0f, 0xc9, 0xd3, 0x4a, 0x0a, 0x2d, 0x43, 0x5e, 0x23, 0xbc, 0xa2, 0x52, 0x51, 0xb6, 0xbf,
0x5a, 0x86, 0xd5, 0x9d, 0xc6, 0xee, 0x3e, 0x0b, 0x30, 0x96, 0x81, 0x79, 0x66, 0x77, 0x00, 0x59,
0x9e, 0xdc, 0x26, 0x78, 0xc8, 0xad, 0x25, 0x29, 0xcf, 0x21, 0x0d, 0x96, 0x78, 0x0e, 0x8c, 0x92,
0xbc, 0xef, 0xd6, 0x12, 0x55, 0xed, 0xd8, 0x24, 0xf9, 0x19, 0x4e, 0xf0, 0xec, 0x5b, 0x4b, 0x52,
0xca, 0x43, 0x9f, 0x43, 0x31, 0x4c, 0x6e, 0x93, 0x3e, 0x06, 0xd7, 0x12, 0x17, 0xf9, 0x98, 0xfe,
0x10, 0xc4, 0x27, 0x7d, 0x0a, 0xad, 0x25, 0x76, 0x47, 0xe8, 0x09, 0xe4, 0xfd, 0x74, 0x29, 0xd9,
0x73, 0x6d, 0x2d, 0x61, 0x01, 0x8e, 0x6d, 0x9f, 0xc8, 0x77, 0x93, 0xbc, 0x49, 0xd7, 0x12, 0x55,
0x19, 0xd1, 0x09, 0xe4, 0x24, 0x4e, 0x4d, 0xf4, 0x10, 0x5b, 0x4b, 0x56, 0x56, 0x63, 0x46, 0x0e,
0x2b, 0x0a, 0x49, 0xdf, 0xe1, 0x6b, 0x89, 0xcb, 0xab, 0x08, 0x03, 0x44, 0x52, 0xdf, 0xc4, 0x0f,
0xec, 0xb5, 0xe4, 0x65, 0x53, 0xf4, 0x33, 0x28, 0x04, 0x09, 0x4e, 0xc2, 0x87, 0xee, 0x5a, 0xd2,
0xca, 0x25, 0xfa, 0x02, 0x4a, 0x71, 0x4c, 0xbf, 0xc8, 0xf3, 0x75, 0x6d, 0xa1, 0x92, 0x24, 0x1b,
0x2b, 0x0e, 0xf3, 0x17, 0x79, 0xd4, 0xae, 0x2d, 0x54, 0xa7, 0x44, 0xe7, 0xb0, 0x36, 0x8e, 0xcc,
0x17, 0x7d, 0xe9, 0xae, 0x2d, 0x5c, 0xbf, 0x44, 0x43, 0x40, 0x13, 0xd0, 0xfd, 0xc2, 0xcf, 0xdf,
0xb5, 0xc5, 0x8b, 0x9a, 0x8d, 0xbd, 0xaf, 0x9f, 0x6f, 0x28, 0xdf, 0x3c, 0xdf, 0x50, 0xfe, 0xfe,
0x7c, 0x43, 0x79, 0xf6, 0x62, 0x23, 0xf5, 0xcd, 0x8b, 0x8d, 0xd4, 0x5f, 0x5f, 0x6c, 0xa4, 0x7e,
0xfa, 0x5e, 0xdb, 0xa2, 0x9d, 0x41, 0xab, 0x6e, 0x38, 0xbd, 0xad, 0xe8, 0x7f, 0x7f, 0x26, 0xfd,
0x51, 0xa9, 0x95, 0xe3, 0xc1, 0xef, 0xc3, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x99, 0x3b, 0x6a,
0xd0, 0xc8, 0x24, 0x00, 0x00,
0x28, 0x83, 0x6e, 0x85, 0x48, 0x2d, 0x3b, 0x5e, 0x16, 0x90, 0xe2, 0x82, 0x41, 0x0a, 0xfb, 0xfc,
0xea, 0x2e, 0x2c, 0x47, 0xd6, 0x83, 0xfe, 0x0f, 0x8a, 0x3d, 0x7c, 0x21, 0xcb, 0x5c, 0xa2, 0x7a,
0x51, 0xe8, 0xe1, 0x0b, 0x5e, 0xe1, 0x42, 0xaf, 0x42, 0x9e, 0x7d, 0x6c, 0x63, 0xe1, 0x77, 0x32,
0x5a, 0xae, 0x87, 0x2f, 0x7e, 0x84, 0x3d, 0xd5, 0x80, 0x72, 0xbc, 0x06, 0xc4, 0x0e, 0x62, 0xdf,
0x19, 0xd8, 0x26, 0xd7, 0xb1, 0xa4, 0x89, 0x0e, 0xba, 0x0d, 0x4b, 0xe7, 0x8e, 0x70, 0x5b, 0xb3,
0x2e, 0xec, 0x63, 0x87, 0x92, 0x48, 0x25, 0x49, 0xc8, 0xa8, 0x0f, 0xa1, 0xcc, 0x1d, 0xd0, 0x0e,
0xa5, 0x7d, 0xab, 0x35, 0xa0, 0x24, 0x5a, 0xcc, 0x5c, 0x99, 0x50, 0xcc, 0x0c, 0x20, 0x4a, 0x00,
0x70, 0x32, 0xa2, 0x92, 0xc6, 0x3b, 0xea, 0xaf, 0x14, 0x58, 0xe2, 0x0a, 0x99, 0x77, 0xe2, 0xe5,
0x21, 0x09, 0x7e, 0x59, 0x1b, 0x19, 0x00, 0xd8, 0x1f, 0xc8, 0x9f, 0xef, 0xf5, 0x59, 0x7e, 0x31,
0x98, 0x56, 0xe3, 0x8a, 0x74, 0x90, 0xeb, 0xa1, 0x82, 0x88, 0x93, 0x8c, 0xa8, 0x55, 0x9f, 0x29,
0x50, 0x38, 0xbe, 0x90, 0x87, 0x7b, 0x4a, 0xd5, 0x88, 0xcd, 0x7e, 0x9f, 0xcf, 0x5e, 0xd4, 0x59,
0x44, 0x47, 0x96, 0xa1, 0x32, 0x41, 0x89, 0xeb, 0x5e, 0x70, 0x89, 0xb3, 0x8b, 0x65, 0xa2, 0x7e,
0xf5, 0x4f, 0x7a, 0xac, 0xdb, 0x50, 0x0c, 0x0e, 0x1a, 0xcb, 0x00, 0xb0, 0x69, 0xf6, 0x89, 0xe7,
0x49, 0x23, 0xfb, 0x5d, 0x5e, 0x9c, 0x74, 0x9e, 0xca, 0x2a, 0x4c, 0x46, 0x13, 0x1d, 0xd5, 0x82,
0xd5, 0x91, 0x98, 0x86, 0x7e, 0x08, 0x79, 0x77, 0xd0, 0xd2, 0xfd, 0x7d, 0x1a, 0x39, 0xd9, 0x12,
0x1c, 0x9e, 0x91, 0xa1, 0x57, 0x3f, 0x1c, 0xb4, 0xba, 0x96, 0x71, 0x9f, 0x0c, 0xfd, 0x19, 0xb9,
0x83, 0xd6, 0x7d, 0xb1, 0xa7, 0x62, 0xa8, 0x74, 0x74, 0xa8, 0x5f, 0x42, 0xc1, 0x3f, 0x26, 0xe8,
0x6e, 0xf4, 0xfe, 0x28, 0xe3, 0xd7, 0x6f, 0x52, 0xc8, 0x95, 0x83, 0x44, 0x2e, 0xd1, 0xbb, 0xb0,
0xe6, 0x59, 0x6d, 0x9b, 0x98, 0x7a, 0x98, 0x8e, 0xf0, 0x31, 0x0b, 0xda, 0xaa, 0xf8, 0xf0, 0xc0,
0xcf, 0x45, 0xd4, 0x7f, 0x28, 0x50, 0xf0, 0xaf, 0xf3, 0xc4, 0xe3, 0x13, 0x9b, 0x52, 0xfa, 0xbb,
0x4e, 0x69, 0x5a, 0x69, 0xd8, 0x2f, 0xc4, 0x67, 0x17, 0x2e, 0xc4, 0xbf, 0x0f, 0x88, 0x3a, 0x14,
0x77, 0xf5, 0x73, 0x87, 0x5a, 0x76, 0x5b, 0x17, 0x96, 0x15, 0x50, 0xab, 0xc2, 0xbf, 0x3c, 0xe6,
0x1f, 0x0e, 0xb9, 0x91, 0x7f, 0xad, 0x40, 0x21, 0x08, 0x8c, 0x8b, 0x16, 0x02, 0x2f, 0x43, 0x4e,
0x3a, 0x7f, 0x51, 0x09, 0x94, 0xbd, 0xa0, 0x56, 0x9d, 0x8d, 0xd4, 0xaa, 0x6b, 0x50, 0xe8, 0x11,
0x8a, 0x39, 0x46, 0x10, 0x89, 0x5f, 0xd0, 0x7f, 0xf7, 0x1a, 0x2c, 0x47, 0x2a, 0xb3, 0x28, 0x0f,
0x99, 0x87, 0xe4, 0x69, 0x25, 0x85, 0x96, 0x21, 0xaf, 0x11, 0x5e, 0x8c, 0xa9, 0x28, 0xdb, 0x5f,
0x2d, 0xc3, 0xea, 0x4e, 0x63, 0x77, 0x9f, 0xc5, 0x26, 0xcb, 0xc0, 0x3c, 0x29, 0x3c, 0x80, 0x2c,
0xcf, 0x8b, 0x13, 0xbc, 0x01, 0xd7, 0x92, 0x54, 0xf6, 0x90, 0x06, 0x4b, 0x3c, 0x7d, 0x46, 0x49,
0x9e, 0x86, 0x6b, 0x89, 0x0a, 0x7e, 0x6c, 0x92, 0xfc, 0x0c, 0x27, 0x78, 0x31, 0xae, 0x25, 0xa9,
0x02, 0xa2, 0xcf, 0xa1, 0x18, 0xe6, 0xc5, 0x49, 0xdf, 0x91, 0x6b, 0x89, 0xeb, 0x83, 0x4c, 0x7f,
0x88, 0xff, 0x93, 0xbe, 0xa2, 0xd6, 0x12, 0xbb, 0x23, 0xf4, 0x04, 0xf2, 0x7e, 0xa6, 0x95, 0xec,
0xa5, 0xb7, 0x96, 0xb0, 0x76, 0xc7, 0xb6, 0x4f, 0xa4, 0xca, 0x49, 0x9e, 0xb3, 0x6b, 0x89, 0x0a,
0x94, 0xe8, 0x04, 0x72, 0x12, 0xe2, 0x26, 0x7a, 0xc3, 0xad, 0x25, 0xab, 0xc8, 0x31, 0x23, 0x87,
0xc5, 0x88, 0xa4, 0x4f, 0xf8, 0xb5, 0xc4, 0x95, 0x59, 0x84, 0x01, 0x22, 0x59, 0x73, 0xe2, 0xb7,
0xf9, 0x5a, 0xf2, 0x8a, 0x2b, 0xfa, 0x19, 0x14, 0x82, 0xdc, 0x28, 0xe1, 0x1b, 0x79, 0x2d, 0x69,
0xd1, 0x13, 0x7d, 0x01, 0xa5, 0x78, 0x3a, 0xb0, 0xc8, 0xcb, 0x77, 0x6d, 0xa1, 0x6a, 0x26, 0x1b,
0x2b, 0x9e, 0x21, 0x2c, 0xf2, 0x1e, 0x5e, 0x5b, 0xa8, 0xc4, 0x89, 0xce, 0x61, 0x6d, 0x1c, 0xd4,
0x2f, 0xfa, 0x48, 0x5e, 0x5b, 0xb8, 0xf4, 0x89, 0x86, 0x80, 0x26, 0x24, 0x06, 0x0b, 0xbf, 0x9c,
0xd7, 0x16, 0xaf, 0x87, 0x36, 0xf6, 0xbe, 0x7e, 0xbe, 0xa1, 0x7c, 0xf3, 0x7c, 0x43, 0xf9, 0xfb,
0xf3, 0x0d, 0xe5, 0xd9, 0x8b, 0x8d, 0xd4, 0x37, 0x2f, 0x36, 0x52, 0x7f, 0x7d, 0xb1, 0x91, 0xfa,
0xe9, 0x7b, 0x6d, 0x8b, 0x76, 0x06, 0xad, 0xba, 0xe1, 0xf4, 0xb6, 0xa2, 0x7f, 0x1b, 0x9a, 0xf4,
0x1f, 0xa7, 0x56, 0x8e, 0x07, 0xbf, 0x8f, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x61, 0x0b, 0xa4,
0x73, 0x03, 0x25, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -5962,6 +5971,18 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.Version != nil {
{
size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
if m.Validator != nil {
{
size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
@ -6358,12 +6379,12 @@ func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x28
}
n48, err48 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err48 != nil {
return 0, err48
n49, err49 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
if err49 != nil {
return 0, err49
}
i -= n48
i = encodeVarintTypes(dAtA, i, uint64(n48))
i -= n49
i = encodeVarintTypes(dAtA, i, uint64(n49))
i--
dAtA[i] = 0x22
if m.Height != 0 {
@ -7459,6 +7480,10 @@ func (m *ConsensusParams) Size() (n int) {
l = m.Validator.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.Version != nil {
l = m.Version.Size()
n += 1 + l + sovTypes(uint64(l))
}
return n
}
@ -12974,6 +12999,42 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Version == nil {
m.Version = &types1.VersionParams{}
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])


+ 3
- 3
consensus/replay.go View File

@ -253,10 +253,9 @@ func (h *Handshaker) Handshake(proxyApp proxy.AppConns) error {
"protocol-version", res.AppVersion,
)
// Set AppVersion on the state.
if h.initialState.Version.Consensus.App != res.AppVersion {
// Only set the version if we're starting from zero.
if h.initialState.LastBlockHeight == 0 {
h.initialState.Version.Consensus.App = res.AppVersion
sm.SaveState(h.stateDB, h.initialState)
}
// Replay blocks up to the latest in the blockstore.
@ -331,6 +330,7 @@ func (h *Handshaker) ReplayBlocks(
if res.ConsensusParams != nil {
state.ConsensusParams = types.UpdateConsensusParams(state.ConsensusParams, res.ConsensusParams)
state.Version.Consensus.App = state.ConsensusParams.Version.AppVersion
}
sm.SaveState(h.stateDB, state)
}


+ 1
- 0
proto/tendermint/abci/types/types.proto View File

@ -281,6 +281,7 @@ message ConsensusParams {
BlockParams block = 1;
tendermint.types.EvidenceParams evidence = 2;
tendermint.types.ValidatorParams validator = 3;
tendermint.types.VersionParams version = 4;
}
// BlockParams contains limits on the block size.


+ 1
- 3
proto/tendermint/consensus/walmsgs.pb.go View File

@ -369,9 +369,7 @@ func init() {
proto.RegisterType((*TimedWALMessage)(nil), "tendermint.consensus.TimedWALMessage")
}
func init() {
proto.RegisterFile("tendermint/consensus/walmsgs.proto", fileDescriptor_ba295fe8d98f7e98)
}
func init() { proto.RegisterFile("tendermint/consensus/walmsgs.proto", fileDescriptor_ba295fe8d98f7e98) }
var fileDescriptor_ba295fe8d98f7e98 = []byte{
// 542 bytes of a gzipped FileDescriptorProto


+ 1
- 3
proto/tendermint/crypto/keys/types.pb.go View File

@ -178,9 +178,7 @@ func init() {
proto.RegisterType((*PrivateKey)(nil), "tendermint.crypto.keys.PrivateKey")
}
func init() {
proto.RegisterFile("tendermint/crypto/keys/types.proto", fileDescriptor_6e4a90a3275dcf41)
}
func init() { proto.RegisterFile("tendermint/crypto/keys/types.proto", fileDescriptor_6e4a90a3275dcf41) }
var fileDescriptor_6e4a90a3275dcf41 = []byte{
// 205 bytes of a gzipped FileDescriptorProto


+ 289
- 40
proto/tendermint/types/params.pb.go View File

@ -33,6 +33,7 @@ type ConsensusParams struct {
Block BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block"`
Evidence EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence"`
Validator ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator"`
Version VersionParams `protobuf:"bytes,4,opt,name=version,proto3" json:"version"`
}
func (m *ConsensusParams) Reset() { *m = ConsensusParams{} }
@ -89,6 +90,13 @@ func (m *ConsensusParams) GetValidator() ValidatorParams {
return ValidatorParams{}
}
func (m *ConsensusParams) GetVersion() VersionParams {
if m != nil {
return m.Version
}
return VersionParams{}
}
// BlockParams contains limits on the block size.
type BlockParams struct {
// Note: must be greater than 0
@ -285,6 +293,51 @@ func (m *ValidatorParams) GetPubKeyTypes() []string {
return nil
}
// VersionParams contains the ABCI application version.
type VersionParams struct {
AppVersion uint64 `protobuf:"varint,1,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"`
}
func (m *VersionParams) Reset() { *m = VersionParams{} }
func (m *VersionParams) String() string { return proto.CompactTextString(m) }
func (*VersionParams) ProtoMessage() {}
func (*VersionParams) Descriptor() ([]byte, []int) {
return fileDescriptor_e12598271a686f57, []int{4}
}
func (m *VersionParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *VersionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_VersionParams.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *VersionParams) XXX_Merge(src proto.Message) {
xxx_messageInfo_VersionParams.Merge(m, src)
}
func (m *VersionParams) XXX_Size() int {
return m.Size()
}
func (m *VersionParams) XXX_DiscardUnknown() {
xxx_messageInfo_VersionParams.DiscardUnknown(m)
}
var xxx_messageInfo_VersionParams proto.InternalMessageInfo
func (m *VersionParams) GetAppVersion() uint64 {
if m != nil {
return m.AppVersion
}
return 0
}
// HashedParams is a subset of ConsensusParams.
// It is amino encoded and hashed into
// the Header.ConsensusHash.
@ -297,7 +350,7 @@ func (m *HashedParams) Reset() { *m = HashedParams{} }
func (m *HashedParams) String() string { return proto.CompactTextString(m) }
func (*HashedParams) ProtoMessage() {}
func (*HashedParams) Descriptor() ([]byte, []int) {
return fileDescriptor_e12598271a686f57, []int{4}
return fileDescriptor_e12598271a686f57, []int{5}
}
func (m *HashedParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -345,46 +398,50 @@ func init() {
proto.RegisterType((*BlockParams)(nil), "tendermint.types.BlockParams")
proto.RegisterType((*EvidenceParams)(nil), "tendermint.types.EvidenceParams")
proto.RegisterType((*ValidatorParams)(nil), "tendermint.types.ValidatorParams")
proto.RegisterType((*VersionParams)(nil), "tendermint.types.VersionParams")
proto.RegisterType((*HashedParams)(nil), "tendermint.types.HashedParams")
}
func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }
var fileDescriptor_e12598271a686f57 = []byte{
// 528 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x53, 0x41, 0x6f, 0xd3, 0x30,
0x14, 0xae, 0xe9, 0x18, 0x9d, 0xbb, 0xae, 0x95, 0x85, 0x44, 0x18, 0x5a, 0x5a, 0x72, 0x40, 0x93,
0x40, 0x89, 0x04, 0x07, 0x04, 0x17, 0x44, 0x60, 0x1a, 0x08, 0x75, 0x9a, 0xa2, 0xc1, 0x61, 0x17,
0xcb, 0x69, 0xbc, 0x2c, 0x5a, 0x1d, 0x47, 0xb1, 0x3d, 0xb5, 0xff, 0x82, 0x23, 0xc7, 0x1d, 0xf9,
0x09, 0xfc, 0x84, 0x1d, 0x27, 0x71, 0x80, 0x13, 0xa0, 0xf6, 0xc2, 0xcf, 0x40, 0x79, 0x69, 0xc8,
0xda, 0xdd, 0xec, 0xf7, 0x7d, 0xef, 0xf3, 0xf7, 0xde, 0x27, 0xe3, 0x1d, 0xcd, 0xd3, 0x88, 0xe7,
0x22, 0x49, 0xb5, 0xa7, 0xa7, 0x19, 0x57, 0x5e, 0xc6, 0x72, 0x26, 0x94, 0x9b, 0xe5, 0x52, 0x4b,
0xd2, 0xab, 0x61, 0x17, 0xe0, 0xed, 0xbb, 0xb1, 0x8c, 0x25, 0x80, 0x5e, 0x71, 0x2a, 0x79, 0xdb,
0x76, 0x2c, 0x65, 0x3c, 0xe6, 0x1e, 0xdc, 0x42, 0x73, 0xe2, 0x45, 0x26, 0x67, 0x3a, 0x91, 0x69,
0x89, 0x3b, 0x3f, 0x10, 0xee, 0xbe, 0x91, 0xa9, 0xe2, 0xa9, 0x32, 0xea, 0x10, 0x5e, 0x20, 0x2f,
0xf0, 0xed, 0x70, 0x2c, 0x47, 0x67, 0x16, 0x1a, 0xa0, 0xdd, 0xf6, 0xd3, 0x1d, 0x77, 0xf5, 0x2d,
0xd7, 0x2f, 0xe0, 0x92, 0xed, 0xaf, 0x5d, 0xfe, 0xea, 0x37, 0x82, 0xb2, 0x83, 0xf8, 0xb8, 0xc5,
0xcf, 0x93, 0x88, 0xa7, 0x23, 0x6e, 0xdd, 0x82, 0xee, 0xc1, 0xcd, 0xee, 0xbd, 0x05, 0x63, 0x49,
0xe0, 0x7f, 0x1f, 0xd9, 0xc3, 0x1b, 0xe7, 0x6c, 0x9c, 0x44, 0x4c, 0xcb, 0xdc, 0x6a, 0x82, 0xc8,
0xc3, 0x9b, 0x22, 0x9f, 0x2a, 0xca, 0x92, 0x4a, 0xdd, 0xe9, 0x70, 0xdc, 0xbe, 0x66, 0x93, 0x3c,
0xc0, 0x1b, 0x82, 0x4d, 0x68, 0x38, 0xd5, 0x5c, 0xc1, 0x60, 0xcd, 0xa0, 0x25, 0xd8, 0xc4, 0x2f,
0xee, 0xe4, 0x1e, 0xbe, 0x53, 0x80, 0x31, 0x53, 0xe0, 0xba, 0x19, 0xac, 0x0b, 0x36, 0xd9, 0x67,
0x8a, 0x0c, 0xf0, 0xa6, 0x4e, 0x04, 0xa7, 0x89, 0xd4, 0x8c, 0x0a, 0x05, 0x76, 0x9a, 0x01, 0x2e,
0x6a, 0xef, 0xa5, 0x66, 0x43, 0xe5, 0x7c, 0x47, 0x78, 0x6b, 0x79, 0x20, 0xf2, 0x18, 0x93, 0x42,
0x8d, 0xc5, 0x9c, 0xa6, 0x46, 0x50, 0xd8, 0x4c, 0xf5, 0x66, 0x57, 0xb0, 0xc9, 0xeb, 0x98, 0x1f,
0x18, 0x01, 0xe6, 0x14, 0x19, 0xe2, 0x5e, 0x45, 0xae, 0xa2, 0x59, 0x6c, 0xee, 0xbe, 0x5b, 0x66,
0xe7, 0x56, 0xd9, 0xb9, 0x6f, 0x17, 0x04, 0xbf, 0x55, 0x0c, 0xfb, 0xe5, 0x77, 0x1f, 0x05, 0x5b,
0xa5, 0x5e, 0x85, 0x54, 0x93, 0xa4, 0x46, 0x80, 0xd7, 0x0e, 0x4c, 0x72, 0x60, 0x04, 0x79, 0x82,
0x49, 0x96, 0x4b, 0x79, 0x42, 0x75, 0x9e, 0xb0, 0x31, 0xcd, 0x78, 0x9e, 0xc8, 0xc8, 0x5a, 0x03,
0x53, 0x3d, 0x40, 0x8e, 0x0a, 0xe0, 0x10, 0xea, 0xce, 0x2b, 0xdc, 0x5d, 0x59, 0x30, 0x71, 0x70,
0x27, 0x33, 0x21, 0x3d, 0xe3, 0x53, 0x0a, 0x09, 0x58, 0x68, 0xd0, 0xdc, 0xdd, 0x08, 0xda, 0x99,
0x09, 0x3f, 0xf0, 0xe9, 0x51, 0x51, 0x7a, 0xd9, 0xfa, 0x76, 0xd1, 0x47, 0x7f, 0x2f, 0xfa, 0xc8,
0x39, 0xc6, 0x9b, 0xef, 0x98, 0x3a, 0xe5, 0xd1, 0xa2, 0xfb, 0x11, 0xee, 0xc2, 0x1e, 0xe8, 0x6a,
0x08, 0x1d, 0x28, 0x0f, 0xab, 0x24, 0x1c, 0xdc, 0xa9, 0x79, 0x75, 0x1e, 0xed, 0x8a, 0xb5, 0xcf,
0x94, 0xff, 0xf1, 0xeb, 0xcc, 0x46, 0x97, 0x33, 0x1b, 0x5d, 0xcd, 0x6c, 0xf4, 0x67, 0x66, 0xa3,
0xcf, 0x73, 0xbb, 0x71, 0x35, 0xb7, 0x1b, 0x3f, 0xe7, 0x76, 0xe3, 0xf8, 0x79, 0x9c, 0xe8, 0x53,
0x13, 0xba, 0x23, 0x29, 0xbc, 0xeb, 0x7f, 0xa8, 0x3e, 0x96, 0x9f, 0x64, 0xf5, 0x7f, 0x85, 0xeb,
0x50, 0x7f, 0xf6, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x47, 0xb8, 0x4b, 0xd4, 0x7a, 0x03, 0x00, 0x00,
// 572 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x53, 0xcd, 0x6e, 0xd3, 0x4c,
0x14, 0x8d, 0xeb, 0x7e, 0x6d, 0x7a, 0xd3, 0x34, 0xd1, 0xe8, 0x93, 0x08, 0x45, 0xb5, 0x83, 0x17,
0xa8, 0x12, 0xc8, 0x96, 0x60, 0x81, 0xe8, 0xa6, 0xc2, 0x50, 0x15, 0x84, 0x52, 0x55, 0x56, 0x61,
0xd1, 0x8d, 0x35, 0x8e, 0xa7, 0xae, 0xd5, 0x8c, 0x67, 0xe4, 0x19, 0x47, 0xc9, 0x5b, 0xb0, 0xec,
0xb2, 0x4b, 0x1e, 0x81, 0x47, 0xe8, 0xb2, 0x12, 0x1b, 0x56, 0x80, 0x92, 0x0d, 0x8f, 0x81, 0x3c,
0xce, 0x90, 0x9f, 0xb2, 0xb3, 0xef, 0xf9, 0x99, 0xb9, 0xe7, 0x68, 0x60, 0x4f, 0x92, 0x2c, 0x26,
0x39, 0x4d, 0x33, 0xe9, 0xc9, 0x31, 0x27, 0xc2, 0xe3, 0x38, 0xc7, 0x54, 0xb8, 0x3c, 0x67, 0x92,
0xa1, 0xf6, 0x1c, 0x76, 0x15, 0xbc, 0xfb, 0x7f, 0xc2, 0x12, 0xa6, 0x40, 0xaf, 0xfc, 0xaa, 0x78,
0xbb, 0x56, 0xc2, 0x58, 0x32, 0x20, 0x9e, 0xfa, 0x8b, 0x8a, 0x0b, 0x2f, 0x2e, 0x72, 0x2c, 0x53,
0x96, 0x55, 0xb8, 0x73, 0xbd, 0x06, 0xad, 0x37, 0x2c, 0x13, 0x24, 0x13, 0x85, 0x38, 0x55, 0x27,
0xa0, 0x57, 0xf0, 0x5f, 0x34, 0x60, 0xfd, 0xab, 0x8e, 0xd1, 0x35, 0xf6, 0x1b, 0xcf, 0xf7, 0xdc,
0xd5, 0xb3, 0x5c, 0xbf, 0x84, 0x2b, 0xb6, 0xbf, 0x7e, 0xfb, 0xc3, 0xae, 0x05, 0x95, 0x02, 0xf9,
0x50, 0x27, 0xc3, 0x34, 0x26, 0x59, 0x9f, 0x74, 0xd6, 0x94, 0xba, 0x7b, 0x5f, 0x7d, 0x34, 0x63,
0x2c, 0x19, 0xfc, 0xd5, 0xa1, 0x23, 0xd8, 0x1a, 0xe2, 0x41, 0x1a, 0x63, 0xc9, 0xf2, 0x8e, 0xa9,
0x4c, 0x1e, 0xdf, 0x37, 0xf9, 0xa4, 0x29, 0x4b, 0x2e, 0x73, 0x25, 0x3a, 0x84, 0xcd, 0x21, 0xc9,
0x45, 0xca, 0xb2, 0xce, 0xba, 0x32, 0xb1, 0xff, 0x61, 0x52, 0x11, 0x96, 0x2c, 0xb4, 0xca, 0x21,
0xd0, 0x58, 0xd8, 0x13, 0x3d, 0x82, 0x2d, 0x8a, 0x47, 0x61, 0x34, 0x96, 0x44, 0xa8, 0x64, 0xcc,
0xa0, 0x4e, 0xf1, 0xc8, 0x2f, 0xff, 0xd1, 0x03, 0xd8, 0x2c, 0xc1, 0x04, 0x0b, 0xb5, 0xb6, 0x19,
0x6c, 0x50, 0x3c, 0x3a, 0xc6, 0x02, 0x75, 0x61, 0x5b, 0xa6, 0x94, 0x84, 0x29, 0x93, 0x38, 0xa4,
0x42, 0xed, 0x63, 0x06, 0x50, 0xce, 0xde, 0x33, 0x89, 0x7b, 0xc2, 0xf9, 0x66, 0xc0, 0xce, 0x72,
0x22, 0xe8, 0x29, 0xa0, 0xd2, 0x0d, 0x27, 0x24, 0xcc, 0x0a, 0x1a, 0xaa, 0x68, 0xf5, 0x99, 0x2d,
0x8a, 0x47, 0xaf, 0x13, 0x72, 0x52, 0x50, 0x75, 0x39, 0x81, 0x7a, 0xd0, 0xd6, 0x64, 0xdd, 0xed,
0x2c, 0xfa, 0x87, 0x6e, 0x55, 0xbe, 0xab, 0xcb, 0x77, 0xdf, 0xce, 0x08, 0x7e, 0xbd, 0x5c, 0xf5,
0xfa, 0xa7, 0x6d, 0x04, 0x3b, 0x95, 0x9f, 0x46, 0xf4, 0x26, 0x59, 0x41, 0xd5, 0x5d, 0x9b, 0x6a,
0x93, 0x93, 0x82, 0xa2, 0x67, 0x80, 0x78, 0xce, 0xd8, 0x45, 0x28, 0xf3, 0x14, 0x0f, 0x42, 0x4e,
0xf2, 0x94, 0xc5, 0x2a, 0x5a, 0x33, 0x68, 0x2b, 0xe4, 0xac, 0x04, 0x4e, 0xd5, 0xdc, 0x39, 0x84,
0xd6, 0x4a, 0x43, 0xc8, 0x81, 0x26, 0x2f, 0xa2, 0xf0, 0x8a, 0x8c, 0x43, 0x95, 0x7e, 0xc7, 0xe8,
0x9a, 0xfb, 0x5b, 0x41, 0x83, 0x17, 0xd1, 0x07, 0x32, 0x3e, 0x2b, 0x47, 0x07, 0xf5, 0xaf, 0x37,
0xb6, 0xf1, 0xfb, 0xc6, 0x36, 0x9c, 0x03, 0x68, 0x2e, 0xb5, 0x83, 0x6c, 0x68, 0x60, 0xce, 0x43,
0xdd, 0x69, 0x99, 0xc6, 0x7a, 0x00, 0x98, 0xf3, 0x19, 0x6d, 0x41, 0x7b, 0x0e, 0xdb, 0xef, 0xb0,
0xb8, 0x24, 0xf1, 0x4c, 0xfa, 0x04, 0x5a, 0x2a, 0xc3, 0x70, 0xb5, 0xc0, 0xa6, 0x1a, 0xf7, 0x74,
0x8b, 0x0e, 0x34, 0xe7, 0xbc, 0x79, 0x97, 0x0d, 0xcd, 0x3a, 0xc6, 0xc2, 0xff, 0xf8, 0x65, 0x62,
0x19, 0xb7, 0x13, 0xcb, 0xb8, 0x9b, 0x58, 0xc6, 0xaf, 0x89, 0x65, 0x7c, 0x9e, 0x5a, 0xb5, 0xbb,
0xa9, 0x55, 0xfb, 0x3e, 0xb5, 0x6a, 0xe7, 0x2f, 0x93, 0x54, 0x5e, 0x16, 0x91, 0xdb, 0x67, 0xd4,
0x5b, 0x7c, 0xc0, 0xf3, 0xcf, 0xea, 0x85, 0xae, 0x3e, 0xee, 0x68, 0x43, 0xcd, 0x5f, 0xfc, 0x09,
0x00, 0x00, 0xff, 0xff, 0xf4, 0xdd, 0x09, 0xef, 0xf7, 0x03, 0x00, 0x00,
}
func (this *ConsensusParams) Equal(that interface{}) bool {
@ -415,6 +472,9 @@ func (this *ConsensusParams) Equal(that interface{}) bool {
if !this.Validator.Equal(&that1.Validator) {
return false
}
if !this.Version.Equal(&that1.Version) {
return false
}
return true
}
func (this *BlockParams) Equal(that interface{}) bool {
@ -509,6 +569,30 @@ func (this *ValidatorParams) Equal(that interface{}) bool {
}
return true
}
func (this *VersionParams) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*VersionParams)
if !ok {
that2, ok := that.(VersionParams)
if ok {
that1 = &that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if this.AppVersion != that1.AppVersion {
return false
}
return true
}
func (this *HashedParams) Equal(that interface{}) bool {
if that == nil {
return this == nil
@ -556,6 +640,16 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
{
size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
{
size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
@ -657,12 +751,12 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
n4, err4 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
if err4 != nil {
return 0, err4
n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
if err5 != nil {
return 0, err5
}
i -= n4
i = encodeVarintParams(dAtA, i, uint64(n4))
i -= n5
i = encodeVarintParams(dAtA, i, uint64(n5))
i--
dAtA[i] = 0x12
if m.MaxAgeNumBlocks != 0 {
@ -705,6 +799,34 @@ func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *VersionParams) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *VersionParams) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *VersionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.AppVersion != 0 {
i = encodeVarintParams(dAtA, i, uint64(m.AppVersion))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *HashedParams) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -761,6 +883,14 @@ func NewPopulatedValidatorParams(r randyParams, easy bool) *ValidatorParams {
return this
}
func NewPopulatedVersionParams(r randyParams, easy bool) *VersionParams {
this := &VersionParams{}
this.AppVersion = uint64(uint64(r.Uint32()))
if !easy && r.Intn(10) != 0 {
}
return this
}
type randyParams interface {
Float32() float32
Float64() float64
@ -845,6 +975,8 @@ func (m *ConsensusParams) Size() (n int) {
n += 1 + l + sovParams(uint64(l))
l = m.Validator.Size()
n += 1 + l + sovParams(uint64(l))
l = m.Version.Size()
n += 1 + l + sovParams(uint64(l))
return n
}
@ -901,6 +1033,18 @@ func (m *ValidatorParams) Size() (n int) {
return n
}
func (m *VersionParams) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.AppVersion != 0 {
n += 1 + sovParams(uint64(m.AppVersion))
}
return n
}
func (m *HashedParams) Size() (n int) {
if m == nil {
return 0
@ -1050,6 +1194,39 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])
@ -1412,6 +1589,78 @@ func (m *ValidatorParams) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *VersionParams) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: VersionParams: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: VersionParams: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType)
}
m.AppVersion = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.AppVersion |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthParams
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthParams
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *HashedParams) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0


+ 9
- 0
proto/tendermint/types/params.proto View File

@ -14,6 +14,7 @@ message ConsensusParams {
BlockParams block = 1 [(gogoproto.nullable) = false];
EvidenceParams evidence = 2 [(gogoproto.nullable) = false];
ValidatorParams validator = 3 [(gogoproto.nullable) = false];
VersionParams version = 4 [(gogoproto.nullable) = false];
}
// BlockParams contains limits on the block size.
@ -64,6 +65,14 @@ message ValidatorParams {
repeated string pub_key_types = 1;
}
// VersionParams contains the ABCI application version.
message VersionParams {
option (gogoproto.populate) = true;
option (gogoproto.equal) = true;
uint64 app_version = 1;
}
// HashedParams is a subset of ConsensusParams.
// It is amino encoded and hashed into
// the Header.ConsensusHash.


+ 3
- 1
state/execution.go View File

@ -431,11 +431,13 @@ func updateState(
if err != nil {
return state, fmt.Errorf("error updating consensus params: %v", err)
}
state.Version.Consensus.App = nextParams.Version.AppVersion
// Change results from this height but only applies to the next height.
lastHeightParamsChanged = header.Height + 1
}
// TODO: allow app to upgrade version
nextVersion := state.Version
// NOTE: the AppHash has not been populated.


+ 3
- 5
state/execution_test.go View File

@ -8,7 +8,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/abci/example/kvstore"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/ed25519"
cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
@ -28,8 +27,7 @@ var (
)
func TestApplyBlock(t *testing.T) {
app := kvstore.NewApplication()
app.RetainBlocks = 1
app := &testApp{}
cc := proxy.NewLocalClientCreator(app)
proxyApp := proxy.NewAppConns(cc)
err := proxyApp.Start()
@ -44,11 +42,12 @@ func TestApplyBlock(t *testing.T) {
block := makeBlock(state, 1)
blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()}
_, retainHeight, err := blockExec.ApplyBlock(state, blockID, block)
state, retainHeight, err := blockExec.ApplyBlock(state, blockID, block)
require.Nil(t, err)
assert.EqualValues(t, retainHeight, 1)
// TODO check state and mempool
assert.EqualValues(t, 1, state.Version.Consensus.App, "App version wasn't updated")
}
// TestBeginBlockValidators ensures we send absent validators list.
@ -402,5 +401,4 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
assert.NotPanics(t, func() { state, _, err = blockExec.ApplyBlock(state, blockID, block) })
assert.NotNil(t, err)
assert.NotEmpty(t, state.NextValidators.Validators)
}

+ 6
- 22
state/helpers_test.go View File

@ -145,26 +145,6 @@ func genValSet(size int) *types.ValidatorSet {
return types.NewValidatorSet(vals)
}
func makeConsensusParams(
blockBytes, blockGas int64,
blockTimeIotaMs int64,
evidenceAge int64,
maxNumEvidence uint32,
) tmproto.ConsensusParams {
return tmproto.ConsensusParams{
Block: tmproto.BlockParams{
MaxBytes: blockBytes,
MaxGas: blockGas,
TimeIotaMs: blockTimeIotaMs,
},
Evidence: tmproto.EvidenceParams{
MaxAgeNumBlocks: evidenceAge,
MaxAgeDuration: time.Duration(evidenceAge),
MaxNum: maxNumEvidence,
},
}
}
func makeHeaderPartsResponsesValPubKeyChange(
state sm.State,
pubkey crypto.PubKey,
@ -266,7 +246,11 @@ func (app *testApp) BeginBlock(req abci.RequestBeginBlock) abci.ResponseBeginBlo
}
func (app *testApp) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlock {
return abci.ResponseEndBlock{ValidatorUpdates: app.ValidatorUpdates}
return abci.ResponseEndBlock{
ValidatorUpdates: app.ValidatorUpdates,
ConsensusParamUpdates: &abci.ConsensusParams{
Version: &tmproto.VersionParams{
AppVersion: 1}}}
}
func (app *testApp) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx {
@ -278,7 +262,7 @@ func (app *testApp) CheckTx(req abci.RequestCheckTx) abci.ResponseCheckTx {
}
func (app *testApp) Commit() abci.ResponseCommit {
return abci.ResponseCommit{}
return abci.ResponseCommit{RetainHeight: 1}
}
func (app *testApp) Query(reqQuery abci.RequestQuery) (resQuery abci.ResponseQuery) {


+ 0
- 36
state/state_test.go View File

@ -7,7 +7,6 @@ import (
"math/big"
"os"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -1029,41 +1028,6 @@ func TestConsensusParamsChangesSaveLoad(t *testing.T) {
}
}
func TestApplyUpdates(t *testing.T) {
initParams := makeConsensusParams(1, 2, 3, 4, 5)
const maxAge int64 = 66
cases := [...]struct {
init tmproto.ConsensusParams
updates abci.ConsensusParams
expected tmproto.ConsensusParams
}{
0: {initParams, abci.ConsensusParams{}, initParams},
1: {initParams, abci.ConsensusParams{}, initParams},
2: {initParams,
abci.ConsensusParams{
Block: &abci.BlockParams{
MaxBytes: 44,
MaxGas: 55,
},
},
makeConsensusParams(44, 55, 3, 4, 5)},
3: {initParams,
abci.ConsensusParams{
Evidence: &tmproto.EvidenceParams{
MaxAgeNumBlocks: maxAge,
MaxAgeDuration: time.Duration(maxAge),
MaxNum: 10,
},
},
makeConsensusParams(1, 2, 3, maxAge, 10)},
}
for i, tc := range cases {
res := types.UpdateConsensusParams(tc.init, &(tc.updates))
assert.Equal(t, tc.expected, res, "case %d", i)
}
}
func TestStateProto(t *testing.T) {
tearDown, _, state := setupTestCase(t)
defer tearDown(t)


+ 2
- 2
state/validation_test.go View File

@ -46,9 +46,9 @@ func TestValidateBlockHeader(t *testing.T) {
// some bad values
wrongHash := tmhash.Sum([]byte("this hash is wrong"))
wrongVersion1 := state.Version.Consensus
wrongVersion1.Block++
wrongVersion1.Block += 2
wrongVersion2 := state.Version.Consensus
wrongVersion2.App++
wrongVersion2.App += 2
// Manipulation of any header field causes failure.
testCases := []struct {


+ 10
- 0
types/params.go View File

@ -30,6 +30,7 @@ func DefaultConsensusParams() *tmproto.ConsensusParams {
Block: DefaultBlockParams(),
Evidence: DefaultEvidenceParams(),
Validator: DefaultValidatorParams(),
Version: DefaultVersionParams(),
}
}
@ -60,6 +61,12 @@ func DefaultValidatorParams() tmproto.ValidatorParams {
}
}
func DefaultVersionParams() tmproto.VersionParams {
return tmproto.VersionParams{
AppVersion: 0,
}
}
func IsValidPubkeyType(params tmproto.ValidatorParams, pubkeyType string) bool {
for i := 0; i < len(params.PubKeyTypes); i++ {
if params.PubKeyTypes[i] == pubkeyType {
@ -182,5 +189,8 @@ func UpdateConsensusParams(params tmproto.ConsensusParams, params2 *abci.Consens
// This avoids having to initialize the slice to 0 values, and then write to it again.
res.Validator.PubKeyTypes = append([]string{}, params2.Validator.PubKeyTypes...)
}
if params2.Version != nil {
res.Version.AppVersion = params2.Version.AppVersion
}
return res
}

+ 11
- 0
types/params_test.go View File

@ -138,3 +138,14 @@ func TestConsensusParamsUpdate(t *testing.T) {
assert.Equal(t, tc.updatedParams, UpdateConsensusParams(tc.params, tc.updates))
}
}
func TestConsensusParamsUpdate_AppVersion(t *testing.T) {
params := makeParams(1, 2, 10, 3, 0, valEd25519)
assert.EqualValues(t, 0, params.Version.AppVersion)
updated := UpdateConsensusParams(params,
&abci.ConsensusParams{Version: &tmproto.VersionParams{AppVersion: 1}})
assert.EqualValues(t, 1, updated.Version.AppVersion)
}

Write Preview
Loading…
Cancel
Save