mirror/prysm-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/prysm-pulse.git synced 2024-12-21 11:10:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Resolve Proto Lint Issues (#3044)

Browse Source 
* skip proto lint

* golang ci lint no -t flag

* regenerate protos to match schema

* move to compatibility folder

* build file compatibility

* foo
This commit is contained in:
Raul Jordan 2019-07-22 14:10:17 -05:00 committed by GitHub
parent d5dcc25472
commit 8cfbf0309d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 390 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -12,7 +12,7 @@ matrix:
- go get ${gobuild_args} -t ./...
- go get ${gobuild_args} github.com/golangci/golangci-lint/cmd/golangci-lint
script:
- golangci-lint run
- golangci-lint run --skip-dirs ./proto
email: false
after_success:
- wget https://raw.githubusercontent.com/k3rn31p4nic/travis-ci-discord-webhook/master/send.sh

2
proto/beacon/p2p/v1/messages.pb.go generated
View File

@ -4829,7 +4829,7 @@ func (m *FinalizedStateAnnounce) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {

186
proto/beacon/p2p/v1/types.pb.go generated
View File

@ -400,7 +400,7 @@ func (m *PendingAttestation) GetProposerIndex() uint64 {
type AttestationTarget struct {
Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
BlockRoot []byte `protobuf:"bytes,2,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"`
BeaconBlockRoot []byte `protobuf:"bytes,2,opt,name=beacon_block_root,json=beaconBlockRoot,proto3" json:"beacon_block_root,omitempty" ssz-size:"32"`
ParentRoot []byte `protobuf:"bytes,3,opt,name=parent_root,json=parentRoot,proto3" json:"parent_root,omitempty" ssz-size:"32"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -447,9 +447,9 @@ func (m *AttestationTarget) GetSlot() uint64 {
return 0
}
func (m *AttestationTarget) GetBlockRoot() []byte {
func (m *AttestationTarget) GetBeaconBlockRoot() []byte {
if m != nil {
return m.BlockRoot
return m.BeaconBlockRoot
}
return nil
}
@ -639,89 +639,89 @@ func init() {
func init() { proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_e719e7d82cfa7b0d) }
var fileDescriptor_e719e7d82cfa7b0d = []byte{
// 1299 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcb, 0x6f, 0x1b, 0x45,
0x18, 0xd7, 0x26, 0x86, 0xb6, 0x9f, 0xd3, 0xd8, 0x99, 0x54, 0xcd, 0xd2, 0x96, 0xac, 0x59, 0xd1,
0x36, 0x42, 0x8d, 0x5d, 0xbb, 0xa9, 0x9d, 0xb4, 0x3c, 0x54, 0xa7, 0x8d, 0x0a, 0x12, 0x12, 0xda,
0x96, 0x4a, 0x48, 0x88, 0xd5, 0x78, 0x77, 0xe2, 0x1d, 0xb2, 0xde, 0x59, 0xed, 0x8c, 0xad, 0xa6,
0x08, 0x71, 0xe0, 0xc4, 0x4b, 0x1c, 0xe0, 0xc6, 0x09, 0x6e, 0x3c, 0xfe, 0x01, 0xe0, 0x04, 0x27,
0x8e, 0xbc, 0x2e, 0x70, 0xb0, 0x50, 0x6f, 0xc0, 0x09, 0x1f, 0x39, 0xa1, 0x9d, 0xd9, 0x5d, 0xaf,
0xd3, 0xb8, 0x8d, 0x80, 0xdb, 0xee, 0x37, 0xbf, 0xdf, 0xef, 0x9b, 0xef, 0x31, 0x33, 0x1f, 0x18,
0x61, 0xc4, 0x04, 0xab, 0x75, 0x08, 0x76, 0x58, 0x50, 0x0b, 0x1b, 0x61, 0x6d, 0x50, 0xaf, 0x89,
0xdd, 0x90, 0xf0, 0xaa, 0x5c, 0x41, 0xc7, 0x89, 0xf0, 0x48, 0x44, 0xfa, 0xbd, 0xaa, 0xc2, 0x54,
0xc3, 0x46, 0x58, 0x1d, 0xd4, 0x4f, 0x3c, 0xae, 0x88, 0x44, 0x78, 0xb5, 0x41, 0x1d, 0xfb, 0xa1,
0x87, 0xeb, 0x35, 0x2c, 0x04, 0xe1, 0x02, 0x0b, 0x1a, 0xc3, 0xe2, 0xe5, 0x13, 0xa7, 0xf7, 0x41,
0x29, 0x1d, 0xbb, 0xe3, 0x33, 0x67, 0x27, 0x81, 0x99, 0xfb, 0xc0, 0x06, 0xd8, 0xa7, 0x2e, 0x16,
0x2c, 0x4a, 0x30, 0xab, 0x5d, 0x2a, 0xbc, 0x7e, 0xa7, 0xea, 0xb0, 0x5e, 0xad, 0xcb, 0xba, 0xac,
0x26, 0xcd, 0x9d, 0xfe, 0xb6, 0xfc, 0x53, 0x02, 0xf1, 0x97, 0x82, 0x9b, 0x1f, 0x95, 0xa0, 0xd8,
0x96, 0x9e, 0x6e, 0x08, 0x2c, 0x08, 0x32, 0x61, 0xae, 0x4b, 0x02, 0xc2, 0x29, 0xb7, 0x05, 0xed,
0x11, 0xfd, 0xf7, 0x43, 0x15, 0x6d, 0xa5, 0x60, 0x15, 0x13, 0xe3, 0x4d, 0xda, 0x23, 0x68, 0x11,
0x0a, 0xdc, 0x67, 0x42, 0xff, 0x43, 0xad, 0xc9, 0x1f, 0x54, 0x87, 0xc2, 0x36, 0x8b, 0x76, 0xf4,
0x3f, 0x63, 0x63, 0xb1, 0x71, 0xaa, 0xba, 0x7f, 0x42, 0xaa, 0x5b, 0x2c, 0xda, 0xb1, 0x24, 0x14,
0xbd, 0x04, 0x8b, 0x3e, 0x8e, 0x53, 0xa1, 0x82, 0xb4, 0x3d, 0x82, 0x5d, 0x12, 0xe9, 0x3f, 0x94,
0xa4, 0xc2, 0xca, 0x58, 0x81, 0x08, 0xaf, 0x9a, 0x06, 0x5c, 0x55, 0xbb, 0x6d, 0xc7, 0x8c, 0xeb,
0x92, 0x60, 0x2d, 0x28, 0x95, 0x9c, 0x09, 0xad, 0x43, 0x51, 0x69, 0x46, 0x8c, 0x09, 0xae, 0xff,
0x58, 0xaa, 0xcc, 0xae, 0xcc, 0xb5, 0x8f, 0x8f, 0x86, 0x06, 0xe2, 0xfc, 0xce, 0x2a, 0xa7, 0x77,
0xc8, 0x25, 0x73, 0xbd, 0xbe, 0xd1, 0x38, 0x77, 0xa1, 0x61, 0x5a, 0x20, 0xb1, 0x56, 0x0c, 0x8d,
0x99, 0x71, 0x6d, 0x48, 0xc2, 0xfc, 0xe9, 0x01, 0x4c, 0x89, 0x55, 0x4c, 0x0b, 0xca, 0x1e, 0xe5,
0x82, 0x45, 0xd4, 0xc1, 0x7e, 0x42, 0xff, 0x59, 0xd1, 0xcf, 0x8c, 0x86, 0x86, 0x39, 0xa6, 0x3f,
0x13, 0x73, 0x2b, 0xf1, 0x7f, 0x0f, 0xdf, 0xbe, 0x64, 0xd6, 0x9b, 0xad, 0x56, 0xab, 0x51, 0x6f,
0x9a, 0x56, 0x69, 0x2c, 0xa0, 0x34, 0x9f, 0x82, 0x23, 0x44, 0x78, 0x75, 0xdb, 0xc5, 0x02, 0xeb,
0x5f, 0x2e, 0xc9, 0xc4, 0x18, 0x53, 0x12, 0x73, 0x4d, 0x78, 0xf5, 0xab, 0x58, 0x60, 0xeb, 0x30,
0x49, 0xbe, 0xd0, 0xcb, 0x50, 0xca, 0xe8, 0xf6, 0x80, 0x09, 0xc2, 0xf5, 0xaf, 0x96, 0x2a, 0xb3,
0x07, 0x10, 0x69, 0xa3, 0xd1, 0xd0, 0x98, 0x1f, 0x6f, 0xf1, 0x7c, 0x63, 0xcd, 0xb4, 0x8e, 0xa6,
0xc2, 0xb7, 0x62, 0x29, 0xb4, 0x0a, 0x48, 0xa9, 0x93, 0x90, 0x71, 0x2a, 0x6c, 0x1a, 0xb8, 0xe4,
0xb6, 0xfe, 0xf5, 0x92, 0xec, 0x8a, 0xb2, 0xc4, 0xaa, 0x95, 0x67, 0xe3, 0x05, 0xf4, 0x0a, 0x40,
0xd6, 0xac, 0x5c, 0xff, 0xd8, 0x90, 0xfb, 0xa8, 0x4c, 0xd9, 0xc7, 0xad, 0x14, 0xd9, 0x3e, 0x39,
0x1a, 0x1a, 0x4b, 0xb9, 0x8d, 0x6c, 0x6c, 0x5c, 0xac, 0xd7, 0x9b, 0x8d, 0x56, 0xab, 0xd5, 0x34,
0xad, 0x9c, 0x22, 0x5a, 0x87, 0xc3, 0x1d, 0xec, 0xe3, 0xc0, 0x21, 0x5c, 0xff, 0x24, 0x56, 0x2f,
0xdc, 0x9f, 0x9b, 0xa1, 0x51, 0x45, 0xd6, 0x3c, 0x12, 0x36, 0xf7, 0x70, 0xe4, 0xea, 0x6f, 0x9d,
0x95, 0x11, 0x80, 0xb4, 0xdd, 0x88, 0x4d, 0xe8, 0x32, 0xcc, 0x45, 0x38, 0x70, 0x31, 0xb3, 0x7b,
0xf4, 0x36, 0xe1, 0xfa, 0xdb, 0x67, 0x65, 0x5d, 0x97, 0x46, 0x43, 0x63, 0x71, 0x5c, 0xd7, 0xe6,
0xc5, 0x8b, 0x17, 0x9a, 0xb2, 0x2f, 0x8a, 0x0a, 0xfd, 0x7c, 0x0c, 0x46, 0x5b, 0x80, 0xb0, 0x23,
0xe8, 0x80, 0xa8, 0x0c, 0x25, 0xad, 0xf1, 0xce, 0x03, 0x24, 0xca, 0x8a, 0x23, 0x73, 0x97, 0x36,
0x98, 0xee, 0xb0, 0x5e, 0x88, 0x1d, 0x61, 0x3b, 0xac, 0xd7, 0xa3, 0x42, 0x10, 0xc2, 0x13, 0xb5,
0x77, 0x1f, 0xa0, 0x76, 0x3c, 0x61, 0x6e, 0x66, 0x44, 0xa5, 0xd9, 0x80, 0x23, 0xdc, 0xc7, 0xdc,
0xa3, 0x41, 0x97, 0xeb, 0x7f, 0x55, 0x65, 0xd6, 0x16, 0x47, 0x43, 0xa3, 0x34, 0xd9, 0xec, 0xa6,
0x35, 0x86, 0xa1, 0x37, 0xe0, 0x64, 0x18, 0x91, 0x01, 0x65, 0x7d, 0x6e, 0x93, 0x90, 0x39, 0x9e,
0x9d, 0xbb, 0xd1, 0xb8, 0xfe, 0x4b, 0x53, 0x56, 0xf6, 0x89, 0x69, 0x37, 0xc0, 0x0b, 0x24, 0x70,
0x69, 0xd0, 0xbd, 0x32, 0xe6, 0xec, 0x69, 0x36, 0xe5, 0xf0, 0x91, 0xd4, 0xc7, 0xb5, 0xd8, 0x45,
0x0e, 0xcd, 0xd1, 0xeb, 0x70, 0xc2, 0xe9, 0x47, 0x11, 0x09, 0xc4, 0x7e, 0xfe, 0x7f, 0xfd, 0x7f,
0xfc, 0xeb, 0x89, 0x8b, 0x7b, 0xdd, 0x77, 0x61, 0x31, 0x8b, 0xdf, 0x89, 0x18, 0xe7, 0x3e, 0x0d,
0x76, 0xb8, 0xfe, 0xcd, 0xd3, 0xf7, 0xed, 0xe8, 0xcd, 0x14, 0xb9, 0x37, 0xbf, 0xea, 0x6c, 0xa1,
0x54, 0x32, 0xc3, 0x71, 0x44, 0x00, 0xa5, 0x71, 0xe6, 0xfc, 0x7c, 0xfb, 0x9f, 0xfc, 0x2c, 0x24,
0x8a, 0x39, 0x37, 0x1c, 0xd0, 0xab, 0x7d, 0x2e, 0xe8, 0x36, 0x75, 0x64, 0x84, 0x76, 0x87, 0x0a,
0xae, 0x7f, 0xba, 0x55, 0xd1, 0x56, 0xe6, 0xda, 0x9b, 0xa3, 0xa1, 0x31, 0x97, 0x13, 0x31, 0xff,
0x1e, 0x1a, 0xb5, 0xdc, 0x1b, 0x13, 0x46, 0xbb, 0xbc, 0x87, 0x05, 0x75, 0x7c, 0xdc, 0xe1, 0xb5,
0x2e, 0x5b, 0xed, 0x50, 0xb1, 0x4d, 0x89, 0xef, 0x56, 0xdb, 0x54, 0x0c, 0x88, 0x23, 0x58, 0xb4,
0x66, 0x2d, 0x4c, 0xe8, 0xb7, 0xa9, 0xe0, 0x68, 0x1b, 0x1e, 0xcd, 0x92, 0x98, 0xac, 0x12, 0xd7,
0x76, 0x3c, 0xe2, 0xec, 0x84, 0x8c, 0x06, 0x42, 0xff, 0x6c, 0x4b, 0xde, 0x76, 0x8f, 0x4d, 0x0b,
0x33, 0x43, 0x5a, 0x59, 0x37, 0x3e, 0x97, 0xea, 0x8c, 0x17, 0x91, 0x0b, 0xa7, 0xd2, 0x1c, 0xee,
0xeb, 0xe6, 0xf3, 0x03, 0xbb, 0x49, 0x7b, 0x6e, 0x3f, 0x2f, 0x2f, 0xc2, 0xb1, 0x6d, 0x1a, 0x60,
0x9f, 0xde, 0x99, 0x54, 0xff, 0xe2, 0xc0, 0xea, 0x8b, 0x19, 0x7f, 0x6c, 0x34, 0x3f, 0xd4, 0xa0,
0x10, 0x3f, 0x98, 0xe8, 0x32, 0x94, 0xb3, 0x6c, 0x0d, 0x48, 0xc4, 0x29, 0x0b, 0x74, 0x4d, 0xd6,
0xa7, 0x3c, 0x59, 0x9f, 0x35, 0xd3, 0x2a, 0xa5, 0xc8, 0x5b, 0x0a, 0x88, 0x36, 0xa0, 0x94, 0xa6,
0x20, 0xe5, 0xce, 0x4c, 0xe1, 0xce, 0x27, 0xc0, 0x94, 0x7a, 0x0c, 0x1e, 0x92, 0x27, 0x4c, 0x9f,
0x95, 0x57, 0xa2, 0xfa, 0x31, 0xdf, 0x9f, 0x01, 0x74, 0xef, 0x29, 0x42, 0x3d, 0x28, 0xe3, 0x6e,
0x37, 0x22, 0xdd, 0x5c, 0x17, 0xa9, 0x4d, 0xb6, 0x27, 0xce, 0xd7, 0xda, 0xf9, 0x8d, 0x66, 0xdc,
0x46, 0xe7, 0x0e, 0xda, 0x46, 0x3e, 0xe5, 0xc2, 0x2a, 0xe5, 0xb4, 0x65, 0x07, 0x5d, 0x82, 0x82,
0x7c, 0x16, 0x67, 0x64, 0x8a, 0xcf, 0x4c, 0x49, 0x71, 0x6e, 0x83, 0xf2, 0x71, 0x94, 0x1c, 0x74,
0x16, 0x4a, 0x34, 0x70, 0xfc, 0x7e, 0x1c, 0xa4, 0xed, 0x12, 0x1f, 0xef, 0x26, 0x11, 0xce, 0x67,
0xe6, 0xab, 0xb1, 0x15, 0x9d, 0x86, 0xf9, 0x30, 0x62, 0x21, 0xe3, 0x24, 0x4a, 0xde, 0xb7, 0x82,
0xc4, 0x1d, 0x4d, 0xad, 0xf2, 0x7e, 0x36, 0xdf, 0xd3, 0x60, 0x21, 0xe7, 0xe9, 0x26, 0x8e, 0xba,
0x44, 0x20, 0x94, 0x0c, 0x4a, 0x5a, 0x6e, 0x4e, 0x3a, 0x0f, 0x30, 0x9e, 0x4c, 0x92, 0x3a, 0x2c,
0x8c, 0x86, 0xc6, 0xd1, 0x71, 0x1d, 0xe2, 0xfb, 0xfa, 0x48, 0x36, 0x92, 0xa0, 0x06, 0x14, 0x43,
0x2c, 0xab, 0x27, 0x29, 0xb3, 0xd3, 0x28, 0xa0, 0x50, 0x31, 0xc7, 0x7c, 0x0d, 0x4e, 0xed, 0x09,
0xfc, 0x4a, 0xe0, 0x6e, 0xf6, 0xb9, 0x60, 0xee, 0x6e, 0x9b, 0x8a, 0x2c, 0x77, 0xda, 0xbf, 0xc8,
0x9d, 0x01, 0x45, 0x47, 0x29, 0xc5, 0x25, 0x96, 0x21, 0x1c, 0xb6, 0xc0, 0xc9, 0xc4, 0xcd, 0x37,
0x35, 0x28, 0x5d, 0xcf, 0x06, 0x99, 0x36, 0x16, 0x8e, 0x87, 0x5a, 0x93, 0x03, 0x99, 0x76, 0xe0,
0x79, 0xac, 0x35, 0x39, 0x8f, 0xcd, 0x1c, 0x74, 0x1c, 0x33, 0x3f, 0xd0, 0xa0, 0xbc, 0xb9, 0xe7,
0xd1, 0x43, 0x4f, 0xc2, 0xa1, 0xb0, 0xdf, 0xd9, 0x21, 0xbb, 0xe9, 0x16, 0xcc, 0xd1, 0xd0, 0x58,
0xce, 0x4f, 0x66, 0x6b, 0xeb, 0xb9, 0xc9, 0x4c, 0x76, 0xaa, 0x95, 0x52, 0xd0, 0x15, 0x40, 0xe9,
0x03, 0x9c, 0x9b, 0x64, 0x66, 0xe4, 0xa3, 0x89, 0xee, 0x6d, 0x71, 0x6b, 0x21, 0x41, 0x67, 0xc3,
0x0c, 0x6f, 0xcf, 0x7d, 0x77, 0x77, 0x59, 0xfb, 0xfe, 0xee, 0xb2, 0xf6, 0xdb, 0xdd, 0x65, 0xad,
0xf3, 0xb0, 0x1c, 0xc2, 0x2f, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0xe4, 0xf3, 0xfa, 0x56, 0x5f,
0x0c, 0x00, 0x00,
// 1307 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8f, 0xdb, 0xc4,
0x1b, 0x96, 0x77, 0xf3, 0xfb, 0xb5, 0x9d, 0x6c, 0x37, 0xc9, 0x6c, 0xd5, 0x35, 0x6d, 0x59, 0x07,
0x8b, 0xb6, 0x2b, 0xd4, 0x4d, 0x9a, 0x74, 0x9b, 0xec, 0xb6, 0x14, 0xd4, 0x6c, 0xbb, 0x2a, 0x48,
0x48, 0xc8, 0x2d, 0x95, 0x90, 0x10, 0xd6, 0xc4, 0x9e, 0xb5, 0x87, 0x75, 0x3c, 0x96, 0x67, 0x12,
0x75, 0x8b, 0x10, 0x07, 0x4e, 0x7c, 0x48, 0x1c, 0xe0, 0x04, 0x27, 0xb8, 0xf1, 0xf1, 0x0f, 0x00,
0x27, 0x38, 0x71, 0xe4, 0xeb, 0x02, 0x87, 0x08, 0xf5, 0x06, 0x9c, 0xc8, 0x91, 0x13, 0x9a, 0x19,
0xdb, 0x71, 0xb6, 0x9b, 0x36, 0x02, 0x6e, 0xf6, 0x3b, 0xcf, 0xf3, 0xbc, 0xf3, 0x7e, 0xcc, 0xcc,
0x0b, 0x8c, 0x28, 0xa6, 0x9c, 0xd6, 0xbb, 0x18, 0x39, 0x34, 0xac, 0x47, 0xcd, 0xa8, 0x3e, 0x68,
0xd4, 0xf9, 0x5e, 0x84, 0x59, 0x4d, 0xae, 0xc0, 0xe3, 0x98, 0xfb, 0x38, 0xc6, 0xfd, 0x5e, 0x4d,
0x61, 0x6a, 0x51, 0x33, 0xaa, 0x0d, 0x1a, 0x27, 0x1e, 0x57, 0x44, 0xcc, 0xfd, 0xfa, 0xa0, 0x81,
0x82, 0xc8, 0x47, 0x8d, 0x3a, 0xe2, 0x1c, 0x33, 0x8e, 0x38, 0x11, 0x30, 0xb1, 0x7c, 0xe2, 0xf4,
0x01, 0x28, 0xa5, 0x63, 0x77, 0x03, 0xea, 0xec, 0x26, 0x30, 0xf3, 0x00, 0xd8, 0x00, 0x05, 0xc4,
0x45, 0x9c, 0xc6, 0x09, 0x66, 0xcd, 0x23, 0xdc, 0xef, 0x77, 0x6b, 0x0e, 0xed, 0xd5, 0x3d, 0xea,
0xd1, 0xba, 0x34, 0x77, 0xfb, 0x3b, 0xf2, 0x4f, 0x09, 0x88, 0x2f, 0x05, 0x37, 0x3f, 0x2c, 0x81,
0x62, 0x47, 0x7a, 0xba, 0xc9, 0x11, 0xc7, 0xd0, 0x04, 0x0b, 0x1e, 0x0e, 0x31, 0x23, 0xcc, 0xe6,
0xa4, 0x87, 0xf5, 0xdf, 0x0e, 0x55, 0xb5, 0xd5, 0x82, 0x55, 0x4c, 0x8c, 0xb7, 0x48, 0x0f, 0xc3,
0x25, 0x50, 0x60, 0x01, 0xe5, 0xfa, 0xef, 0x6a, 0x4d, 0xfe, 0xc0, 0x06, 0x28, 0xec, 0xd0, 0x78,
0x57, 0xff, 0x43, 0x18, 0x8b, 0xcd, 0x53, 0xb5, 0x83, 0x13, 0x52, 0xdb, 0xa6, 0xf1, 0xae, 0x25,
0xa1, 0xf0, 0x45, 0xb0, 0x14, 0x20, 0x91, 0x0a, 0x15, 0xa4, 0xed, 0x63, 0xe4, 0xe2, 0x58, 0xff,
0xbe, 0x24, 0x15, 0x56, 0xc7, 0x0a, 0x98, 0xfb, 0xb5, 0x34, 0xe0, 0x9a, 0xda, 0x6d, 0x47, 0x30,
0x6e, 0x48, 0x82, 0x55, 0x51, 0x2a, 0x39, 0x13, 0xdc, 0x00, 0x45, 0xa5, 0x19, 0x53, 0xca, 0x99,
0xfe, 0x43, 0xa9, 0x3a, 0xbf, 0xba, 0xd0, 0x39, 0x3e, 0x1a, 0x1a, 0x90, 0xb1, 0xbb, 0x6b, 0x8c,
0xdc, 0xc5, 0x97, 0xcc, 0x8d, 0xc6, 0x66, 0xf3, 0xdc, 0x85, 0xa6, 0x69, 0x01, 0x89, 0xb5, 0x04,
0x54, 0x30, 0x45, 0x6d, 0x70, 0xc2, 0xfc, 0xf1, 0x21, 0x4c, 0x89, 0x55, 0x4c, 0x0b, 0x94, 0x7d,
0xc2, 0x38, 0x8d, 0x89, 0x83, 0x82, 0x84, 0xfe, 0x93, 0xa2, 0x9f, 0x19, 0x0d, 0x0d, 0x73, 0x4c,
0x7f, 0x5a, 0x70, 0xab, 0xe2, 0xbf, 0x87, 0xee, 0x5c, 0x32, 0x1b, 0xad, 0x76, 0xbb, 0xdd, 0x6c,
0xb4, 0x4c, 0xab, 0x34, 0x16, 0x50, 0x9a, 0x57, 0xc0, 0x11, 0xcc, 0xfd, 0x86, 0xed, 0x22, 0x8e,
0xf4, 0x2f, 0x96, 0x65, 0x62, 0x8c, 0x29, 0x89, 0xb9, 0xce, 0xfd, 0xc6, 0x35, 0xc4, 0x91, 0x75,
0x18, 0x27, 0x5f, 0xf0, 0x25, 0x50, 0xca, 0xe8, 0xf6, 0x80, 0x72, 0xcc, 0xf4, 0x2f, 0x97, 0xab,
0xf3, 0x33, 0x88, 0x74, 0xe0, 0x68, 0x68, 0x2c, 0x8e, 0xb7, 0x78, 0xbe, 0xb9, 0x6e, 0x5a, 0x47,
0x53, 0xe1, 0xdb, 0x42, 0x0a, 0xae, 0x01, 0xa8, 0xd4, 0x71, 0x44, 0x19, 0xe1, 0x36, 0x09, 0x5d,
0x7c, 0x47, 0xff, 0x6a, 0x59, 0x76, 0x45, 0x59, 0x62, 0xd5, 0xca, 0x33, 0x62, 0x01, 0xbe, 0x0c,
0x40, 0xd6, 0xac, 0x4c, 0xff, 0xc8, 0x90, 0xfb, 0xa8, 0x4e, 0xd9, 0xc7, 0xed, 0x14, 0xd9, 0x39,
0x39, 0x1a, 0x1a, 0xcb, 0xb9, 0x8d, 0x6c, 0x6e, 0x5e, 0x6c, 0x34, 0x5a, 0xcd, 0x76, 0xbb, 0xdd,
0x32, 0xad, 0x9c, 0x22, 0xdc, 0x00, 0x87, 0xbb, 0x28, 0x40, 0xa1, 0x83, 0x99, 0xfe, 0xb1, 0x50,
0x2f, 0x3c, 0x98, 0x9b, 0xa1, 0x61, 0x55, 0xd6, 0x3c, 0xe6, 0x36, 0xf3, 0x51, 0xec, 0xea, 0x6f,
0x9e, 0x95, 0x11, 0x00, 0x69, 0xbb, 0x29, 0x4c, 0xf0, 0x32, 0x58, 0x88, 0x51, 0xe8, 0x22, 0x6a,
0xf7, 0xc8, 0x1d, 0xcc, 0xf4, 0xb7, 0xce, 0xca, 0xba, 0x2e, 0x8f, 0x86, 0xc6, 0xd2, 0xb8, 0xae,
0xad, 0x8b, 0x17, 0x2f, 0xb4, 0x64, 0x5f, 0x14, 0x15, 0xfa, 0x39, 0x01, 0x86, 0xdb, 0x00, 0x22,
0x87, 0x93, 0x01, 0x56, 0x19, 0x4a, 0x5a, 0xe3, 0xed, 0x87, 0x48, 0x94, 0x15, 0x47, 0xe6, 0x2e,
0x6d, 0x30, 0xdd, 0xa1, 0xbd, 0x08, 0x39, 0xdc, 0x76, 0x68, 0xaf, 0x47, 0x38, 0xc7, 0x98, 0x25,
0x6a, 0xef, 0x3c, 0x44, 0xed, 0x78, 0xc2, 0xdc, 0xca, 0x88, 0x4a, 0xb3, 0x09, 0x8e, 0xb0, 0x00,
0x31, 0x9f, 0x84, 0x1e, 0xd3, 0xff, 0xac, 0xc9, 0xac, 0x2d, 0x8d, 0x86, 0x46, 0x69, 0xb2, 0xd9,
0x4d, 0x6b, 0x0c, 0x83, 0xaf, 0x83, 0x93, 0x51, 0x8c, 0x07, 0x84, 0xf6, 0x99, 0x8d, 0x23, 0xea,
0xf8, 0x76, 0xee, 0x46, 0x63, 0xfa, 0xcf, 0x2d, 0x59, 0xd9, 0x27, 0xa6, 0xdd, 0x00, 0xcf, 0xe3,
0xd0, 0x25, 0xa1, 0x77, 0x75, 0xcc, 0xd9, 0xd7, 0x6c, 0xca, 0xe1, 0x23, 0xa9, 0x8f, 0xeb, 0xc2,
0x45, 0x0e, 0xcd, 0xe0, 0x6b, 0xe0, 0x84, 0xd3, 0x8f, 0x63, 0x1c, 0xf2, 0x83, 0xfc, 0xff, 0xf2,
0xdf, 0xf8, 0xd7, 0x13, 0x17, 0xf7, 0xbb, 0xf7, 0xc0, 0x52, 0x16, 0xbf, 0x13, 0x53, 0xc6, 0x02,
0x12, 0xee, 0x32, 0xfd, 0xeb, 0xa7, 0x1e, 0xd8, 0xd1, 0x5b, 0x29, 0x72, 0x7f, 0x7e, 0xd5, 0xd9,
0x82, 0xa9, 0x64, 0x86, 0x63, 0x10, 0x03, 0x98, 0xc6, 0x99, 0xf3, 0xf3, 0xcd, 0xbf, 0xf2, 0x53,
0x49, 0x14, 0x73, 0x6e, 0x18, 0x80, 0xaf, 0xf4, 0x19, 0x27, 0x3b, 0xc4, 0x91, 0x11, 0xda, 0x5d,
0xc2, 0x99, 0xfe, 0xc9, 0x76, 0x55, 0x5b, 0x5d, 0xe8, 0x6c, 0x8d, 0x86, 0xc6, 0x42, 0x4e, 0xc4,
0xfc, 0x6b, 0x68, 0xd4, 0x73, 0x6f, 0x4c, 0x14, 0xef, 0xb1, 0x1e, 0xe2, 0xc4, 0x09, 0x50, 0x97,
0xd5, 0x3d, 0xba, 0xd6, 0x25, 0x7c, 0x87, 0xe0, 0xc0, 0xad, 0x75, 0x08, 0x1f, 0x60, 0x87, 0xd3,
0x78, 0xdd, 0xaa, 0x4c, 0xe8, 0x77, 0x08, 0x67, 0x70, 0x07, 0x3c, 0x9a, 0x25, 0x31, 0x59, 0xc5,
0xae, 0xed, 0xf8, 0xd8, 0xd9, 0x8d, 0x28, 0x09, 0xb9, 0xfe, 0xe9, 0xb6, 0xbc, 0xed, 0x1e, 0x9b,
0x16, 0x66, 0x86, 0xb4, 0xb2, 0x6e, 0x7c, 0x36, 0xd5, 0x19, 0x2f, 0x42, 0x17, 0x9c, 0x4a, 0x73,
0x78, 0xa0, 0x9b, 0xcf, 0x66, 0x76, 0x93, 0xf6, 0xdc, 0x41, 0x5e, 0x5e, 0x00, 0xc7, 0x76, 0x48,
0x88, 0x02, 0x72, 0x77, 0x52, 0xfd, 0xf3, 0x99, 0xd5, 0x97, 0x32, 0xfe, 0xd8, 0x68, 0xbe, 0xaf,
0x81, 0x82, 0x78, 0x30, 0xe1, 0x65, 0x50, 0xce, 0xb2, 0x35, 0xc0, 0x31, 0x23, 0x34, 0xd4, 0x35,
0x59, 0x9f, 0xf2, 0x64, 0x7d, 0xd6, 0x4d, 0xab, 0x94, 0x22, 0x6f, 0x2b, 0x20, 0xdc, 0x04, 0xa5,
0x34, 0x05, 0x29, 0x77, 0x6e, 0x0a, 0x77, 0x31, 0x01, 0xa6, 0xd4, 0x63, 0xe0, 0x7f, 0xf2, 0x84,
0xe9, 0xf3, 0xf2, 0x4a, 0x54, 0x3f, 0xe6, 0xbb, 0x73, 0x00, 0xde, 0x7f, 0x8a, 0x60, 0x0f, 0x94,
0x91, 0xe7, 0xc5, 0xd8, 0xcb, 0x75, 0x91, 0xda, 0x64, 0x67, 0xe2, 0x7c, 0xad, 0x9f, 0xdf, 0x6c,
0x89, 0x36, 0x3a, 0x37, 0x6b, 0x1b, 0x05, 0x84, 0x71, 0xab, 0x94, 0xd3, 0x96, 0x1d, 0x74, 0x09,
0x14, 0xe4, 0xb3, 0x38, 0x27, 0x53, 0x7c, 0x66, 0x4a, 0x8a, 0x73, 0x1b, 0x94, 0x8f, 0xa3, 0xe4,
0xc0, 0xb3, 0xa0, 0x44, 0x42, 0x27, 0xe8, 0x8b, 0x20, 0x6d, 0x17, 0x07, 0x68, 0x2f, 0x89, 0x70,
0x31, 0x33, 0x5f, 0x13, 0x56, 0x78, 0x1a, 0x2c, 0x46, 0x31, 0x8d, 0x28, 0xc3, 0x71, 0xf2, 0xbe,
0x15, 0x24, 0xee, 0x68, 0x6a, 0x95, 0xf7, 0xb3, 0xf9, 0x81, 0x06, 0x2a, 0x39, 0x4f, 0xb7, 0x50,
0xec, 0x61, 0x0e, 0x61, 0x32, 0x28, 0x69, 0xb9, 0x39, 0xe9, 0x0a, 0xa8, 0xe4, 0x27, 0x3b, 0x79,
0x7d, 0x27, 0xe5, 0xa8, 0x8c, 0x86, 0xc6, 0xd1, 0x71, 0x39, 0xc4, 0xb5, 0x5d, 0xea, 0x8e, 0xa7,
0x1d, 0x71, 0x61, 0xc3, 0x26, 0x28, 0x46, 0x48, 0x96, 0x52, 0x12, 0xe7, 0xa7, 0x11, 0x81, 0x42,
0x09, 0x8e, 0xf9, 0x2a, 0x38, 0xb5, 0x2f, 0x0b, 0x57, 0x43, 0x77, 0xab, 0xcf, 0x38, 0x75, 0xf7,
0x3a, 0x84, 0x67, 0x89, 0xd4, 0xfe, 0x41, 0x22, 0x0d, 0x50, 0x74, 0x94, 0x92, 0xa8, 0xb7, 0x0c,
0xe4, 0xb0, 0x05, 0x9c, 0x4c, 0xdc, 0x7c, 0x43, 0x03, 0xa5, 0x1b, 0xd9, 0x54, 0xd3, 0x41, 0xdc,
0xf1, 0x61, 0x7b, 0x72, 0x3a, 0xd3, 0x66, 0x1e, 0xce, 0xda, 0x93, 0xc3, 0xd9, 0xdc, 0xac, 0xb3,
0x99, 0xf9, 0x9e, 0x06, 0xca, 0x5b, 0xfb, 0x5e, 0x40, 0xf8, 0x24, 0x38, 0x14, 0xf5, 0xbb, 0xbb,
0x78, 0x2f, 0xdd, 0x82, 0x39, 0x1a, 0x1a, 0x2b, 0xf9, 0x31, 0x6d, 0x7d, 0x23, 0x37, 0xa6, 0xc9,
0xb6, 0xb5, 0x52, 0x0a, 0xbc, 0x0a, 0x60, 0xfa, 0x1a, 0xe7, 0xc6, 0x9a, 0x39, 0xf9, 0x82, 0xc2,
0xfb, 0xfb, 0xdd, 0xaa, 0x24, 0xe8, 0x6c, 0xb2, 0x61, 0x9d, 0x85, 0x6f, 0xef, 0xad, 0x68, 0xdf,
0xdd, 0x5b, 0xd1, 0x7e, 0xbd, 0xb7, 0xa2, 0x75, 0xff, 0x2f, 0x27, 0xf2, 0x0b, 0x7f, 0x07, 0x00,
0x00, 0xff, 0xff, 0x70, 0x1e, 0x6a, 0xd1, 0x6c, 0x0c, 0x00, 0x00,
}
func (m *BeaconState) Marshal() (dAtA []byte, err error) {
@ -1176,11 +1176,11 @@ func (m *AttestationTarget) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintTypes(dAtA, i, uint64(m.Slot))
}
if len(m.BlockRoot) > 0 {
if len(m.BeaconBlockRoot) > 0 {
dAtA[i] = 0x12
i++
i = encodeVarintTypes(dAtA, i, uint64(len(m.BlockRoot)))
i += copy(dAtA[i:], m.BlockRoot)
i = encodeVarintTypes(dAtA, i, uint64(len(m.BeaconBlockRoot)))
i += copy(dAtA[i:], m.BeaconBlockRoot)
}
if len(m.ParentRoot) > 0 {
dAtA[i] = 0x1a
@ -1523,7 +1523,7 @@ func (m *AttestationTarget) Size() (n int) {
if m.Slot != 0 {
n += 1 + sovTypes(uint64(m.Slot))
}
l = len(m.BlockRoot)
l = len(m.BeaconBlockRoot)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
@ -2926,9 +2926,9 @@ func (m *AttestationTarget) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.BlockRoot = append(m.BlockRoot[:0], dAtA[iNdEx:postIndex]...)
if m.BlockRoot == nil {
m.BlockRoot = []byte{}
m.BeaconBlockRoot = append(m.BeaconBlockRoot[:0], dAtA[iNdEx:postIndex]...)
if m.BeaconBlockRoot == nil {
m.BeaconBlockRoot = []byte{}
}
iNdEx = postIndex
case 3:

4
proto/beacon/rpc/v1/services.pb.go generated
View File

@ -3656,7 +3656,7 @@ func (m *ProposeResponse) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@ -5864,7 +5864,7 @@ func (m *BlockTreeResponse_TreeNode) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {

11
proto/eth/v1alpha1/BUILD.bazel
View File

@ -20,17 +20,6 @@ proto_library(
],
)
go_test(
name = "go_default_test",
size = "small",
srcs = ["compatability_test.go"],
deps = [
":go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
],
)
go_proto_library(
name = "go_default_library",
compiler = "//:grpc_proto_compiler",

11
proto/eth/v1alpha1/_compatibility/BUILD.bazel Normal file
View File

@ -0,0 +1,11 @@
load("@io_bazel_rules_go//go:def.bzl", "go_test")
go_test(
name = "go_default_test",
srcs = ["compatability_test.go"],
deps = [
"//proto/eth/v1alpha1:go_default_library",
"@com_github_gogo_protobuf//proto:go_default_library",
"@com_github_prysmaticlabs_ethereumapis//eth/v1alpha1:go_default_library",
],
)

0
proto/eth/v1alpha1/compatability_test.go → proto/eth/v1alpha1/_compatibility/compatability_test.go
View File

4
proto/eth/v1alpha1/beacon_chain.pb.go generated
View File

@ -3365,7 +3365,7 @@ func (m *ListAttestationsRequest) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@ -3795,7 +3795,7 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BeaconBlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {

309
proto/testing/test.pb.go generated
View File

@ -49,7 +49,7 @@ func (x Person_PhoneType) String() string {
}
func (Person_PhoneType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{2, 0}
return fileDescriptor_1f902154cb7707ef, []int{3, 0}
}
type TestMessage struct {
@ -107,6 +107,61 @@ func (m *TestMessage) GetBar() string {
return ""
}
type TestNestedMessage struct {
Fuzz string `protobuf:"bytes,1,opt,name=fuzz,proto3" json:"fuzz,omitempty"`
Msg *TestMessage `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *TestNestedMessage) Reset() { *m = TestNestedMessage{} }
func (m *TestNestedMessage) String() string { return proto.CompactTextString(m) }
func (*TestNestedMessage) ProtoMessage() {}
func (*TestNestedMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{1}
}
func (m *TestNestedMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *TestNestedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_TestNestedMessage.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalTo(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *TestNestedMessage) XXX_Merge(src proto.Message) {
xxx_messageInfo_TestNestedMessage.Merge(m, src)
}
func (m *TestNestedMessage) XXX_Size() int {
return m.Size()
}
func (m *TestNestedMessage) XXX_DiscardUnknown() {
xxx_messageInfo_TestNestedMessage.DiscardUnknown(m)
}
var xxx_messageInfo_TestNestedMessage proto.InternalMessageInfo
func (m *TestNestedMessage) GetFuzz() string {
if m != nil {
return m.Fuzz
}
return ""
}
func (m *TestNestedMessage) GetMsg() *TestMessage {
if m != nil {
return m.Msg
}
return nil
}
type Puzzle struct {
Challenge string `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
Answer string `protobuf:"bytes,2,opt,name=answer,proto3" json:"answer,omitempty"`
@ -119,7 +174,7 @@ func (m *Puzzle) Reset() { *m = Puzzle{} }
func (m *Puzzle) String() string { return proto.CompactTextString(m) }
func (*Puzzle) ProtoMessage() {}
func (*Puzzle) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{1}
return fileDescriptor_1f902154cb7707ef, []int{2}
}
func (m *Puzzle) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -177,7 +232,7 @@ func (m *Person) Reset() { *m = Person{} }
func (m *Person) String() string { return proto.CompactTextString(m) }
func (*Person) ProtoMessage() {}
func (*Person) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{2}
return fileDescriptor_1f902154cb7707ef, []int{3}
}
func (m *Person) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -253,7 +308,7 @@ func (m *Person_PhoneNumber) Reset() { *m = Person_PhoneNumber{} }
func (m *Person_PhoneNumber) String() string { return proto.CompactTextString(m) }
func (*Person_PhoneNumber) ProtoMessage() {}
func (*Person_PhoneNumber) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{2, 0}
return fileDescriptor_1f902154cb7707ef, []int{3, 0}
}
func (m *Person_PhoneNumber) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -307,7 +362,7 @@ func (m *AddressBook) Reset() { *m = AddressBook{} }
func (m *AddressBook) String() string { return proto.CompactTextString(m) }
func (*AddressBook) ProtoMessage() {}
func (*AddressBook) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{3}
return fileDescriptor_1f902154cb7707ef, []int{4}
}
func (m *AddressBook) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -346,6 +401,7 @@ func (m *AddressBook) GetPeople() []*Person {
func init() {
proto.RegisterEnum("testing.Person_PhoneType", Person_PhoneType_name, Person_PhoneType_value)
proto.RegisterType((*TestMessage)(nil), "testing.TestMessage")
proto.RegisterType((*TestNestedMessage)(nil), "testing.TestNestedMessage")
proto.RegisterType((*Puzzle)(nil), "testing.Puzzle")
proto.RegisterType((*Person)(nil), "testing.Person")
proto.RegisterType((*Person_PhoneNumber)(nil), "testing.Person.PhoneNumber")
@ -355,35 +411,37 @@ func init() {
func init() { proto.RegisterFile("proto/testing/test.proto", fileDescriptor_1f902154cb7707ef) }
var fileDescriptor_1f902154cb7707ef = []byte{
// 444 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xd1, 0x8a, 0xd3, 0x40,
0x14, 0x86, 0x4d, 0xda, 0x46, 0x7b, 0xb2, 0xac, 0x65, 0x10, 0x89, 0x5d, 0x69, 0x4b, 0x6e, 0x2c,
0x48, 0x53, 0xec, 0x82, 0x17, 0x0b, 0x0a, 0x16, 0x16, 0x14, 0xad, 0x2d, 0x43, 0xc5, 0x4b, 0x99,
0x34, 0xa7, 0x69, 0x30, 0xc9, 0x0c, 0x99, 0x09, 0xb2, 0x79, 0x33, 0xdf, 0xc0, 0x4b, 0x9f, 0x40,
0xa4, 0x8f, 0xe0, 0x13, 0xc8, 0x4c, 0x66, 0xad, 0x88, 0x57, 0xf9, 0xcf, 0x9f, 0x6f, 0xfe, 0x99,
0xf3, 0x43, 0x20, 0x2a, 0xae, 0xf8, 0x5c, 0xa1, 0x54, 0x59, 0x99, 0x9a, 0x6f, 0x64, 0x2c, 0x72,
0xd7, 0x7a, 0xc3, 0x71, 0xca, 0x79, 0x9a, 0xe3, 0xdc, 0xd8, 0x71, 0xbd, 0x9f, 0xab, 0xac, 0x40,
0xa9, 0x58, 0x21, 0x5a, 0x72, 0x38, 0x4b, 0x33, 0x75, 0xa8, 0xe3, 0x68, 0xc7, 0x8b, 0x79, 0xca,
0x53, 0x7e, 0x22, 0xf5, 0xd4, 0x5e, 0xa0, 0x55, 0x8b, 0x87, 0x14, 0xfc, 0x2d, 0x4a, 0xb5, 0x42,
0x29, 0x59, 0x8a, 0x64, 0x00, 0x9d, 0x3d, 0xe7, 0x81, 0x33, 0x71, 0xa6, 0x7d, 0xaa, 0x25, 0x79,
0x06, 0x9d, 0x98, 0x55, 0x81, 0xab, 0x9d, 0xe5, 0xf8, 0xd7, 0x8f, 0xf1, 0xc5, 0x3e, 0x6b, 0x9a,
0xab, 0x30, 0xae, 0x9b, 0x26, 0x9c, 0x48, 0x81, 0xbb, 0x59, 0xc9, 0x0a, 0xbc, 0x0a, 0x63, 0xd6,
0x84, 0x54, 0xb3, 0xe1, 0x4b, 0xf0, 0x36, 0x75, 0xd3, 0xe4, 0x48, 0x1e, 0x43, 0x7f, 0x77, 0x60,
0x79, 0x8e, 0x65, 0x8a, 0x36, 0xf4, 0x64, 0x90, 0x87, 0xe0, 0xb1, 0x52, 0x7e, 0x41, 0x9b, 0x4e,
0xed, 0x14, 0x7e, 0x75, 0xc1, 0xdb, 0x60, 0x25, 0x79, 0x49, 0x08, 0x74, 0x75, 0xba, 0x3d, 0x6b,
0x34, 0x39, 0x07, 0x37, 0x4b, 0xcc, 0x91, 0x1e, 0x75, 0xb3, 0x84, 0x3c, 0x80, 0x1e, 0x16, 0x2c,
0xcb, 0x83, 0x8e, 0x81, 0xda, 0x81, 0x5c, 0x82, 0x27, 0x0e, 0xbc, 0x44, 0x19, 0x74, 0x27, 0x9d,
0xa9, 0xbf, 0xb8, 0x88, 0x6c, 0x85, 0x51, 0x1b, 0x1d, 0x6d, 0xf4, 0xdf, 0xf7, 0x75, 0x11, 0x63,
0x45, 0x2d, 0x4a, 0x5e, 0xc0, 0x59, 0xce, 0xa4, 0xfa, 0x54, 0x8b, 0x84, 0x29, 0x4c, 0x82, 0xde,
0xc4, 0x99, 0xfa, 0x8b, 0x61, 0xd4, 0x96, 0x1e, 0xdd, 0x56, 0x19, 0x6d, 0x6f, 0x4b, 0xa7, 0xbe,
0xe6, 0x3f, 0xb4, 0xf8, 0x70, 0x0b, 0xfe, 0x5f, 0xa9, 0x7a, 0xbf, 0xd2, 0x28, 0xfb, 0x7c, 0x3b,
0x91, 0x19, 0x74, 0xd5, 0x8d, 0x40, 0xb3, 0xc2, 0xf9, 0xe2, 0xd1, 0x7f, 0x1f, 0xb6, 0xbd, 0x11,
0x48, 0x0d, 0x16, 0x3e, 0x85, 0xfe, 0x1f, 0x8b, 0x00, 0x78, 0xab, 0xf5, 0xf2, 0xcd, 0xbb, 0xeb,
0xc1, 0x1d, 0x72, 0x0f, 0xba, 0xaf, 0xd7, 0xab, 0xeb, 0x81, 0xa3, 0xd5, 0xc7, 0x35, 0x7d, 0x3b,
0x70, 0xc3, 0xe7, 0xe0, 0xbf, 0x4a, 0x92, 0x0a, 0xa5, 0x5c, 0x72, 0xfe, 0x99, 0x3c, 0x01, 0x4f,
0x20, 0x17, 0xb9, 0x6e, 0x50, 0xb7, 0x70, 0xff, 0x9f, 0xcb, 0xa8, 0xfd, 0xbd, 0x3c, 0xfb, 0x76,
0x1c, 0x39, 0xdf, 0x8f, 0x23, 0xe7, 0xe7, 0x71, 0xe4, 0xc4, 0x9e, 0xd9, 0xf4, 0xf2, 0x77, 0x00,
0x00, 0x00, 0xff, 0xff, 0x12, 0x4a, 0xad, 0xd0, 0x91, 0x02, 0x00, 0x00,
// 478 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xdd, 0x8a, 0xd3, 0x40,
0x18, 0x35, 0xfd, 0x89, 0xf6, 0xcb, 0xb2, 0xd6, 0x61, 0x91, 0xd8, 0x95, 0xb6, 0xcc, 0x85, 0x2e,
0x48, 0x53, 0xec, 0x82, 0x17, 0x0b, 0x0a, 0x16, 0x16, 0x14, 0xed, 0xb6, 0x0c, 0x15, 0x2f, 0x65,
0xd2, 0x7c, 0x4d, 0x83, 0x49, 0x26, 0x64, 0x26, 0xc8, 0xe6, 0xcd, 0x7c, 0x03, 0x2f, 0x7d, 0x02,
0x91, 0x3e, 0x82, 0x4f, 0x20, 0x33, 0x99, 0xee, 0x2e, 0xe2, 0x55, 0xce, 0x77, 0xe6, 0xe4, 0xcc,
0x39, 0xf3, 0x81, 0x5f, 0x94, 0x42, 0x89, 0xa9, 0x42, 0xa9, 0x92, 0x3c, 0x36, 0xdf, 0xc0, 0x50,
0xe4, 0xbe, 0xe5, 0x06, 0xa3, 0x58, 0x88, 0x38, 0xc5, 0xa9, 0xa1, 0xc3, 0x6a, 0x3b, 0x55, 0x49,
0x86, 0x52, 0xf1, 0xac, 0x68, 0x94, 0x83, 0x49, 0x9c, 0xa8, 0x5d, 0x15, 0x06, 0x1b, 0x91, 0x4d,
0x63, 0x11, 0x8b, 0x5b, 0xa5, 0x9e, 0x9a, 0x0b, 0x34, 0x6a, 0xe4, 0x94, 0x81, 0xb7, 0x46, 0xa9,
0x16, 0x28, 0x25, 0x8f, 0x91, 0xf4, 0xa1, 0xbd, 0x15, 0xc2, 0x77, 0xc6, 0xce, 0x59, 0x8f, 0x69,
0x48, 0x5e, 0x42, 0x3b, 0xe4, 0xa5, 0xdf, 0xd2, 0xcc, 0x7c, 0xf4, 0xe7, 0xd7, 0xe8, 0x74, 0x9b,
0xd4, 0xf5, 0x05, 0x0d, 0xab, 0xba, 0xa6, 0x63, 0x59, 0xe0, 0x66, 0x92, 0xf3, 0x0c, 0x2f, 0x68,
0xc8, 0x6b, 0xca, 0xb4, 0x96, 0x2e, 0xe1, 0x91, 0xf6, 0xbc, 0x42, 0xa9, 0x30, 0x3a, 0x38, 0x13,
0xe8, 0x6c, 0xab, 0xba, 0xb6, 0xd6, 0x06, 0x93, 0x67, 0xd0, 0xce, 0x64, 0x6c, 0xbc, 0xbd, 0xd9,
0x49, 0x60, 0x3b, 0x06, 0x77, 0x02, 0x31, 0x2d, 0xa0, 0x6f, 0xc0, 0x5d, 0x55, 0x75, 0x9d, 0x22,
0x79, 0x0a, 0xbd, 0xcd, 0x8e, 0xa7, 0x29, 0xe6, 0x31, 0x5a, 0xab, 0x5b, 0x82, 0x3c, 0x06, 0x97,
0xe7, 0xf2, 0x1b, 0xda, 0xb8, 0xcc, 0x4e, 0xf4, 0x7b, 0x0b, 0xdc, 0x15, 0x96, 0x52, 0xe4, 0x3a,
0x86, 0x8e, 0x7b, 0x88, 0xa1, 0x31, 0x39, 0x86, 0x56, 0x12, 0x99, 0x5f, 0xba, 0xac, 0x95, 0x44,
0xe4, 0x04, 0xba, 0x98, 0xf1, 0x24, 0xf5, 0xdb, 0x46, 0xd4, 0x0c, 0xe4, 0x1c, 0xdc, 0x62, 0x27,
0x72, 0x94, 0x7e, 0x67, 0xdc, 0x3e, 0xf3, 0x66, 0xa7, 0x37, 0x79, 0x1b, 0xeb, 0x60, 0xa5, 0x4f,
0xaf, 0xaa, 0x2c, 0xc4, 0x92, 0x59, 0x29, 0x79, 0x0d, 0x47, 0x29, 0x97, 0xea, 0x4b, 0x55, 0x44,
0x5c, 0x61, 0xe4, 0x77, 0x4d, 0xd5, 0x41, 0xd0, 0x6c, 0x31, 0x38, 0xec, 0x26, 0x58, 0x1f, 0xb6,
0xc8, 0x3c, 0xad, 0xff, 0xd4, 0xc8, 0x07, 0x6b, 0xf0, 0xee, 0xb8, 0xea, 0x7e, 0xb9, 0x41, 0x36,
0xbe, 0x9d, 0xc8, 0x04, 0x3a, 0xea, 0xba, 0x40, 0x53, 0xe1, 0x78, 0xf6, 0xe4, 0xbf, 0xc1, 0xd6,
0xd7, 0x05, 0x32, 0x23, 0xa3, 0x2f, 0xa0, 0x77, 0x43, 0x11, 0x00, 0x77, 0xb1, 0x9c, 0xbf, 0xff,
0x78, 0xd9, 0xbf, 0x47, 0x1e, 0x40, 0xe7, 0xdd, 0x72, 0x71, 0xd9, 0x77, 0x34, 0xfa, 0xbc, 0x64,
0x1f, 0xfa, 0x2d, 0xfa, 0x0a, 0xbc, 0xb7, 0x51, 0x54, 0xa2, 0x94, 0x73, 0x21, 0xbe, 0x92, 0xe7,
0xe0, 0x16, 0x28, 0x8a, 0x54, 0xbf, 0xa0, 0x7e, 0x85, 0x87, 0xff, 0x5c, 0xc6, 0xec, 0xf1, 0xfc,
0xe8, 0xc7, 0x7e, 0xe8, 0xfc, 0xdc, 0x0f, 0x9d, 0xdf, 0xfb, 0xa1, 0x13, 0xba, 0xa6, 0xe9, 0xf9,
0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x3f, 0x7c, 0x52, 0xe2, 0x02, 0x00, 0x00,
}
func (m *TestMessage) Marshal() (dAtA []byte, err error) {
@ -419,6 +477,43 @@ func (m *TestMessage) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *TestNestedMessage) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *TestNestedMessage) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Fuzz) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintTest(dAtA, i, uint64(len(m.Fuzz)))
i += copy(dAtA[i:], m.Fuzz)
}
if m.Msg != nil {
dAtA[i] = 0x12
i++
i = encodeVarintTest(dAtA, i, uint64(m.Msg.Size()))
n1, err := m.Msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Puzzle) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -500,11 +595,11 @@ func (m *Person) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintTest(dAtA, i, uint64(m.LastUpdated.Size()))
n1, err := m.LastUpdated.MarshalTo(dAtA[i:])
n2, err := m.LastUpdated.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n1
i += n2
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
@ -606,6 +701,26 @@ func (m *TestMessage) Size() (n int) {
return n
}
func (m *TestNestedMessage) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Fuzz)
if l > 0 {
n += 1 + l + sovTest(uint64(l))
}
if m.Msg != nil {
l = m.Msg.Size()
n += 1 + l + sovTest(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Puzzle) Size() (n int) {
if m == nil {
return 0
@ -827,6 +942,128 @@ func (m *TestMessage) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *TestNestedMessage) 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 ErrIntOverflowTest
}
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: TestNestedMessage: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TestNestedMessage: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Fuzz", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Fuzz = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTest
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTest
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTest
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Msg == nil {
m.Msg = &TestMessage{}
}
if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTest(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTest
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTest
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Puzzle) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0

11
shared/testutil/json_to_pb_converter_test.go
View File

@ -6,6 +6,9 @@ import (
pb "github.com/prysmaticlabs/prysm/proto/testing"
)
const baz = "baz"
const foo = "foo"
func TestOverrideSpecName(t *testing.T) {
input := struct {
Foo string `json:"foo"`
@ -19,10 +22,10 @@ func TestOverrideSpecName(t *testing.T) {
t.Fatal(err)
}
if output.Foo != "foo" {
if output.Foo != foo {
t.Error("Expected output.Foo to be foo")
}
if output.Bar != "baz" {
if output.Bar != baz {
t.Errorf("Expected output.Bar to be baz")
}
}
@ -53,10 +56,10 @@ func TestOverrideSpecName_NestedProto(t *testing.T) {
if output.Fuzz != "fuzz" {
t.Error("Expected output.fuzz to be fuzz")
}
if output.Msg.Foo != "foo" {
if output.Msg.Foo != foo {
t.Error("Expected output.Msg.Foo to be foo")
}
if output.Msg.Bar != "baz" {
if output.Msg.Bar != baz {
t.Errorf("Expected output.Msg.Bar to be baz")
}
}