mirror/prysm-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/prysm-pulse.git synced 2024-12-22 03:30:35 +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} -t ./...
- go get ${gobuild_args} github.com/golangci/golangci-lint/cmd/golangci-lint - go get ${gobuild_args} github.com/golangci/golangci-lint/cmd/golangci-lint
script: script:
- golangci-lint run - golangci-lint run --skip-dirs ./proto
email: false email: false
after_success: after_success:
- wget https://raw.githubusercontent.com/k3rn31p4nic/travis-ci-discord-webhook/master/send.sh - 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 { switch fieldNum {
case 1: case 1:
if wireType != 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 var byteLen int
for shift := uint(0); ; shift += 7 { 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 { type AttestationTarget struct {
Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` 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"` ParentRoot []byte `protobuf:"bytes,3,opt,name=parent_root,json=parentRoot,proto3" json:"parent_root,omitempty" ssz-size:"32"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
@ -447,9 +447,9 @@ func (m *AttestationTarget) GetSlot() uint64 {
return 0 return 0
} }
func (m *AttestationTarget) GetBlockRoot() []byte { func (m *AttestationTarget) GetBeaconBlockRoot() []byte {
if m != nil { if m != nil {
return m.BlockRoot return m.BeaconBlockRoot
} }
return nil return nil
} }
@ -639,89 +639,89 @@ func init() {
func init() { proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_e719e7d82cfa7b0d) } func init() { proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_e719e7d82cfa7b0d) }
var fileDescriptor_e719e7d82cfa7b0d = []byte{ var fileDescriptor_e719e7d82cfa7b0d = []byte{
// 1299 bytes of a gzipped FileDescriptorProto // 1307 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcb, 0x6f, 0x1b, 0x45, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x8f, 0xdb, 0xc4,
0x18, 0xd7, 0x26, 0x86, 0xb6, 0x9f, 0xd3, 0xd8, 0x99, 0x54, 0xcd, 0xd2, 0x96, 0xac, 0x59, 0xd1, 0x1b, 0x96, 0x77, 0xf3, 0xfb, 0xb5, 0x9d, 0x6c, 0x37, 0xc9, 0x6c, 0xd5, 0x35, 0x6d, 0x59, 0x07,
0x36, 0x42, 0x8d, 0x5d, 0xbb, 0xa9, 0x9d, 0xb4, 0x3c, 0x54, 0xa7, 0x8d, 0x0a, 0x12, 0x12, 0xda, 0x8b, 0xb6, 0x2b, 0xd4, 0x4d, 0x9a, 0x74, 0x9b, 0xec, 0xb6, 0x14, 0xd4, 0x6c, 0xbb, 0x2a, 0x48,
0x96, 0x4a, 0x48, 0x88, 0xd5, 0x78, 0x77, 0xe2, 0x1d, 0xb2, 0xde, 0x59, 0xed, 0x8c, 0xad, 0xa6, 0x48, 0xc8, 0x2d, 0x95, 0x90, 0x10, 0xd6, 0xc4, 0x9e, 0xb5, 0x87, 0x75, 0x3c, 0x96, 0x67, 0x12,
0x08, 0x71, 0xe0, 0xc4, 0x4b, 0x1c, 0xe0, 0xc6, 0x09, 0x6e, 0x3c, 0xfe, 0x01, 0xe0, 0x04, 0x27, 0x75, 0x8b, 0x10, 0x07, 0x4e, 0x7c, 0x48, 0x1c, 0xe0, 0x04, 0x27, 0xb8, 0xf1, 0xf1, 0x0f, 0x00,
0x8e, 0xbc, 0x2e, 0x70, 0xb0, 0x50, 0x6f, 0xc0, 0x09, 0x1f, 0x39, 0xa1, 0x9d, 0xd9, 0x5d, 0xaf, 0x27, 0x38, 0x71, 0xe4, 0xeb, 0x02, 0x87, 0x08, 0xf5, 0x06, 0x9c, 0xc8, 0x91, 0x13, 0x9a, 0x19,
0xd3, 0xb8, 0x8d, 0x80, 0xdb, 0xee, 0x37, 0xbf, 0xdf, 0xef, 0x9b, 0xef, 0x31, 0x33, 0x1f, 0x18, 0xdb, 0x71, 0xb6, 0x9b, 0x36, 0x02, 0x6e, 0xf6, 0x3b, 0xcf, 0xf3, 0xbc, 0xf3, 0x7e, 0xcc, 0xcc,
0x61, 0xc4, 0x04, 0xab, 0x75, 0x08, 0x76, 0x58, 0x50, 0x0b, 0x1b, 0x61, 0x6d, 0x50, 0xaf, 0x89, 0x0b, 0x8c, 0x28, 0xa6, 0x9c, 0xd6, 0xbb, 0x18, 0x39, 0x34, 0xac, 0x47, 0xcd, 0xa8, 0x3e, 0x68,
0xdd, 0x90, 0xf0, 0xaa, 0x5c, 0x41, 0xc7, 0x89, 0xf0, 0x48, 0x44, 0xfa, 0xbd, 0xaa, 0xc2, 0x54, 0xd4, 0xf9, 0x5e, 0x84, 0x59, 0x4d, 0xae, 0xc0, 0xe3, 0x98, 0xfb, 0x38, 0xc6, 0xfd, 0x5e, 0x4d,
0xc3, 0x46, 0x58, 0x1d, 0xd4, 0x4f, 0x3c, 0xae, 0x88, 0x44, 0x78, 0xb5, 0x41, 0x1d, 0xfb, 0xa1, 0x61, 0x6a, 0x51, 0x33, 0xaa, 0x0d, 0x1a, 0x27, 0x1e, 0x57, 0x44, 0xcc, 0xfd, 0xfa, 0xa0, 0x81,
0x87, 0xeb, 0x35, 0x2c, 0x04, 0xe1, 0x02, 0x0b, 0x1a, 0xc3, 0xe2, 0xe5, 0x13, 0xa7, 0xf7, 0x41, 0x82, 0xc8, 0x47, 0x8d, 0x3a, 0xe2, 0x1c, 0x33, 0x8e, 0x38, 0x11, 0x30, 0xb1, 0x7c, 0xe2, 0xf4,
0x29, 0x1d, 0xbb, 0xe3, 0x33, 0x67, 0x27, 0x81, 0x99, 0xfb, 0xc0, 0x06, 0xd8, 0xa7, 0x2e, 0x16, 0x01, 0x28, 0xa5, 0x63, 0x77, 0x03, 0xea, 0xec, 0x26, 0x30, 0xf3, 0x00, 0xd8, 0x00, 0x05, 0xc4,
0x2c, 0x4a, 0x30, 0xab, 0x5d, 0x2a, 0xbc, 0x7e, 0xa7, 0xea, 0xb0, 0x5e, 0xad, 0xcb, 0xba, 0xac, 0x45, 0x9c, 0xc6, 0x09, 0x66, 0xcd, 0x23, 0xdc, 0xef, 0x77, 0x6b, 0x0e, 0xed, 0xd5, 0x3d, 0xea,
0x26, 0xcd, 0x9d, 0xfe, 0xb6, 0xfc, 0x53, 0x02, 0xf1, 0x97, 0x82, 0x9b, 0x1f, 0x95, 0xa0, 0xd8, 0xd1, 0xba, 0x34, 0x77, 0xfb, 0x3b, 0xf2, 0x4f, 0x09, 0x88, 0x2f, 0x05, 0x37, 0x3f, 0x2c, 0x81,
0x96, 0x9e, 0x6e, 0x08, 0x2c, 0x08, 0x32, 0x61, 0xae, 0x4b, 0x02, 0xc2, 0x29, 0xb7, 0x05, 0xed, 0x62, 0x47, 0x7a, 0xba, 0xc9, 0x11, 0xc7, 0xd0, 0x04, 0x0b, 0x1e, 0x0e, 0x31, 0x23, 0xcc, 0xe6,
0x11, 0xfd, 0xf7, 0x43, 0x15, 0x6d, 0xa5, 0x60, 0x15, 0x13, 0xe3, 0x4d, 0xda, 0x23, 0x68, 0x11, 0xa4, 0x87, 0xf5, 0xdf, 0x0e, 0x55, 0xb5, 0xd5, 0x82, 0x55, 0x4c, 0x8c, 0xb7, 0x48, 0x0f, 0xc3,
0x0a, 0xdc, 0x67, 0x42, 0xff, 0x43, 0xad, 0xc9, 0x1f, 0x54, 0x87, 0xc2, 0x36, 0x8b, 0x76, 0xf4, 0x25, 0x50, 0x60, 0x01, 0xe5, 0xfa, 0xef, 0x6a, 0x4d, 0xfe, 0xc0, 0x06, 0x28, 0xec, 0xd0, 0x78,
0x3f, 0x63, 0x63, 0xb1, 0x71, 0xaa, 0xba, 0x7f, 0x42, 0xaa, 0x5b, 0x2c, 0xda, 0xb1, 0x24, 0x14, 0x57, 0xff, 0x43, 0x18, 0x8b, 0xcd, 0x53, 0xb5, 0x83, 0x13, 0x52, 0xdb, 0xa6, 0xf1, 0xae, 0x25,
0xbd, 0x04, 0x8b, 0x3e, 0x8e, 0x53, 0xa1, 0x82, 0xb4, 0x3d, 0x82, 0x5d, 0x12, 0xe9, 0x3f, 0x94, 0xa1, 0xf0, 0x45, 0xb0, 0x14, 0x20, 0x91, 0x0a, 0x15, 0xa4, 0xed, 0x63, 0xe4, 0xe2, 0x58, 0xff,
0xa4, 0xc2, 0xca, 0x58, 0x81, 0x08, 0xaf, 0x9a, 0x06, 0x5c, 0x55, 0xbb, 0x6d, 0xc7, 0x8c, 0xeb, 0xbe, 0x24, 0x15, 0x56, 0xc7, 0x0a, 0x98, 0xfb, 0xb5, 0x34, 0xe0, 0x9a, 0xda, 0x6d, 0x47, 0x30,
0x92, 0x60, 0x2d, 0x28, 0x95, 0x9c, 0x09, 0xad, 0x43, 0x51, 0x69, 0x46, 0x8c, 0x09, 0xae, 0xff, 0x6e, 0x48, 0x82, 0x55, 0x51, 0x2a, 0x39, 0x13, 0xdc, 0x00, 0x45, 0xa5, 0x19, 0x53, 0xca, 0x99,
0x58, 0xaa, 0xcc, 0xae, 0xcc, 0xb5, 0x8f, 0x8f, 0x86, 0x06, 0xe2, 0xfc, 0xce, 0x2a, 0xa7, 0x77, 0xfe, 0x43, 0xa9, 0x3a, 0xbf, 0xba, 0xd0, 0x39, 0x3e, 0x1a, 0x1a, 0x90, 0xb1, 0xbb, 0x6b, 0x8c,
0xc8, 0x25, 0x73, 0xbd, 0xbe, 0xd1, 0x38, 0x77, 0xa1, 0x61, 0x5a, 0x20, 0xb1, 0x56, 0x0c, 0x8d, 0xdc, 0xc5, 0x97, 0xcc, 0x8d, 0xc6, 0x66, 0xf3, 0xdc, 0x85, 0xa6, 0x69, 0x01, 0x89, 0xb5, 0x04,
0x99, 0x71, 0x6d, 0x48, 0xc2, 0xfc, 0xe9, 0x01, 0x4c, 0x89, 0x55, 0x4c, 0x0b, 0xca, 0x1e, 0xe5, 0x54, 0x30, 0x45, 0x6d, 0x70, 0xc2, 0xfc, 0xf1, 0x21, 0x4c, 0x89, 0x55, 0x4c, 0x0b, 0x94, 0x7d,
0x82, 0x45, 0xd4, 0xc1, 0x7e, 0x42, 0xff, 0x59, 0xd1, 0xcf, 0x8c, 0x86, 0x86, 0x39, 0xa6, 0x3f, 0xc2, 0x38, 0x8d, 0x89, 0x83, 0x82, 0x84, 0xfe, 0x93, 0xa2, 0x9f, 0x19, 0x0d, 0x0d, 0x73, 0x4c,
0x13, 0x73, 0x2b, 0xf1, 0x7f, 0x0f, 0xdf, 0xbe, 0x64, 0xd6, 0x9b, 0xad, 0x56, 0xab, 0x51, 0x6f, 0x7f, 0x5a, 0x70, 0xab, 0xe2, 0xbf, 0x87, 0xee, 0x5c, 0x32, 0x1b, 0xad, 0x76, 0xbb, 0xdd, 0x6c,
0x9a, 0x56, 0x69, 0x2c, 0xa0, 0x34, 0x9f, 0x82, 0x23, 0x44, 0x78, 0x75, 0xdb, 0xc5, 0x02, 0xeb, 0xb4, 0x4c, 0xab, 0x34, 0x16, 0x50, 0x9a, 0x57, 0xc0, 0x11, 0xcc, 0xfd, 0x86, 0xed, 0x22, 0x8e,
0x5f, 0x2e, 0xc9, 0xc4, 0x18, 0x53, 0x12, 0x73, 0x4d, 0x78, 0xf5, 0xab, 0x58, 0x60, 0xeb, 0x30, 0xf4, 0x2f, 0x96, 0x65, 0x62, 0x8c, 0x29, 0x89, 0xb9, 0xce, 0xfd, 0xc6, 0x35, 0xc4, 0x91, 0x75,
0x49, 0xbe, 0xd0, 0xcb, 0x50, 0xca, 0xe8, 0xf6, 0x80, 0x09, 0xc2, 0xf5, 0xaf, 0x96, 0x2a, 0xb3, 0x18, 0x27, 0x5f, 0xf0, 0x25, 0x50, 0xca, 0xe8, 0xf6, 0x80, 0x72, 0xcc, 0xf4, 0x2f, 0x97, 0xab,
0x07, 0x10, 0x69, 0xa3, 0xd1, 0xd0, 0x98, 0x1f, 0x6f, 0xf1, 0x7c, 0x63, 0xcd, 0xb4, 0x8e, 0xa6, 0xf3, 0x33, 0x88, 0x74, 0xe0, 0x68, 0x68, 0x2c, 0x8e, 0xb7, 0x78, 0xbe, 0xb9, 0x6e, 0x5a, 0x47,
0xc2, 0xb7, 0x62, 0x29, 0xb4, 0x0a, 0x48, 0xa9, 0x93, 0x90, 0x71, 0x2a, 0x6c, 0x1a, 0xb8, 0xe4, 0x53, 0xe1, 0xdb, 0x42, 0x0a, 0xae, 0x01, 0xa8, 0xd4, 0x71, 0x44, 0x19, 0xe1, 0x36, 0x09, 0x5d,
0xb6, 0xfe, 0xf5, 0x92, 0xec, 0x8a, 0xb2, 0xc4, 0xaa, 0x95, 0x67, 0xe3, 0x05, 0xf4, 0x0a, 0x40, 0x7c, 0x47, 0xff, 0x6a, 0x59, 0x76, 0x45, 0x59, 0x62, 0xd5, 0xca, 0x33, 0x62, 0x01, 0xbe, 0x0c,
0xd6, 0xac, 0x5c, 0xff, 0xd8, 0x90, 0xfb, 0xa8, 0x4c, 0xd9, 0xc7, 0xad, 0x14, 0xd9, 0x3e, 0x39, 0x40, 0xd6, 0xac, 0x4c, 0xff, 0xc8, 0x90, 0xfb, 0xa8, 0x4e, 0xd9, 0xc7, 0xed, 0x14, 0xd9, 0x39,
0x1a, 0x1a, 0x4b, 0xb9, 0x8d, 0x6c, 0x6c, 0x5c, 0xac, 0xd7, 0x9b, 0x8d, 0x56, 0xab, 0xd5, 0x34, 0x39, 0x1a, 0x1a, 0xcb, 0xb9, 0x8d, 0x6c, 0x6e, 0x5e, 0x6c, 0x34, 0x5a, 0xcd, 0x76, 0xbb, 0xdd,
0xad, 0x9c, 0x22, 0x5a, 0x87, 0xc3, 0x1d, 0xec, 0xe3, 0xc0, 0x21, 0x5c, 0xff, 0x24, 0x56, 0x2f, 0x32, 0xad, 0x9c, 0x22, 0xdc, 0x00, 0x87, 0xbb, 0x28, 0x40, 0xa1, 0x83, 0x99, 0xfe, 0xb1, 0x50,
0xdc, 0x9f, 0x9b, 0xa1, 0x51, 0x45, 0xd6, 0x3c, 0x12, 0x36, 0xf7, 0x70, 0xe4, 0xea, 0x6f, 0x9d, 0x2f, 0x3c, 0x98, 0x9b, 0xa1, 0x61, 0x55, 0xd6, 0x3c, 0xe6, 0x36, 0xf3, 0x51, 0xec, 0xea, 0x6f,
0x95, 0x11, 0x80, 0xb4, 0xdd, 0x88, 0x4d, 0xe8, 0x32, 0xcc, 0x45, 0x38, 0x70, 0x31, 0xb3, 0x7b, 0x9e, 0x95, 0x11, 0x00, 0x69, 0xbb, 0x29, 0x4c, 0xf0, 0x32, 0x58, 0x88, 0x51, 0xe8, 0x22, 0x6a,
0xf4, 0x36, 0xe1, 0xfa, 0xdb, 0x67, 0x65, 0x5d, 0x97, 0x46, 0x43, 0x63, 0x71, 0x5c, 0xd7, 0xe6, 0xf7, 0xc8, 0x1d, 0xcc, 0xf4, 0xb7, 0xce, 0xca, 0xba, 0x2e, 0x8f, 0x86, 0xc6, 0xd2, 0xb8, 0xae,
0xc5, 0x8b, 0x17, 0x9a, 0xb2, 0x2f, 0x8a, 0x0a, 0xfd, 0x7c, 0x0c, 0x46, 0x5b, 0x80, 0xb0, 0x23, 0xad, 0x8b, 0x17, 0x2f, 0xb4, 0x64, 0x5f, 0x14, 0x15, 0xfa, 0x39, 0x01, 0x86, 0xdb, 0x00, 0x22,
0xe8, 0x80, 0xa8, 0x0c, 0x25, 0xad, 0xf1, 0xce, 0x03, 0x24, 0xca, 0x8a, 0x23, 0x73, 0x97, 0x36, 0x87, 0x93, 0x01, 0x56, 0x19, 0x4a, 0x5a, 0xe3, 0xed, 0x87, 0x48, 0x94, 0x15, 0x47, 0xe6, 0x2e,
0x98, 0xee, 0xb0, 0x5e, 0x88, 0x1d, 0x61, 0x3b, 0xac, 0xd7, 0xa3, 0x42, 0x10, 0xc2, 0x13, 0xb5, 0x6d, 0x30, 0xdd, 0xa1, 0xbd, 0x08, 0x39, 0xdc, 0x76, 0x68, 0xaf, 0x47, 0x38, 0xc7, 0x98, 0x25,
0x77, 0x1f, 0xa0, 0x76, 0x3c, 0x61, 0x6e, 0x66, 0x44, 0xa5, 0xd9, 0x80, 0x23, 0xdc, 0xc7, 0xdc, 0x6a, 0xef, 0x3c, 0x44, 0xed, 0x78, 0xc2, 0xdc, 0xca, 0x88, 0x4a, 0xb3, 0x09, 0x8e, 0xb0, 0x00,
0xa3, 0x41, 0x97, 0xeb, 0x7f, 0x55, 0x65, 0xd6, 0x16, 0x47, 0x43, 0xa3, 0x34, 0xd9, 0xec, 0xa6, 0x31, 0x9f, 0x84, 0x1e, 0xd3, 0xff, 0xac, 0xc9, 0xac, 0x2d, 0x8d, 0x86, 0x46, 0x69, 0xb2, 0xd9,
0x35, 0x86, 0xa1, 0x37, 0xe0, 0x64, 0x18, 0x91, 0x01, 0x65, 0x7d, 0x6e, 0x93, 0x90, 0x39, 0x9e, 0x4d, 0x6b, 0x0c, 0x83, 0xaf, 0x83, 0x93, 0x51, 0x8c, 0x07, 0x84, 0xf6, 0x99, 0x8d, 0x23, 0xea,
0x9d, 0xbb, 0xd1, 0xb8, 0xfe, 0x4b, 0x53, 0x56, 0xf6, 0x89, 0x69, 0x37, 0xc0, 0x0b, 0x24, 0x70, 0xf8, 0x76, 0xee, 0x46, 0x63, 0xfa, 0xcf, 0x2d, 0x59, 0xd9, 0x27, 0xa6, 0xdd, 0x00, 0xcf, 0xe3,
0x69, 0xd0, 0xbd, 0x32, 0xe6, 0xec, 0x69, 0x36, 0xe5, 0xf0, 0x91, 0xd4, 0xc7, 0xb5, 0xd8, 0x45, 0xd0, 0x25, 0xa1, 0x77, 0x75, 0xcc, 0xd9, 0xd7, 0x6c, 0xca, 0xe1, 0x23, 0xa9, 0x8f, 0xeb, 0xc2,
0x0e, 0xcd, 0xd1, 0xeb, 0x70, 0xc2, 0xe9, 0x47, 0x11, 0x09, 0xc4, 0x7e, 0xfe, 0x7f, 0xfd, 0x7f, 0x45, 0x0e, 0xcd, 0xe0, 0x6b, 0xe0, 0x84, 0xd3, 0x8f, 0x63, 0x1c, 0xf2, 0x83, 0xfc, 0xff, 0xf2,
0xfc, 0xeb, 0x89, 0x8b, 0x7b, 0xdd, 0x77, 0x61, 0x31, 0x8b, 0xdf, 0x89, 0x18, 0xe7, 0x3e, 0x0d, 0xdf, 0xf8, 0xd7, 0x13, 0x17, 0xf7, 0xbb, 0xf7, 0xc0, 0x52, 0x16, 0xbf, 0x13, 0x53, 0xc6, 0x02,
0x76, 0xb8, 0xfe, 0xcd, 0xd3, 0xf7, 0xed, 0xe8, 0xcd, 0x14, 0xb9, 0x37, 0xbf, 0xea, 0x6c, 0xa1, 0x12, 0xee, 0x32, 0xfd, 0xeb, 0xa7, 0x1e, 0xd8, 0xd1, 0x5b, 0x29, 0x72, 0x7f, 0x7e, 0xd5, 0xd9,
0x54, 0x32, 0xc3, 0x71, 0x44, 0x00, 0xa5, 0x71, 0xe6, 0xfc, 0x7c, 0xfb, 0x9f, 0xfc, 0x2c, 0x24, 0x82, 0xa9, 0x64, 0x86, 0x63, 0x10, 0x03, 0x98, 0xc6, 0x99, 0xf3, 0xf3, 0xcd, 0xbf, 0xf2, 0x53,
0x8a, 0x39, 0x37, 0x1c, 0xd0, 0xab, 0x7d, 0x2e, 0xe8, 0x36, 0x75, 0x64, 0x84, 0x76, 0x87, 0x0a, 0x49, 0x14, 0x73, 0x6e, 0x18, 0x80, 0xaf, 0xf4, 0x19, 0x27, 0x3b, 0xc4, 0x91, 0x11, 0xda, 0x5d,
0xae, 0x7f, 0xba, 0x55, 0xd1, 0x56, 0xe6, 0xda, 0x9b, 0xa3, 0xa1, 0x31, 0x97, 0x13, 0x31, 0xff, 0xc2, 0x99, 0xfe, 0xc9, 0x76, 0x55, 0x5b, 0x5d, 0xe8, 0x6c, 0x8d, 0x86, 0xc6, 0x42, 0x4e, 0xc4,
0x1e, 0x1a, 0xb5, 0xdc, 0x1b, 0x13, 0x46, 0xbb, 0xbc, 0x87, 0x05, 0x75, 0x7c, 0xdc, 0xe1, 0xb5, 0xfc, 0x6b, 0x68, 0xd4, 0x73, 0x6f, 0x4c, 0x14, 0xef, 0xb1, 0x1e, 0xe2, 0xc4, 0x09, 0x50, 0x97,
0x2e, 0x5b, 0xed, 0x50, 0xb1, 0x4d, 0x89, 0xef, 0x56, 0xdb, 0x54, 0x0c, 0x88, 0x23, 0x58, 0xb4, 0xd5, 0x3d, 0xba, 0xd6, 0x25, 0x7c, 0x87, 0xe0, 0xc0, 0xad, 0x75, 0x08, 0x1f, 0x60, 0x87, 0xd3,
0x66, 0x2d, 0x4c, 0xe8, 0xb7, 0xa9, 0xe0, 0x68, 0x1b, 0x1e, 0xcd, 0x92, 0x98, 0xac, 0x12, 0xd7, 0x78, 0xdd, 0xaa, 0x4c, 0xe8, 0x77, 0x08, 0x67, 0x70, 0x07, 0x3c, 0x9a, 0x25, 0x31, 0x59, 0xc5,
0x76, 0x3c, 0xe2, 0xec, 0x84, 0x8c, 0x06, 0x42, 0xff, 0x6c, 0x4b, 0xde, 0x76, 0x8f, 0x4d, 0x0b, 0xae, 0xed, 0xf8, 0xd8, 0xd9, 0x8d, 0x28, 0x09, 0xb9, 0xfe, 0xe9, 0xb6, 0xbc, 0xed, 0x1e, 0x9b,
0x33, 0x43, 0x5a, 0x59, 0x37, 0x3e, 0x97, 0xea, 0x8c, 0x17, 0x91, 0x0b, 0xa7, 0xd2, 0x1c, 0xee, 0x16, 0x66, 0x86, 0xb4, 0xb2, 0x6e, 0x7c, 0x36, 0xd5, 0x19, 0x2f, 0x42, 0x17, 0x9c, 0x4a, 0x73,
0xeb, 0xe6, 0xf3, 0x03, 0xbb, 0x49, 0x7b, 0x6e, 0x3f, 0x2f, 0x2f, 0xc2, 0xb1, 0x6d, 0x1a, 0x60, 0x78, 0xa0, 0x9b, 0xcf, 0x66, 0x76, 0x93, 0xf6, 0xdc, 0x41, 0x5e, 0x5e, 0x00, 0xc7, 0x76, 0x48,
0x9f, 0xde, 0x99, 0x54, 0xff, 0xe2, 0xc0, 0xea, 0x8b, 0x19, 0x7f, 0x6c, 0x34, 0x3f, 0xd4, 0xa0, 0x88, 0x02, 0x72, 0x77, 0x52, 0xfd, 0xf3, 0x99, 0xd5, 0x97, 0x32, 0xfe, 0xd8, 0x68, 0xbe, 0xaf,
0x10, 0x3f, 0x98, 0xe8, 0x32, 0x94, 0xb3, 0x6c, 0x0d, 0x48, 0xc4, 0x29, 0x0b, 0x74, 0x4d, 0xd6, 0x81, 0x82, 0x78, 0x30, 0xe1, 0x65, 0x50, 0xce, 0xb2, 0x35, 0xc0, 0x31, 0x23, 0x34, 0xd4, 0x35,
0xa7, 0x3c, 0x59, 0x9f, 0x35, 0xd3, 0x2a, 0xa5, 0xc8, 0x5b, 0x0a, 0x88, 0x36, 0xa0, 0x94, 0xa6, 0x59, 0x9f, 0xf2, 0x64, 0x7d, 0xd6, 0x4d, 0xab, 0x94, 0x22, 0x6f, 0x2b, 0x20, 0xdc, 0x04, 0xa5,
0x20, 0xe5, 0xce, 0x4c, 0xe1, 0xce, 0x27, 0xc0, 0x94, 0x7a, 0x0c, 0x1e, 0x92, 0x27, 0x4c, 0x9f, 0x34, 0x05, 0x29, 0x77, 0x6e, 0x0a, 0x77, 0x31, 0x01, 0xa6, 0xd4, 0x63, 0xe0, 0x7f, 0xf2, 0x84,
0x95, 0x57, 0xa2, 0xfa, 0x31, 0xdf, 0x9f, 0x01, 0x74, 0xef, 0x29, 0x42, 0x3d, 0x28, 0xe3, 0x6e, 0xe9, 0xf3, 0xf2, 0x4a, 0x54, 0x3f, 0xe6, 0xbb, 0x73, 0x00, 0xde, 0x7f, 0x8a, 0x60, 0x0f, 0x94,
0x37, 0x22, 0xdd, 0x5c, 0x17, 0xa9, 0x4d, 0xb6, 0x27, 0xce, 0xd7, 0xda, 0xf9, 0x8d, 0x66, 0xdc, 0x91, 0xe7, 0xc5, 0xd8, 0xcb, 0x75, 0x91, 0xda, 0x64, 0x67, 0xe2, 0x7c, 0xad, 0x9f, 0xdf, 0x6c,
0x46, 0xe7, 0x0e, 0xda, 0x46, 0x3e, 0xe5, 0xc2, 0x2a, 0xe5, 0xb4, 0x65, 0x07, 0x5d, 0x82, 0x82, 0x89, 0x36, 0x3a, 0x37, 0x6b, 0x1b, 0x05, 0x84, 0x71, 0xab, 0x94, 0xd3, 0x96, 0x1d, 0x74, 0x09,
0x7c, 0x16, 0x67, 0x64, 0x8a, 0xcf, 0x4c, 0x49, 0x71, 0x6e, 0x83, 0xf2, 0x71, 0x94, 0x1c, 0x74, 0x14, 0xe4, 0xb3, 0x38, 0x27, 0x53, 0x7c, 0x66, 0x4a, 0x8a, 0x73, 0x1b, 0x94, 0x8f, 0xa3, 0xe4,
0x16, 0x4a, 0x34, 0x70, 0xfc, 0x7e, 0x1c, 0xa4, 0xed, 0x12, 0x1f, 0xef, 0x26, 0x11, 0xce, 0x67, 0xc0, 0xb3, 0xa0, 0x44, 0x42, 0x27, 0xe8, 0x8b, 0x20, 0x6d, 0x17, 0x07, 0x68, 0x2f, 0x89, 0x70,
0xe6, 0xab, 0xb1, 0x15, 0x9d, 0x86, 0xf9, 0x30, 0x62, 0x21, 0xe3, 0x24, 0x4a, 0xde, 0xb7, 0x82, 0x31, 0x33, 0x5f, 0x13, 0x56, 0x78, 0x1a, 0x2c, 0x46, 0x31, 0x8d, 0x28, 0xc3, 0x71, 0xf2, 0xbe,
0xc4, 0x1d, 0x4d, 0xad, 0xf2, 0x7e, 0x36, 0xdf, 0xd3, 0x60, 0x21, 0xe7, 0xe9, 0x26, 0x8e, 0xba, 0x15, 0x24, 0xee, 0x68, 0x6a, 0x95, 0xf7, 0xb3, 0xf9, 0x81, 0x06, 0x2a, 0x39, 0x4f, 0xb7, 0x50,
0x44, 0x20, 0x94, 0x0c, 0x4a, 0x5a, 0x6e, 0x4e, 0x3a, 0x0f, 0x30, 0x9e, 0x4c, 0x92, 0x3a, 0x2c, 0xec, 0x61, 0x0e, 0x61, 0x32, 0x28, 0x69, 0xb9, 0x39, 0xe9, 0x0a, 0xa8, 0xe4, 0x27, 0x3b, 0x79,
0x8c, 0x86, 0xc6, 0xd1, 0x71, 0x1d, 0xe2, 0xfb, 0xfa, 0x48, 0x36, 0x92, 0xa0, 0x06, 0x14, 0x43, 0x7d, 0x27, 0xe5, 0xa8, 0x8c, 0x86, 0xc6, 0xd1, 0x71, 0x39, 0xc4, 0xb5, 0x5d, 0xea, 0x8e, 0xa7,
0x2c, 0xab, 0x27, 0x29, 0xb3, 0xd3, 0x28, 0xa0, 0x50, 0x31, 0xc7, 0x7c, 0x0d, 0x4e, 0xed, 0x09, 0x1d, 0x71, 0x61, 0xc3, 0x26, 0x28, 0x46, 0x48, 0x96, 0x52, 0x12, 0xe7, 0xa7, 0x11, 0x81, 0x42,
0xfc, 0x4a, 0xe0, 0x6e, 0xf6, 0xb9, 0x60, 0xee, 0x6e, 0x9b, 0x8a, 0x2c, 0x77, 0xda, 0xbf, 0xc8, 0x09, 0x8e, 0xf9, 0x2a, 0x38, 0xb5, 0x2f, 0x0b, 0x57, 0x43, 0x77, 0xab, 0xcf, 0x38, 0x75, 0xf7,
0x9d, 0x01, 0x45, 0x47, 0x29, 0xc5, 0x25, 0x96, 0x21, 0x1c, 0xb6, 0xc0, 0xc9, 0xc4, 0xcd, 0x37, 0x3a, 0x84, 0x67, 0x89, 0xd4, 0xfe, 0x41, 0x22, 0x0d, 0x50, 0x74, 0x94, 0x92, 0xa8, 0xb7, 0x0c,
0x35, 0x28, 0x5d, 0xcf, 0x06, 0x99, 0x36, 0x16, 0x8e, 0x87, 0x5a, 0x93, 0x03, 0x99, 0x76, 0xe0, 0xe4, 0xb0, 0x05, 0x9c, 0x4c, 0xdc, 0x7c, 0x43, 0x03, 0xa5, 0x1b, 0xd9, 0x54, 0xd3, 0x41, 0xdc,
0x79, 0xac, 0x35, 0x39, 0x8f, 0xcd, 0x1c, 0x74, 0x1c, 0x33, 0x3f, 0xd0, 0xa0, 0xbc, 0xb9, 0xe7, 0xf1, 0x61, 0x7b, 0x72, 0x3a, 0xd3, 0x66, 0x1e, 0xce, 0xda, 0x93, 0xc3, 0xd9, 0xdc, 0xac, 0xb3,
0xd1, 0x43, 0x4f, 0xc2, 0xa1, 0xb0, 0xdf, 0xd9, 0x21, 0xbb, 0xe9, 0x16, 0xcc, 0xd1, 0xd0, 0x58, 0x99, 0xf9, 0x9e, 0x06, 0xca, 0x5b, 0xfb, 0x5e, 0x40, 0xf8, 0x24, 0x38, 0x14, 0xf5, 0xbb, 0xbb,
0xce, 0x4f, 0x66, 0x6b, 0xeb, 0xb9, 0xc9, 0x4c, 0x76, 0xaa, 0x95, 0x52, 0xd0, 0x15, 0x40, 0xe9, 0x78, 0x2f, 0xdd, 0x82, 0x39, 0x1a, 0x1a, 0x2b, 0xf9, 0x31, 0x6d, 0x7d, 0x23, 0x37, 0xa6, 0xc9,
0x03, 0x9c, 0x9b, 0x64, 0x66, 0xe4, 0xa3, 0x89, 0xee, 0x6d, 0x71, 0x6b, 0x21, 0x41, 0x67, 0xc3, 0xb6, 0xb5, 0x52, 0x0a, 0xbc, 0x0a, 0x60, 0xfa, 0x1a, 0xe7, 0xc6, 0x9a, 0x39, 0xf9, 0x82, 0xc2,
0x0c, 0x6f, 0xcf, 0x7d, 0x77, 0x77, 0x59, 0xfb, 0xfe, 0xee, 0xb2, 0xf6, 0xdb, 0xdd, 0x65, 0xad, 0xfb, 0xfb, 0xdd, 0xaa, 0x24, 0xe8, 0x6c, 0xb2, 0x61, 0x9d, 0x85, 0x6f, 0xef, 0xad, 0x68, 0xdf,
0xf3, 0xb0, 0x1c, 0xc2, 0x2f, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0xe4, 0xf3, 0xfa, 0x56, 0x5f, 0xdd, 0x5b, 0xd1, 0x7e, 0xbd, 0xb7, 0xa2, 0x75, 0xff, 0x2f, 0x27, 0xf2, 0x0b, 0x7f, 0x07, 0x00,
0x0c, 0x00, 0x00, 0x00, 0xff, 0xff, 0x70, 0x1e, 0x6a, 0xd1, 0x6c, 0x0c, 0x00, 0x00,
} }
func (m *BeaconState) Marshal() (dAtA []byte, err error) { func (m *BeaconState) Marshal() (dAtA []byte, err error) {
@ -1176,11 +1176,11 @@ func (m *AttestationTarget) MarshalTo(dAtA []byte) (int, error) {
i++ i++
i = encodeVarintTypes(dAtA, i, uint64(m.Slot)) i = encodeVarintTypes(dAtA, i, uint64(m.Slot))
} }
if len(m.BlockRoot) > 0 { if len(m.BeaconBlockRoot) > 0 {
dAtA[i] = 0x12 dAtA[i] = 0x12
i++ i++
i = encodeVarintTypes(dAtA, i, uint64(len(m.BlockRoot))) i = encodeVarintTypes(dAtA, i, uint64(len(m.BeaconBlockRoot)))
i += copy(dAtA[i:], m.BlockRoot) i += copy(dAtA[i:], m.BeaconBlockRoot)
} }
if len(m.ParentRoot) > 0 { if len(m.ParentRoot) > 0 {
dAtA[i] = 0x1a dAtA[i] = 0x1a
@ -1523,7 +1523,7 @@ func (m *AttestationTarget) Size() (n int) {
if m.Slot != 0 { if m.Slot != 0 {
n += 1 + sovTypes(uint64(m.Slot)) n += 1 + sovTypes(uint64(m.Slot))
} }
l = len(m.BlockRoot) l = len(m.BeaconBlockRoot)
if l > 0 { if l > 0 {
n += 1 + l + sovTypes(uint64(l)) n += 1 + l + sovTypes(uint64(l))
} }
@ -2926,9 +2926,9 @@ func (m *AttestationTarget) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
m.BlockRoot = append(m.BlockRoot[:0], dAtA[iNdEx:postIndex]...) m.BeaconBlockRoot = append(m.BeaconBlockRoot[:0], dAtA[iNdEx:postIndex]...)
if m.BlockRoot == nil { if m.BeaconBlockRoot == nil {
m.BlockRoot = []byte{} m.BeaconBlockRoot = []byte{}
} }
iNdEx = postIndex iNdEx = postIndex
case 3: 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 { switch fieldNum {
case 1: case 1:
if wireType != 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 var byteLen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -5864,7 +5864,7 @@ func (m *BlockTreeResponse_TreeNode) Unmarshal(dAtA []byte) error {
iNdEx = postIndex iNdEx = postIndex
case 2: case 2:
if wireType != 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 var byteLen int
for shift := uint(0); ; shift += 7 { 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( go_proto_library(
name = "go_default_library", name = "go_default_library",
compiler = "//:grpc_proto_compiler", 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 { switch fieldNum {
case 1: case 1:
if wireType != 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 var byteLen int
for shift := uint(0); ; shift += 7 { for shift := uint(0); ; shift += 7 {
@ -3795,7 +3795,7 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
switch fieldNum { switch fieldNum {
case 1: case 1:
if wireType != 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 var byteLen int
for shift := uint(0); ; shift += 7 { 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) { func (Person_PhoneType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{2, 0} return fileDescriptor_1f902154cb7707ef, []int{3, 0}
} }
type TestMessage struct { type TestMessage struct {
@ -107,6 +107,61 @@ func (m *TestMessage) GetBar() string {
return "" 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 { type Puzzle struct {
Challenge string `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"` Challenge string `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
Answer string `protobuf:"bytes,2,opt,name=answer,proto3" json:"answer,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 (m *Puzzle) String() string { return proto.CompactTextString(m) }
func (*Puzzle) ProtoMessage() {} func (*Puzzle) ProtoMessage() {}
func (*Puzzle) Descriptor() ([]byte, []int) { func (*Puzzle) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{1} return fileDescriptor_1f902154cb7707ef, []int{2}
} }
func (m *Puzzle) XXX_Unmarshal(b []byte) error { func (m *Puzzle) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -177,7 +232,7 @@ func (m *Person) Reset() { *m = Person{} }
func (m *Person) String() string { return proto.CompactTextString(m) } func (m *Person) String() string { return proto.CompactTextString(m) }
func (*Person) ProtoMessage() {} func (*Person) ProtoMessage() {}
func (*Person) Descriptor() ([]byte, []int) { func (*Person) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{2} return fileDescriptor_1f902154cb7707ef, []int{3}
} }
func (m *Person) XXX_Unmarshal(b []byte) error { func (m *Person) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) 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 (m *Person_PhoneNumber) String() string { return proto.CompactTextString(m) }
func (*Person_PhoneNumber) ProtoMessage() {} func (*Person_PhoneNumber) ProtoMessage() {}
func (*Person_PhoneNumber) Descriptor() ([]byte, []int) { 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 { func (m *Person_PhoneNumber) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -307,7 +362,7 @@ func (m *AddressBook) Reset() { *m = AddressBook{} }
func (m *AddressBook) String() string { return proto.CompactTextString(m) } func (m *AddressBook) String() string { return proto.CompactTextString(m) }
func (*AddressBook) ProtoMessage() {} func (*AddressBook) ProtoMessage() {}
func (*AddressBook) Descriptor() ([]byte, []int) { func (*AddressBook) Descriptor() ([]byte, []int) {
return fileDescriptor_1f902154cb7707ef, []int{3} return fileDescriptor_1f902154cb7707ef, []int{4}
} }
func (m *AddressBook) XXX_Unmarshal(b []byte) error { func (m *AddressBook) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -346,6 +401,7 @@ func (m *AddressBook) GetPeople() []*Person {
func init() { func init() {
proto.RegisterEnum("testing.Person_PhoneType", Person_PhoneType_name, Person_PhoneType_value) proto.RegisterEnum("testing.Person_PhoneType", Person_PhoneType_name, Person_PhoneType_value)
proto.RegisterType((*TestMessage)(nil), "testing.TestMessage") proto.RegisterType((*TestMessage)(nil), "testing.TestMessage")
proto.RegisterType((*TestNestedMessage)(nil), "testing.TestNestedMessage")
proto.RegisterType((*Puzzle)(nil), "testing.Puzzle") proto.RegisterType((*Puzzle)(nil), "testing.Puzzle")
proto.RegisterType((*Person)(nil), "testing.Person") proto.RegisterType((*Person)(nil), "testing.Person")
proto.RegisterType((*Person_PhoneNumber)(nil), "testing.Person.PhoneNumber") proto.RegisterType((*Person_PhoneNumber)(nil), "testing.Person.PhoneNumber")
@ -355,35 +411,37 @@ func init() {
func init() { proto.RegisterFile("proto/testing/test.proto", fileDescriptor_1f902154cb7707ef) } func init() { proto.RegisterFile("proto/testing/test.proto", fileDescriptor_1f902154cb7707ef) }
var fileDescriptor_1f902154cb7707ef = []byte{ var fileDescriptor_1f902154cb7707ef = []byte{
// 444 bytes of a gzipped FileDescriptorProto // 478 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xd1, 0x8a, 0xd3, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xdd, 0x8a, 0xd3, 0x40,
0x14, 0x86, 0x4d, 0xda, 0x46, 0x7b, 0xb2, 0xac, 0x65, 0x10, 0x89, 0x5d, 0x69, 0x4b, 0x6e, 0x2c, 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, 0xad, 0x2d, 0x43, 0xc5, 0x4b, 0x99, 0x48, 0x53, 0xec, 0x82, 0x17, 0x0b, 0x0a, 0x16, 0x16, 0x14, 0xed, 0xb6, 0x0c, 0x15, 0x2f, 0x65,
0x34, 0xa7, 0x69, 0x30, 0xc9, 0x0c, 0x99, 0x09, 0xb2, 0x79, 0x33, 0xdf, 0xc0, 0x4b, 0x9f, 0x40, 0xd2, 0x7c, 0x4d, 0x83, 0x49, 0x26, 0x64, 0x26, 0xc8, 0xe6, 0xcd, 0x7c, 0x03, 0x2f, 0x7d, 0x02,
0xa4, 0x8f, 0xe0, 0x13, 0xc8, 0x4c, 0x66, 0xad, 0x88, 0x57, 0xf9, 0xcf, 0x9f, 0x6f, 0xfe, 0x99, 0x91, 0x3e, 0x82, 0x4f, 0x20, 0x33, 0x99, 0xee, 0x2e, 0xe2, 0x55, 0xce, 0x77, 0xe6, 0xe4, 0xcc,
0xf3, 0x43, 0x20, 0x2a, 0xae, 0xf8, 0x5c, 0xa1, 0x54, 0x59, 0x99, 0x9a, 0x6f, 0x64, 0x2c, 0x72, 0x39, 0xf3, 0x81, 0x5f, 0x94, 0x42, 0x89, 0xa9, 0x42, 0xa9, 0x92, 0x3c, 0x36, 0xdf, 0xc0, 0x50,
0xd7, 0x7a, 0xc3, 0x71, 0xca, 0x79, 0x9a, 0xe3, 0xdc, 0xd8, 0x71, 0xbd, 0x9f, 0xab, 0xac, 0x40, 0xe4, 0xbe, 0xe5, 0x06, 0xa3, 0x58, 0x88, 0x38, 0xc5, 0xa9, 0xa1, 0xc3, 0x6a, 0x3b, 0x55, 0x49,
0xa9, 0x58, 0x21, 0x5a, 0x72, 0x38, 0x4b, 0x33, 0x75, 0xa8, 0xe3, 0x68, 0xc7, 0x8b, 0x79, 0xca, 0x86, 0x52, 0xf1, 0xac, 0x68, 0x94, 0x83, 0x49, 0x9c, 0xa8, 0x5d, 0x15, 0x06, 0x1b, 0x91, 0x4d,
0x53, 0x7e, 0x22, 0xf5, 0xd4, 0x5e, 0xa0, 0x55, 0x8b, 0x87, 0x14, 0xfc, 0x2d, 0x4a, 0xb5, 0x42, 0x63, 0x11, 0x8b, 0x5b, 0xa5, 0x9e, 0x9a, 0x0b, 0x34, 0x6a, 0xe4, 0x94, 0x81, 0xb7, 0x46, 0xa9,
0x29, 0x59, 0x8a, 0x64, 0x00, 0x9d, 0x3d, 0xe7, 0x81, 0x33, 0x71, 0xa6, 0x7d, 0xaa, 0x25, 0x79, 0x16, 0x28, 0x25, 0x8f, 0x91, 0xf4, 0xa1, 0xbd, 0x15, 0xc2, 0x77, 0xc6, 0xce, 0x59, 0x8f, 0x69,
0x06, 0x9d, 0x98, 0x55, 0x81, 0xab, 0x9d, 0xe5, 0xf8, 0xd7, 0x8f, 0xf1, 0xc5, 0x3e, 0x6b, 0x9a, 0x48, 0x5e, 0x42, 0x3b, 0xe4, 0xa5, 0xdf, 0xd2, 0xcc, 0x7c, 0xf4, 0xe7, 0xd7, 0xe8, 0x74, 0x9b,
0xab, 0x30, 0xae, 0x9b, 0x26, 0x9c, 0x48, 0x81, 0xbb, 0x59, 0xc9, 0x0a, 0xbc, 0x0a, 0x63, 0xd6, 0xd4, 0xf5, 0x05, 0x0d, 0xab, 0xba, 0xa6, 0x63, 0x59, 0xe0, 0x66, 0x92, 0xf3, 0x0c, 0x2f, 0x68,
0x84, 0x54, 0xb3, 0xe1, 0x4b, 0xf0, 0x36, 0x75, 0xd3, 0xe4, 0x48, 0x1e, 0x43, 0x7f, 0x77, 0x60, 0xc8, 0x6b, 0xca, 0xb4, 0x96, 0x2e, 0xe1, 0x91, 0xf6, 0xbc, 0x42, 0xa9, 0x30, 0x3a, 0x38, 0x13,
0x79, 0x8e, 0x65, 0x8a, 0x36, 0xf4, 0x64, 0x90, 0x87, 0xe0, 0xb1, 0x52, 0x7e, 0x41, 0x9b, 0x4e, 0xe8, 0x6c, 0xab, 0xba, 0xb6, 0xd6, 0x06, 0x93, 0x67, 0xd0, 0xce, 0x64, 0x6c, 0xbc, 0xbd, 0xd9,
0xed, 0x14, 0x7e, 0x75, 0xc1, 0xdb, 0x60, 0x25, 0x79, 0x49, 0x08, 0x74, 0x75, 0xba, 0x3d, 0x6b, 0x49, 0x60, 0x3b, 0x06, 0x77, 0x02, 0x31, 0x2d, 0xa0, 0x6f, 0xc0, 0x5d, 0x55, 0x75, 0x9d, 0x22,
0x34, 0x39, 0x07, 0x37, 0x4b, 0xcc, 0x91, 0x1e, 0x75, 0xb3, 0x84, 0x3c, 0x80, 0x1e, 0x16, 0x2c, 0x79, 0x0a, 0xbd, 0xcd, 0x8e, 0xa7, 0x29, 0xe6, 0x31, 0x5a, 0xab, 0x5b, 0x82, 0x3c, 0x06, 0x97,
0xcb, 0x83, 0x8e, 0x81, 0xda, 0x81, 0x5c, 0x82, 0x27, 0x0e, 0xbc, 0x44, 0x19, 0x74, 0x27, 0x9d, 0xe7, 0xf2, 0x1b, 0xda, 0xb8, 0xcc, 0x4e, 0xf4, 0x7b, 0x0b, 0xdc, 0x15, 0x96, 0x52, 0xe4, 0x3a,
0xa9, 0xbf, 0xb8, 0x88, 0x6c, 0x85, 0x51, 0x1b, 0x1d, 0x6d, 0xf4, 0xdf, 0xf7, 0x75, 0x11, 0x63, 0x86, 0x8e, 0x7b, 0x88, 0xa1, 0x31, 0x39, 0x86, 0x56, 0x12, 0x99, 0x5f, 0xba, 0xac, 0x95, 0x44,
0x45, 0x2d, 0x4a, 0x5e, 0xc0, 0x59, 0xce, 0xa4, 0xfa, 0x54, 0x8b, 0x84, 0x29, 0x4c, 0x82, 0xde, 0xe4, 0x04, 0xba, 0x98, 0xf1, 0x24, 0xf5, 0xdb, 0x46, 0xd4, 0x0c, 0xe4, 0x1c, 0xdc, 0x62, 0x27,
0xc4, 0x99, 0xfa, 0x8b, 0x61, 0xd4, 0x96, 0x1e, 0xdd, 0x56, 0x19, 0x6d, 0x6f, 0x4b, 0xa7, 0xbe, 0x72, 0x94, 0x7e, 0x67, 0xdc, 0x3e, 0xf3, 0x66, 0xa7, 0x37, 0x79, 0x1b, 0xeb, 0x60, 0xa5, 0x4f,
0xe6, 0x3f, 0xb4, 0xf8, 0x70, 0x0b, 0xfe, 0x5f, 0xa9, 0x7a, 0xbf, 0xd2, 0x28, 0xfb, 0x7c, 0x3b, 0xaf, 0xaa, 0x2c, 0xc4, 0x92, 0x59, 0x29, 0x79, 0x0d, 0x47, 0x29, 0x97, 0xea, 0x4b, 0x55, 0x44,
0x91, 0x19, 0x74, 0xd5, 0x8d, 0x40, 0xb3, 0xc2, 0xf9, 0xe2, 0xd1, 0x7f, 0x1f, 0xb6, 0xbd, 0x11, 0x5c, 0x61, 0xe4, 0x77, 0x4d, 0xd5, 0x41, 0xd0, 0x6c, 0x31, 0x38, 0xec, 0x26, 0x58, 0x1f, 0xb6,
0x48, 0x0d, 0x16, 0x3e, 0x85, 0xfe, 0x1f, 0x8b, 0x00, 0x78, 0xab, 0xf5, 0xf2, 0xcd, 0xbb, 0xeb, 0xc8, 0x3c, 0xad, 0xff, 0xd4, 0xc8, 0x07, 0x6b, 0xf0, 0xee, 0xb8, 0xea, 0x7e, 0xb9, 0x41, 0x36,
0xc1, 0x1d, 0x72, 0x0f, 0xba, 0xaf, 0xd7, 0xab, 0xeb, 0x81, 0xa3, 0xd5, 0xc7, 0x35, 0x7d, 0x3b, 0xbe, 0x9d, 0xc8, 0x04, 0x3a, 0xea, 0xba, 0x40, 0x53, 0xe1, 0x78, 0xf6, 0xe4, 0xbf, 0xc1, 0xd6,
0x70, 0xc3, 0xe7, 0xe0, 0xbf, 0x4a, 0x92, 0x0a, 0xa5, 0x5c, 0x72, 0xfe, 0x99, 0x3c, 0x01, 0x4f, 0xd7, 0x05, 0x32, 0x23, 0xa3, 0x2f, 0xa0, 0x77, 0x43, 0x11, 0x00, 0x77, 0xb1, 0x9c, 0xbf, 0xff,
0x20, 0x17, 0xb9, 0x6e, 0x50, 0xb7, 0x70, 0xff, 0x9f, 0xcb, 0xa8, 0xfd, 0xbd, 0x3c, 0xfb, 0x76, 0x78, 0xd9, 0xbf, 0x47, 0x1e, 0x40, 0xe7, 0xdd, 0x72, 0x71, 0xd9, 0x77, 0x34, 0xfa, 0xbc, 0x64,
0x1c, 0x39, 0xdf, 0x8f, 0x23, 0xe7, 0xe7, 0x71, 0xe4, 0xc4, 0x9e, 0xd9, 0xf4, 0xf2, 0x77, 0x00, 0x1f, 0xfa, 0x2d, 0xfa, 0x0a, 0xbc, 0xb7, 0x51, 0x54, 0xa2, 0x94, 0x73, 0x21, 0xbe, 0x92, 0xe7,
0x00, 0x00, 0xff, 0xff, 0x12, 0x4a, 0xad, 0xd0, 0x91, 0x02, 0x00, 0x00, 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) { func (m *TestMessage) Marshal() (dAtA []byte, err error) {
@ -419,6 +477,43 @@ func (m *TestMessage) MarshalTo(dAtA []byte) (int, error) {
return i, nil 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) { func (m *Puzzle) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
@ -500,11 +595,11 @@ func (m *Person) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a dAtA[i] = 0x2a
i++ i++
i = encodeVarintTest(dAtA, i, uint64(m.LastUpdated.Size())) 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 { if err != nil {
return 0, err return 0, err
} }
i += n1 i += n2
} }
if m.XXX_unrecognized != nil { if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized) i += copy(dAtA[i:], m.XXX_unrecognized)
@ -606,6 +701,26 @@ func (m *TestMessage) Size() (n int) {
return n 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) { func (m *Puzzle) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
@ -827,6 +942,128 @@ func (m *TestMessage) Unmarshal(dAtA []byte) error {
} }
return nil 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 { func (m *Puzzle) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 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" pb "github.com/prysmaticlabs/prysm/proto/testing"
) )
const baz = "baz"
const foo = "foo"
func TestOverrideSpecName(t *testing.T) { func TestOverrideSpecName(t *testing.T) {
input := struct { input := struct {
Foo string `json:"foo"` Foo string `json:"foo"`
@ -19,10 +22,10 @@ func TestOverrideSpecName(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
if output.Foo != "foo" { if output.Foo != foo {
t.Error("Expected output.Foo to be 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") t.Errorf("Expected output.Bar to be baz")
} }
} }
@ -53,10 +56,10 @@ func TestOverrideSpecName_NestedProto(t *testing.T) {
if output.Fuzz != "fuzz" { if output.Fuzz != "fuzz" {
t.Error("Expected output.fuzz to be 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") 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") t.Errorf("Expected output.Msg.Bar to be baz")
} }
} }