diff --git a/proto/beacon/db/attestation_container.pb.go b/proto/beacon/db/attestation_container.pb.go index 077567e979b..462366c1363 100755 --- a/proto/beacon/db/attestation_container.pb.go +++ b/proto/beacon/db/attestation_container.pb.go @@ -5,14 +5,13 @@ package db import ( fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" + io "io" + math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/db/finalized_block_root_container.pb.go b/proto/beacon/db/finalized_block_root_container.pb.go index f1cbb44283c..446e609773f 100755 --- a/proto/beacon/db/finalized_block_root_container.pb.go +++ b/proto/beacon/db/finalized_block_root_container.pb.go @@ -5,11 +5,10 @@ package db import ( fmt "fmt" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" - - proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/db/powchain.pb.go b/proto/beacon/db/powchain.pb.go index 297a2fb6062..4cb1b16ebaa 100755 --- a/proto/beacon/db/powchain.pb.go +++ b/proto/beacon/db/powchain.pb.go @@ -5,13 +5,12 @@ package db import ( fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - proto "github.com/gogo/protobuf/proto" v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" + io "io" + math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/p2p/v1/archive.pb.go b/proto/beacon/p2p/v1/archive.pb.go index dd6dbdf6917..f6388922948 100755 --- a/proto/beacon/p2p/v1/archive.pb.go +++ b/proto/beacon/p2p/v1/archive.pb.go @@ -5,13 +5,12 @@ package ethereum_beacon_p2p_v1 import ( fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" + io "io" + math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/p2p/v1/messages.pb.go b/proto/beacon/p2p/v1/messages.pb.go index 7f8bcc84587..b31b2426d28 100755 --- a/proto/beacon/p2p/v1/messages.pb.go +++ b/proto/beacon/p2p/v1/messages.pb.go @@ -5,12 +5,11 @@ package ethereum_beacon_p2p_v1 import ( fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" - - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/p2p/v1/types.pb.go b/proto/beacon/p2p/v1/types.pb.go index 6371f0bb5ca..b7f668e5195 100755 --- a/proto/beacon/p2p/v1/types.pb.go +++ b/proto/beacon/p2p/v1/types.pb.go @@ -5,14 +5,13 @@ package ethereum_beacon_p2p_v1 import ( fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" + io "io" + math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. @@ -469,85 +468,152 @@ func (m *HistoricalBatch) GetStateRoots() [][]byte { return nil } +type StateSummary struct { + Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"` + Root []byte `protobuf:"bytes,2,opt,name=root,proto3" json:"root,omitempty"` + BoundaryRoot []byte `protobuf:"bytes,3,opt,name=boundary_root,json=boundaryRoot,proto3" json:"boundary_root,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StateSummary) Reset() { *m = StateSummary{} } +func (m *StateSummary) String() string { return proto.CompactTextString(m) } +func (*StateSummary) ProtoMessage() {} +func (*StateSummary) Descriptor() ([]byte, []int) { + return fileDescriptor_e719e7d82cfa7b0d, []int{5} +} +func (m *StateSummary) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StateSummary.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 *StateSummary) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateSummary.Merge(m, src) +} +func (m *StateSummary) XXX_Size() int { + return m.Size() +} +func (m *StateSummary) XXX_DiscardUnknown() { + xxx_messageInfo_StateSummary.DiscardUnknown(m) +} + +var xxx_messageInfo_StateSummary proto.InternalMessageInfo + +func (m *StateSummary) GetSlot() uint64 { + if m != nil { + return m.Slot + } + return 0 +} + +func (m *StateSummary) GetRoot() []byte { + if m != nil { + return m.Root + } + return nil +} + +func (m *StateSummary) GetBoundaryRoot() []byte { + if m != nil { + return m.BoundaryRoot + } + return nil +} + func init() { proto.RegisterType((*BeaconState)(nil), "ethereum.beacon.p2p.v1.BeaconState") proto.RegisterType((*Fork)(nil), "ethereum.beacon.p2p.v1.Fork") proto.RegisterType((*PendingAttestation)(nil), "ethereum.beacon.p2p.v1.PendingAttestation") proto.RegisterType((*ValidatorLatestVote)(nil), "ethereum.beacon.p2p.v1.ValidatorLatestVote") proto.RegisterType((*HistoricalBatch)(nil), "ethereum.beacon.p2p.v1.HistoricalBatch") + proto.RegisterType((*StateSummary)(nil), "ethereum.beacon.p2p.v1.StateSummary") } func init() { proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_e719e7d82cfa7b0d) } var fileDescriptor_e719e7d82cfa7b0d = []byte{ - // 1065 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6f, 0x1b, 0x45, - 0x14, 0x97, 0x53, 0x03, 0xed, 0xc4, 0x8d, 0xd3, 0x71, 0xd5, 0x2c, 0x69, 0xc8, 0x9a, 0x95, 0x68, - 0x23, 0xd4, 0xac, 0xb3, 0x4e, 0x62, 0x27, 0xa9, 0x68, 0xc5, 0xb6, 0x45, 0x05, 0x81, 0x84, 0x16, - 0x88, 0x84, 0x84, 0x58, 0x8d, 0x77, 0xc7, 0xbb, 0x43, 0xd6, 0x3b, 0xab, 0x9d, 0xb1, 0x95, 0x44, + // 1107 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xcd, 0x6f, 0xe3, 0x44, + 0x14, 0x57, 0xda, 0x00, 0xbb, 0xd3, 0xb4, 0xe9, 0x4e, 0x56, 0x5b, 0xd3, 0x2d, 0x75, 0x30, 0x62, + 0xb7, 0x42, 0x5b, 0xa7, 0x4e, 0xdb, 0xa4, 0xed, 0x8a, 0x5d, 0xe1, 0xdd, 0x45, 0x0b, 0x02, 0x09, + 0x79, 0xa1, 0x12, 0x02, 0x61, 0x4d, 0xec, 0x49, 0x3c, 0xd4, 0xf1, 0x58, 0x9e, 0x49, 0xd4, 0x56, 0x42, 0x1c, 0x38, 0x71, 0x40, 0x5c, 0xf8, 0x07, 0xe0, 0xbf, 0x00, 0x4e, 0x7c, 0x1c, 0x38, 0xf2, - 0x75, 0x81, 0x83, 0x85, 0x72, 0x03, 0x4e, 0xf8, 0xc8, 0x09, 0xcd, 0xec, 0xa7, 0x69, 0x0c, 0x3e, - 0x70, 0xdb, 0x79, 0xef, 0xf7, 0xfb, 0xbd, 0x37, 0xef, 0x3d, 0xbf, 0x31, 0x50, 0xa3, 0x98, 0x72, - 0xda, 0xea, 0x61, 0xe4, 0xd0, 0xb0, 0x15, 0xb5, 0xa3, 0xd6, 0xc8, 0x68, 0xf1, 0x93, 0x08, 0x33, - 0x5d, 0x7a, 0xe0, 0x35, 0xcc, 0x7d, 0x1c, 0xe3, 0xe1, 0x40, 0x4f, 0x30, 0x7a, 0xd4, 0x8e, 0xf4, - 0x91, 0xb1, 0xba, 0x8e, 0xb9, 0xdf, 0x1a, 0x19, 0x28, 0x88, 0x7c, 0x64, 0xb4, 0x10, 0xe7, 0x98, - 0x71, 0xc4, 0x89, 0x00, 0x08, 0xde, 0xaa, 0x3a, 0xe5, 0x4f, 0xb8, 0x76, 0x2f, 0xa0, 0xce, 0x51, - 0x0a, 0x58, 0x9b, 0x02, 0x8c, 0x50, 0x40, 0x5c, 0xc4, 0x69, 0x9c, 0x7a, 0x37, 0x3d, 0xc2, 0xfd, - 0x61, 0x4f, 0x77, 0xe8, 0xa0, 0xe5, 0x51, 0x8f, 0xb6, 0xa4, 0xb9, 0x37, 0xec, 0xcb, 0x53, 0x92, - 0xb4, 0xf8, 0x4a, 0xe0, 0xda, 0x87, 0x35, 0xb0, 0x68, 0xca, 0x18, 0xaf, 0x71, 0xc4, 0x31, 0xd4, - 0x40, 0xcd, 0xc3, 0x21, 0x66, 0x84, 0xd9, 0x9c, 0x0c, 0xb0, 0xf2, 0xdb, 0x13, 0xcd, 0xca, 0x46, - 0xd5, 0x5a, 0x4c, 0x8d, 0xaf, 0x93, 0x01, 0x86, 0x0d, 0x50, 0x65, 0x01, 0xe5, 0xca, 0xef, 0x89, - 0x4f, 0x1e, 0xa0, 0x01, 0xaa, 0x7d, 0x1a, 0x1f, 0x29, 0x7f, 0x08, 0xe3, 0x62, 0x7b, 0x4d, 0x3f, - 0xff, 0xfa, 0xfa, 0x0b, 0x34, 0x3e, 0xb2, 0x24, 0x14, 0xbe, 0x09, 0x1a, 0x01, 0x12, 0xd7, 0x4f, - 0xae, 0x67, 0xfb, 0x18, 0xb9, 0x38, 0x56, 0xbe, 0xaf, 0x4b, 0x85, 0x8d, 0x42, 0x01, 0x73, 0x5f, - 0xcf, 0x2e, 0xac, 0x27, 0xd9, 0x9a, 0x82, 0xf1, 0x50, 0x12, 0xac, 0x2b, 0x89, 0x4a, 0xc9, 0x04, - 0xf7, 0xc0, 0x62, 0xa2, 0x19, 0x53, 0xca, 0x99, 0xf2, 0x43, 0xbd, 0x79, 0x61, 0xa3, 0x66, 0x5e, - 0x9b, 0x8c, 0x55, 0xc8, 0xd8, 0xe9, 0x26, 0x23, 0xa7, 0xf8, 0x40, 0xdb, 0x33, 0xf6, 0xdb, 0xb7, - 0xb6, 0xdb, 0x9a, 0x05, 0x24, 0xd6, 0x12, 0x50, 0xc1, 0x14, 0xfd, 0xc0, 0x29, 0xf3, 0xc7, 0xff, - 0x60, 0x4a, 0x6c, 0xc2, 0xb4, 0xc0, 0xb2, 0x4f, 0x18, 0xa7, 0x31, 0x71, 0x50, 0x90, 0xd2, 0x7f, - 0x4a, 0xe8, 0x37, 0x26, 0x63, 0x55, 0x2b, 0xe8, 0x77, 0x05, 0xb7, 0x29, 0xce, 0x03, 0x74, 0x7c, - 0xa0, 0x19, 0x9d, 0x6e, 0xb7, 0xdb, 0x36, 0x3a, 0x9a, 0x55, 0x2f, 0x04, 0x12, 0xcd, 0xe7, 0xc0, - 0x25, 0xcc, 0x7d, 0xc3, 0x76, 0x11, 0x47, 0xca, 0x67, 0x2b, 0xb2, 0x30, 0xea, 0x8c, 0xc2, 0x3c, - 0xe0, 0xbe, 0x71, 0x1f, 0x71, 0x64, 0x5d, 0xc4, 0xe9, 0x17, 0x7c, 0x0b, 0xd4, 0x73, 0xba, 0x3d, - 0xa2, 0x1c, 0x33, 0xe5, 0xf3, 0x95, 0xe6, 0x85, 0x39, 0x44, 0x4c, 0x38, 0x19, 0xab, 0x4b, 0x45, - 0x8a, 0x5b, 0xed, 0x1d, 0xcd, 0xba, 0x9c, 0x09, 0x1f, 0x0a, 0x29, 0xb8, 0x09, 0x60, 0xa2, 0x8e, - 0x23, 0xca, 0x08, 0xb7, 0x49, 0xe8, 0xe2, 0x63, 0xe5, 0x8b, 0x15, 0x39, 0x15, 0xcb, 0x12, 0x9b, - 0x78, 0x5e, 0x14, 0x0e, 0xf8, 0x36, 0x00, 0xf9, 0xb0, 0x32, 0xe5, 0x13, 0x55, 0xe6, 0xd1, 0x9c, - 0x91, 0xc7, 0x61, 0x86, 0x34, 0xaf, 0x4f, 0xc6, 0xea, 0x4a, 0x29, 0x91, 0xfd, 0xfd, 0x5d, 0xc3, - 0xe8, 0xb4, 0xbb, 0xdd, 0x6e, 0x47, 0xb3, 0x4a, 0x8a, 0x70, 0x0f, 0x5c, 0xec, 0xa1, 0x00, 0x85, - 0x0e, 0x66, 0xca, 0xa7, 0x42, 0xbd, 0xfa, 0xef, 0xdc, 0x1c, 0x0d, 0x6f, 0x83, 0x5a, 0x8c, 0x42, - 0x17, 0x51, 0x7b, 0x40, 0x8e, 0x31, 0x53, 0x3e, 0xb8, 0x29, 0xbb, 0xb6, 0x32, 0x19, 0xab, 0x8d, - 0xa2, 0x6b, 0x9d, 0xdd, 0xdd, 0xed, 0x8e, 0xec, 0xfa, 0x62, 0x82, 0x7e, 0x45, 0x80, 0x61, 0x1b, - 0x5c, 0x62, 0x01, 0x62, 0x3e, 0x09, 0x3d, 0xa6, 0xfc, 0xa9, 0xcb, 0xb8, 0x8d, 0xc9, 0x58, 0xad, - 0x4f, 0x8f, 0x8b, 0x66, 0x15, 0x30, 0xf8, 0x1e, 0xb8, 0x1e, 0xc5, 0x78, 0x44, 0xe8, 0x90, 0xd9, - 0x38, 0xa2, 0x8e, 0x6f, 0x97, 0xf6, 0x00, 0x53, 0x7e, 0xee, 0xc8, 0xda, 0x3c, 0x3b, 0xeb, 0x37, - 0xf4, 0x2a, 0x0e, 0x5d, 0x12, 0x7a, 0xcf, 0x17, 0x9c, 0x7f, 0xb4, 0x6b, 0x67, 0x6b, 0xbf, 0xa3, - 0x59, 0x4f, 0x66, 0x31, 0x1e, 0x88, 0x10, 0x25, 0x34, 0x83, 0xef, 0x82, 0x55, 0x67, 0x18, 0xc7, - 0x38, 0xe4, 0xe7, 0xc5, 0xff, 0xe5, 0xff, 0x89, 0xaf, 0xa4, 0x21, 0x1e, 0x0d, 0xcf, 0x00, 0x7c, - 0x67, 0xc8, 0x38, 0xe9, 0x13, 0x47, 0x5a, 0xec, 0x1e, 0xe1, 0x4c, 0xf9, 0xf2, 0x4e, 0xb3, 0xb2, - 0x51, 0x33, 0xef, 0x4d, 0xc6, 0x6a, 0xad, 0x28, 0x9e, 0xa1, 0xfd, 0x35, 0x56, 0x5b, 0xa5, 0xad, - 0x16, 0xc5, 0x27, 0x6c, 0x80, 0x38, 0x71, 0x02, 0xd4, 0x63, 0x2d, 0x8f, 0x6e, 0xf6, 0x08, 0xef, - 0x13, 0x1c, 0xb8, 0xba, 0x49, 0xf8, 0x08, 0x3b, 0x9c, 0xc6, 0x3b, 0xd6, 0x95, 0x29, 0x7d, 0x93, - 0x70, 0x06, 0xfb, 0xe0, 0xa9, 0xbc, 0xe8, 0xa9, 0x17, 0xbb, 0xb6, 0xe3, 0x63, 0xe7, 0x28, 0xa2, - 0x24, 0xe4, 0xca, 0x57, 0x77, 0xe4, 0xef, 0xeb, 0xe9, 0x19, 0x23, 0x79, 0x2f, 0x47, 0x5a, 0x79, - 0xf7, 0x5e, 0xca, 0x74, 0x0a, 0x27, 0x74, 0xc1, 0x5a, 0x56, 0xdb, 0x73, 0xc3, 0x7c, 0x3d, 0x77, - 0x98, 0xac, 0x47, 0xe7, 0x45, 0x79, 0x03, 0x5c, 0xed, 0x93, 0x10, 0x05, 0xe4, 0x74, 0x5a, 0xfd, - 0x9b, 0xb9, 0xd5, 0x1b, 0x39, 0xbf, 0x30, 0x6a, 0x1f, 0x57, 0x40, 0x55, 0xac, 0x68, 0x78, 0x1b, - 0x2c, 0xe7, 0xd5, 0x1a, 0xe1, 0x98, 0x11, 0x1a, 0x2a, 0x15, 0xd9, 0x9f, 0xe5, 0xe9, 0xfe, 0xec, - 0x68, 0x56, 0x3d, 0x43, 0x1e, 0x26, 0x40, 0xb8, 0x0f, 0xea, 0x59, 0x09, 0x32, 0xee, 0xc2, 0x0c, - 0xee, 0x52, 0x0a, 0xcc, 0xa8, 0x57, 0xc1, 0x63, 0x72, 0x22, 0x95, 0x0b, 0x72, 0x8d, 0x24, 0x07, - 0xed, 0xa3, 0x05, 0x00, 0x1f, 0x9d, 0x3a, 0x38, 0x00, 0xcb, 0xc8, 0xf3, 0x62, 0xec, 0x95, 0xa6, - 0x28, 0x49, 0xd2, 0x9c, 0x9a, 0xc7, 0xf6, 0xd6, 0xce, 0x9e, 0x18, 0xa3, 0x5b, 0xf3, 0x8e, 0x51, - 0x40, 0x18, 0xb7, 0xea, 0x25, 0x6d, 0x39, 0x41, 0x07, 0xa0, 0x2a, 0x17, 0xf1, 0x82, 0x2c, 0xf1, - 0x8d, 0x19, 0x25, 0x2e, 0x25, 0x28, 0xd7, 0xb1, 0xe4, 0xc0, 0x9b, 0xa0, 0x4e, 0x42, 0x27, 0x18, - 0x8a, 0x4b, 0xda, 0x2e, 0x0e, 0xd0, 0x49, 0x7a, 0xc3, 0xa5, 0xdc, 0x7c, 0x5f, 0x58, 0xe1, 0x33, - 0x60, 0x29, 0x8a, 0x69, 0x44, 0x19, 0x8e, 0xd3, 0x8d, 0x5a, 0x95, 0xb8, 0xcb, 0x99, 0x55, 0x6e, - 0x53, 0xed, 0x2e, 0x68, 0xe4, 0x3b, 0xf2, 0x65, 0xf9, 0xfe, 0x89, 0xa5, 0x5c, 0x94, 0xaf, 0x52, - 0x2a, 0x1f, 0x84, 0xa0, 0x2a, 0xde, 0xa3, 0xa4, 0x09, 0x96, 0xfc, 0xd6, 0xde, 0xaf, 0x80, 0xfa, - 0xc3, 0xfc, 0xb9, 0x31, 0x11, 0x77, 0x7c, 0xd8, 0x9d, 0x7e, 0x36, 0x2b, 0x73, 0xbf, 0x9a, 0xdd, - 0xe9, 0x57, 0x73, 0x61, 0xde, 0x47, 0xd3, 0xac, 0x7d, 0x7b, 0xb6, 0x5e, 0xf9, 0xee, 0x6c, 0xbd, - 0xf2, 0xeb, 0xd9, 0x7a, 0xa5, 0xf7, 0xb8, 0xfc, 0x53, 0xb2, 0xfd, 0x77, 0x00, 0x00, 0x00, 0xff, - 0xff, 0xaf, 0x4b, 0xd5, 0x03, 0x5d, 0x09, 0x00, 0x00, + 0x75, 0x81, 0x43, 0x84, 0x7a, 0x03, 0x4e, 0xe4, 0xc8, 0x09, 0xcd, 0xf8, 0x33, 0x6c, 0x03, 0x39, + 0xec, 0xcd, 0x7e, 0xef, 0xf7, 0xfb, 0xbd, 0x37, 0xef, 0x3d, 0xbf, 0x31, 0x50, 0xc3, 0x88, 0x72, + 0xda, 0xe8, 0x60, 0xe4, 0xd0, 0xa0, 0x11, 0x36, 0xc3, 0xc6, 0xd0, 0x68, 0xf0, 0x93, 0x10, 0x33, + 0x5d, 0x7a, 0xe0, 0x15, 0xcc, 0x3d, 0x1c, 0xe1, 0x41, 0x5f, 0x8f, 0x31, 0x7a, 0xd8, 0x0c, 0xf5, + 0xa1, 0xb1, 0xba, 0x8e, 0xb9, 0xd7, 0x18, 0x1a, 0xc8, 0x0f, 0x3d, 0x64, 0x34, 0x10, 0xe7, 0x98, + 0x71, 0xc4, 0x89, 0x00, 0x08, 0xde, 0xaa, 0x3a, 0xe1, 0x8f, 0xb9, 0x76, 0xc7, 0xa7, 0xce, 0x51, + 0x02, 0x58, 0x9b, 0x00, 0x0c, 0x91, 0x4f, 0x5c, 0xc4, 0x69, 0x94, 0x78, 0x37, 0x7b, 0x84, 0x7b, + 0x83, 0x8e, 0xee, 0xd0, 0x7e, 0xa3, 0x47, 0x7b, 0xb4, 0x21, 0xcd, 0x9d, 0x41, 0x57, 0xbe, 0xc5, + 0x49, 0x8b, 0xa7, 0x18, 0xae, 0x7d, 0x54, 0x01, 0x0b, 0xa6, 0x8c, 0xf1, 0x80, 0x23, 0x8e, 0xa1, + 0x06, 0x2a, 0x3d, 0x1c, 0x60, 0x46, 0x98, 0xcd, 0x49, 0x1f, 0x2b, 0xbf, 0x3f, 0x51, 0x2f, 0x6d, + 0x94, 0xad, 0x85, 0xc4, 0xf8, 0x3a, 0xe9, 0x63, 0x58, 0x03, 0x65, 0xe6, 0x53, 0xae, 0xfc, 0x11, + 0xfb, 0xe4, 0x0b, 0x34, 0x40, 0xb9, 0x4b, 0xa3, 0x23, 0xe5, 0x4f, 0x61, 0x5c, 0x68, 0xae, 0xe9, + 0xe7, 0x1f, 0x5f, 0x7f, 0x91, 0x46, 0x47, 0x96, 0x84, 0xc2, 0x37, 0x41, 0xcd, 0x47, 0xe2, 0xf8, + 0xf1, 0xf1, 0x6c, 0x0f, 0x23, 0x17, 0x47, 0xca, 0x0f, 0x55, 0xa9, 0xb0, 0x91, 0x2b, 0x60, 0xee, + 0xe9, 0xe9, 0x81, 0xf5, 0x38, 0x5b, 0x53, 0x30, 0xee, 0x4b, 0x82, 0x75, 0x29, 0x56, 0x29, 0x98, + 0xe0, 0x1e, 0x58, 0x88, 0x35, 0x23, 0x4a, 0x39, 0x53, 0x7e, 0xac, 0xd6, 0xe7, 0x37, 0x2a, 0xe6, + 0x95, 0xf1, 0x48, 0x85, 0x8c, 0x9d, 0x6e, 0x32, 0x72, 0x8a, 0x0f, 0xb4, 0x3d, 0x63, 0xbf, 0x79, + 0x63, 0xbb, 0xa9, 0x59, 0x40, 0x62, 0x2d, 0x01, 0x15, 0x4c, 0xd1, 0x0f, 0x9c, 0x30, 0x7f, 0xfa, + 0x1f, 0xa6, 0xc4, 0xc6, 0x4c, 0x0b, 0x2c, 0x7b, 0x84, 0x71, 0x1a, 0x11, 0x07, 0xf9, 0x09, 0xfd, + 0xe7, 0x98, 0x7e, 0x6d, 0x3c, 0x52, 0xb5, 0x9c, 0x7e, 0x5b, 0x70, 0xeb, 0xe2, 0xbd, 0x8f, 0x8e, + 0x0f, 0x34, 0xa3, 0xd5, 0x6e, 0xb7, 0x9b, 0x46, 0x4b, 0xb3, 0xaa, 0xb9, 0x40, 0xac, 0xf9, 0x3c, + 0xb8, 0x88, 0xb9, 0x67, 0xd8, 0x2e, 0xe2, 0x48, 0xf9, 0x7c, 0x45, 0x16, 0x46, 0x9d, 0x52, 0x98, + 0x7b, 0xdc, 0x33, 0xee, 0x22, 0x8e, 0xac, 0x0b, 0x38, 0x79, 0x82, 0x6f, 0x83, 0x6a, 0x46, 0xb7, + 0x87, 0x94, 0x63, 0xa6, 0x7c, 0xb1, 0x52, 0x9f, 0x9f, 0x41, 0xc4, 0x84, 0xe3, 0x91, 0xba, 0x94, + 0xa7, 0xb8, 0xd5, 0xdc, 0xd1, 0xac, 0xc5, 0x54, 0xf8, 0x50, 0x48, 0xc1, 0x4d, 0x00, 0x63, 0x75, + 0x1c, 0x52, 0x46, 0xb8, 0x4d, 0x02, 0x17, 0x1f, 0x2b, 0x5f, 0xae, 0xc8, 0xa9, 0x58, 0x96, 0xd8, + 0xd8, 0xf3, 0x92, 0x70, 0xc0, 0x77, 0x00, 0xc8, 0x86, 0x95, 0x29, 0x9f, 0xaa, 0x32, 0x8f, 0xfa, + 0x94, 0x3c, 0x0e, 0x53, 0xa4, 0x79, 0x75, 0x3c, 0x52, 0x57, 0x0a, 0x89, 0xec, 0xef, 0xef, 0x1a, + 0x46, 0xab, 0xd9, 0x6e, 0xb7, 0x5b, 0x9a, 0x55, 0x50, 0x84, 0x7b, 0xe0, 0x42, 0x07, 0xf9, 0x28, + 0x70, 0x30, 0x53, 0x3e, 0x13, 0xea, 0xe5, 0xff, 0xe6, 0x66, 0x68, 0x78, 0x13, 0x54, 0x22, 0x14, + 0xb8, 0x88, 0xda, 0x7d, 0x72, 0x8c, 0x99, 0xf2, 0xe1, 0x75, 0xd9, 0xb5, 0x95, 0xf1, 0x48, 0xad, + 0xe5, 0x5d, 0x6b, 0xed, 0xee, 0x6e, 0xb7, 0x64, 0xd7, 0x17, 0x62, 0xf4, 0xab, 0x02, 0x0c, 0x9b, + 0xe0, 0x22, 0xf3, 0x11, 0xf3, 0x48, 0xd0, 0x63, 0xca, 0x5f, 0xba, 0x8c, 0x5b, 0x1b, 0x8f, 0xd4, + 0xea, 0xe4, 0xb8, 0x68, 0x56, 0x0e, 0x83, 0xef, 0x83, 0xab, 0x61, 0x84, 0x87, 0x84, 0x0e, 0x98, + 0x8d, 0x43, 0xea, 0x78, 0x76, 0x61, 0x0f, 0x30, 0xe5, 0x97, 0x96, 0xac, 0xcd, 0x73, 0xd3, 0xbe, + 0xa1, 0xd7, 0x70, 0xe0, 0x92, 0xa0, 0xf7, 0x42, 0xce, 0xf9, 0x57, 0xbb, 0x76, 0xb6, 0xf6, 0x5b, + 0x9a, 0xf5, 0x64, 0x1a, 0xe3, 0x9e, 0x08, 0x51, 0x40, 0x33, 0xf8, 0x1e, 0x58, 0x75, 0x06, 0x51, + 0x84, 0x03, 0x7e, 0x5e, 0xfc, 0x5f, 0x1f, 0x4d, 0x7c, 0x25, 0x09, 0xf1, 0x70, 0x78, 0x06, 0xe0, + 0xbb, 0x03, 0xc6, 0x49, 0x97, 0x38, 0xd2, 0x62, 0x77, 0x08, 0x67, 0xca, 0x57, 0xb7, 0xea, 0xa5, + 0x8d, 0x8a, 0x79, 0x67, 0x3c, 0x52, 0x2b, 0x79, 0xf1, 0x0c, 0xed, 0xef, 0x91, 0xda, 0x28, 0x6c, + 0xb5, 0x30, 0x3a, 0x61, 0x7d, 0xc4, 0x89, 0xe3, 0xa3, 0x0e, 0x6b, 0xf4, 0xe8, 0x66, 0x87, 0xf0, + 0x2e, 0xc1, 0xbe, 0xab, 0x9b, 0x84, 0x0f, 0xb1, 0xc3, 0x69, 0xb4, 0x63, 0x5d, 0x9a, 0xd0, 0x37, + 0x09, 0x67, 0xb0, 0x0b, 0x9e, 0xca, 0x8a, 0x9e, 0x78, 0xb1, 0x6b, 0x3b, 0x1e, 0x76, 0x8e, 0x42, + 0x4a, 0x02, 0xae, 0x7c, 0x7d, 0x4b, 0x7e, 0x5f, 0x4f, 0x4f, 0x19, 0xc9, 0x3b, 0x19, 0xd2, 0xca, + 0xba, 0xf7, 0x72, 0xaa, 0x93, 0x3b, 0xa1, 0x0b, 0xd6, 0xd2, 0xda, 0x9e, 0x1b, 0xe6, 0x9b, 0x99, + 0xc3, 0xa4, 0x3d, 0x3a, 0x2f, 0xca, 0x1b, 0xe0, 0x72, 0x97, 0x04, 0xc8, 0x27, 0xa7, 0x93, 0xea, + 0xdf, 0xce, 0xac, 0x5e, 0xcb, 0xf8, 0xb9, 0x51, 0xfb, 0xa4, 0x04, 0xca, 0x62, 0x45, 0xc3, 0x9b, + 0x60, 0x39, 0xab, 0xd6, 0x10, 0x47, 0x8c, 0xd0, 0x40, 0x29, 0xc9, 0xfe, 0x2c, 0x4f, 0xf6, 0x67, + 0x47, 0xb3, 0xaa, 0x29, 0xf2, 0x30, 0x06, 0xc2, 0x7d, 0x50, 0x4d, 0x4b, 0x90, 0x72, 0xe7, 0xa6, + 0x70, 0x97, 0x12, 0x60, 0x4a, 0xbd, 0x0c, 0x1e, 0x93, 0x13, 0xa9, 0xcc, 0xcb, 0x35, 0x12, 0xbf, + 0x68, 0x1f, 0xcf, 0x01, 0xf8, 0xf0, 0xd4, 0xc1, 0x3e, 0x58, 0x46, 0xbd, 0x5e, 0x84, 0x7b, 0x85, + 0x29, 0x8a, 0x93, 0x34, 0x27, 0xe6, 0xb1, 0xb9, 0xb5, 0xb3, 0x27, 0xc6, 0xe8, 0xc6, 0xac, 0x63, + 0xe4, 0x13, 0xc6, 0xad, 0x6a, 0x41, 0x5b, 0x4e, 0xd0, 0x01, 0x28, 0xcb, 0x45, 0x3c, 0x27, 0x4b, + 0x7c, 0x6d, 0x4a, 0x89, 0x0b, 0x09, 0xca, 0x75, 0x2c, 0x39, 0xf0, 0x3a, 0xa8, 0x92, 0xc0, 0xf1, + 0x07, 0xe2, 0x90, 0xb6, 0x8b, 0x7d, 0x74, 0x92, 0x9c, 0x70, 0x29, 0x33, 0xdf, 0x15, 0x56, 0xf8, + 0x2c, 0x58, 0x0a, 0x23, 0x1a, 0x52, 0x86, 0xa3, 0x64, 0xa3, 0x96, 0x25, 0x6e, 0x31, 0xb5, 0xca, + 0x6d, 0xaa, 0xdd, 0x06, 0xb5, 0x6c, 0x47, 0xbe, 0x22, 0xef, 0x3f, 0xb1, 0x94, 0xf3, 0xf2, 0x95, + 0x0a, 0xe5, 0x83, 0x10, 0x94, 0xc5, 0x7d, 0x14, 0x37, 0xc1, 0x92, 0xcf, 0xda, 0x07, 0x25, 0x50, + 0xbd, 0x9f, 0x5d, 0x37, 0x26, 0xe2, 0x8e, 0x07, 0xdb, 0x93, 0xd7, 0x66, 0x69, 0xe6, 0x5b, 0xb3, + 0x3d, 0x79, 0x6b, 0xce, 0xcd, 0x7a, 0x69, 0x6a, 0x6f, 0x81, 0x8a, 0xfc, 0xf1, 0x78, 0x30, 0xe8, + 0xf7, 0x51, 0x74, 0x22, 0x32, 0x95, 0xff, 0x16, 0xa5, 0xc2, 0xaf, 0xc5, 0x39, 0xd9, 0xc3, 0x67, + 0xc0, 0x62, 0x87, 0x0e, 0x02, 0x17, 0x45, 0x27, 0x32, 0xa6, 0x2c, 0x66, 0xc5, 0xaa, 0xa4, 0x46, + 0xa1, 0x6e, 0x56, 0xbe, 0x3b, 0x5b, 0x2f, 0x7d, 0x7f, 0xb6, 0x5e, 0xfa, 0xed, 0x6c, 0xbd, 0xd4, + 0x79, 0x5c, 0xfe, 0xf1, 0x6c, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x6d, 0xa0, 0x24, 0xba, + 0x09, 0x00, 0x00, } func (m *BeaconState) Marshal() (dAtA []byte, err error) { @@ -1051,6 +1117,52 @@ func (m *HistoricalBatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *StateSummary) 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 *StateSummary) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.BoundaryRoot) > 0 { + i -= len(m.BoundaryRoot) + copy(dAtA[i:], m.BoundaryRoot) + i = encodeVarintTypes(dAtA, i, uint64(len(m.BoundaryRoot))) + i-- + dAtA[i] = 0x1a + } + if len(m.Root) > 0 { + i -= len(m.Root) + copy(dAtA[i:], m.Root) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Root))) + i-- + dAtA[i] = 0x12 + } + if m.Slot != 0 { + i = encodeVarintTypes(dAtA, i, uint64(m.Slot)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -1265,6 +1377,29 @@ func (m *HistoricalBatch) Size() (n int) { return n } +func (m *StateSummary) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Slot != 0 { + n += 1 + sovTypes(uint64(m.Slot)) + } + l = len(m.Root) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.BoundaryRoot) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2576,6 +2711,147 @@ func (m *HistoricalBatch) Unmarshal(dAtA []byte) error { } return nil } +func (m *StateSummary) 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 ErrIntOverflowTypes + } + 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: StateSummary: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateSummary: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType) + } + m.Slot = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Slot |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Root", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Root = append(m.Root[:0], dAtA[iNdEx:postIndex]...) + if m.Root == nil { + m.Root = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoundaryRoot", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BoundaryRoot = append(m.BoundaryRoot[:0], dAtA[iNdEx:postIndex]...) + if m.BoundaryRoot == nil { + m.BoundaryRoot = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 skipTypes(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/proto/beacon/rpc/v1/services.pb.go b/proto/beacon/rpc/v1/services.pb.go index 8c320c492f9..c3b7ad7e829 100755 --- a/proto/beacon/rpc/v1/services.pb.go +++ b/proto/beacon/rpc/v1/services.pb.go @@ -6,15 +6,14 @@ package ethereum_beacon_rpc_v1 import ( context "context" fmt "fmt" - io "io" - math "math" - math_bits "math/bits" - proto "github.com/gogo/protobuf/proto" _ "github.com/gogo/protobuf/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/rpc/v1/slasher.pb.go b/proto/beacon/rpc/v1/slasher.pb.go new file mode 100755 index 00000000000..88d9423a05c --- /dev/null +++ b/proto/beacon/rpc/v1/slasher.pb.go @@ -0,0 +1,2041 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: proto/beacon/rpc/v1/slasher.proto + +package ethereum_beacon_rpc_v1 + +import ( + context "context" + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + types "github.com/gogo/protobuf/types" + v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" + grpc "google.golang.org/grpc" + io "io" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type ValidatorIDToIdxAtt struct { + Indices []uint64 `protobuf:"varint,1,rep,packed,name=indices,proto3" json:"indices,omitempty"` + DataRoot []byte `protobuf:"bytes,2,opt,name=data_root,json=dataRoot,proto3" json:"data_root,omitempty"` + Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidatorIDToIdxAtt) Reset() { *m = ValidatorIDToIdxAtt{} } +func (m *ValidatorIDToIdxAtt) String() string { return proto.CompactTextString(m) } +func (*ValidatorIDToIdxAtt) ProtoMessage() {} +func (*ValidatorIDToIdxAtt) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{0} +} +func (m *ValidatorIDToIdxAtt) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorIDToIdxAtt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorIDToIdxAtt.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 *ValidatorIDToIdxAtt) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorIDToIdxAtt.Merge(m, src) +} +func (m *ValidatorIDToIdxAtt) XXX_Size() int { + return m.Size() +} +func (m *ValidatorIDToIdxAtt) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorIDToIdxAtt.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorIDToIdxAtt proto.InternalMessageInfo + +func (m *ValidatorIDToIdxAtt) GetIndices() []uint64 { + if m != nil { + return m.Indices + } + return nil +} + +func (m *ValidatorIDToIdxAtt) GetDataRoot() []byte { + if m != nil { + return m.DataRoot + } + return nil +} + +func (m *ValidatorIDToIdxAtt) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +type ValidatorIDToIdxAttList struct { + IndicesList []*ValidatorIDToIdxAtt `protobuf:"bytes,1,rep,name=indicesList,proto3" json:"indicesList,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidatorIDToIdxAttList) Reset() { *m = ValidatorIDToIdxAttList{} } +func (m *ValidatorIDToIdxAttList) String() string { return proto.CompactTextString(m) } +func (*ValidatorIDToIdxAttList) ProtoMessage() {} +func (*ValidatorIDToIdxAttList) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{1} +} +func (m *ValidatorIDToIdxAttList) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ValidatorIDToIdxAttList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ValidatorIDToIdxAttList.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 *ValidatorIDToIdxAttList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorIDToIdxAttList.Merge(m, src) +} +func (m *ValidatorIDToIdxAttList) XXX_Size() int { + return m.Size() +} +func (m *ValidatorIDToIdxAttList) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorIDToIdxAttList.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorIDToIdxAttList proto.InternalMessageInfo + +func (m *ValidatorIDToIdxAttList) GetIndicesList() []*ValidatorIDToIdxAtt { + if m != nil { + return m.IndicesList + } + return nil +} + +type ProposerSlashingRequest struct { + BlockHeader *v1alpha1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=block_header,json=blockHeader,proto3" json:"block_header,omitempty"` + ValidatorIndex uint64 `protobuf:"varint,2,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProposerSlashingRequest) Reset() { *m = ProposerSlashingRequest{} } +func (m *ProposerSlashingRequest) String() string { return proto.CompactTextString(m) } +func (*ProposerSlashingRequest) ProtoMessage() {} +func (*ProposerSlashingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{2} +} +func (m *ProposerSlashingRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposerSlashingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposerSlashingRequest.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 *ProposerSlashingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposerSlashingRequest.Merge(m, src) +} +func (m *ProposerSlashingRequest) XXX_Size() int { + return m.Size() +} +func (m *ProposerSlashingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposerSlashingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposerSlashingRequest proto.InternalMessageInfo + +func (m *ProposerSlashingRequest) GetBlockHeader() *v1alpha1.BeaconBlockHeader { + if m != nil { + return m.BlockHeader + } + return nil +} + +func (m *ProposerSlashingRequest) GetValidatorIndex() uint64 { + if m != nil { + return m.ValidatorIndex + } + return 0 +} + +type ProposerSlashingResponse struct { + ProposerSlashing []*v1alpha1.ProposerSlashing `protobuf:"bytes,1,rep,name=proposer_slashing,json=proposerSlashing,proto3" json:"proposer_slashing,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProposerSlashingResponse) Reset() { *m = ProposerSlashingResponse{} } +func (m *ProposerSlashingResponse) String() string { return proto.CompactTextString(m) } +func (*ProposerSlashingResponse) ProtoMessage() {} +func (*ProposerSlashingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{3} +} +func (m *ProposerSlashingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ProposerSlashingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ProposerSlashingResponse.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 *ProposerSlashingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposerSlashingResponse.Merge(m, src) +} +func (m *ProposerSlashingResponse) XXX_Size() int { + return m.Size() +} +func (m *ProposerSlashingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposerSlashingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposerSlashingResponse proto.InternalMessageInfo + +func (m *ProposerSlashingResponse) GetProposerSlashing() []*v1alpha1.ProposerSlashing { + if m != nil { + return m.ProposerSlashing + } + return nil +} + +type AttesterSlashingResponse struct { + AttesterSlashing []*v1alpha1.AttesterSlashing `protobuf:"bytes,1,rep,name=attester_slashing,json=attesterSlashing,proto3" json:"attester_slashing,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AttesterSlashingResponse) Reset() { *m = AttesterSlashingResponse{} } +func (m *AttesterSlashingResponse) String() string { return proto.CompactTextString(m) } +func (*AttesterSlashingResponse) ProtoMessage() {} +func (*AttesterSlashingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{4} +} +func (m *AttesterSlashingResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AttesterSlashingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AttesterSlashingResponse.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 *AttesterSlashingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AttesterSlashingResponse.Merge(m, src) +} +func (m *AttesterSlashingResponse) XXX_Size() int { + return m.Size() +} +func (m *AttesterSlashingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AttesterSlashingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AttesterSlashingResponse proto.InternalMessageInfo + +func (m *AttesterSlashingResponse) GetAttesterSlashing() []*v1alpha1.AttesterSlashing { + if m != nil { + return m.AttesterSlashing + } + return nil +} + +type MinMaxEpochSpan struct { + MinEpochSpan uint32 `protobuf:"varint,1,opt,name=min_epoch_span,json=minEpochSpan,proto3" json:"min_epoch_span,omitempty"` + MaxEpochSpan uint32 `protobuf:"varint,2,opt,name=max_epoch_span,json=maxEpochSpan,proto3" json:"max_epoch_span,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MinMaxEpochSpan) Reset() { *m = MinMaxEpochSpan{} } +func (m *MinMaxEpochSpan) String() string { return proto.CompactTextString(m) } +func (*MinMaxEpochSpan) ProtoMessage() {} +func (*MinMaxEpochSpan) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{5} +} +func (m *MinMaxEpochSpan) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MinMaxEpochSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MinMaxEpochSpan.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 *MinMaxEpochSpan) XXX_Merge(src proto.Message) { + xxx_messageInfo_MinMaxEpochSpan.Merge(m, src) +} +func (m *MinMaxEpochSpan) XXX_Size() int { + return m.Size() +} +func (m *MinMaxEpochSpan) XXX_DiscardUnknown() { + xxx_messageInfo_MinMaxEpochSpan.DiscardUnknown(m) +} + +var xxx_messageInfo_MinMaxEpochSpan proto.InternalMessageInfo + +func (m *MinMaxEpochSpan) GetMinEpochSpan() uint32 { + if m != nil { + return m.MinEpochSpan + } + return 0 +} + +func (m *MinMaxEpochSpan) GetMaxEpochSpan() uint32 { + if m != nil { + return m.MaxEpochSpan + } + return 0 +} + +type EpochSpanMap struct { + EpochSpanMap map[uint64]*MinMaxEpochSpan `protobuf:"bytes,1,rep,name=epoch_span_map,json=epochSpanMap,proto3" json:"epoch_span_map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EpochSpanMap) Reset() { *m = EpochSpanMap{} } +func (m *EpochSpanMap) String() string { return proto.CompactTextString(m) } +func (*EpochSpanMap) ProtoMessage() {} +func (*EpochSpanMap) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{6} +} +func (m *EpochSpanMap) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EpochSpanMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EpochSpanMap.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 *EpochSpanMap) XXX_Merge(src proto.Message) { + xxx_messageInfo_EpochSpanMap.Merge(m, src) +} +func (m *EpochSpanMap) XXX_Size() int { + return m.Size() +} +func (m *EpochSpanMap) XXX_DiscardUnknown() { + xxx_messageInfo_EpochSpanMap.DiscardUnknown(m) +} + +var xxx_messageInfo_EpochSpanMap proto.InternalMessageInfo + +func (m *EpochSpanMap) GetEpochSpanMap() map[uint64]*MinMaxEpochSpan { + if m != nil { + return m.EpochSpanMap + } + return nil +} + +func init() { + proto.RegisterType((*ValidatorIDToIdxAtt)(nil), "ethereum.beacon.rpc.v1.ValidatorIDToIdxAtt") + proto.RegisterType((*ValidatorIDToIdxAttList)(nil), "ethereum.beacon.rpc.v1.ValidatorIDToIdxAttList") + proto.RegisterType((*ProposerSlashingRequest)(nil), "ethereum.beacon.rpc.v1.ProposerSlashingRequest") + proto.RegisterType((*ProposerSlashingResponse)(nil), "ethereum.beacon.rpc.v1.ProposerSlashingResponse") + proto.RegisterType((*AttesterSlashingResponse)(nil), "ethereum.beacon.rpc.v1.AttesterSlashingResponse") + proto.RegisterType((*MinMaxEpochSpan)(nil), "ethereum.beacon.rpc.v1.MinMaxEpochSpan") + proto.RegisterType((*EpochSpanMap)(nil), "ethereum.beacon.rpc.v1.EpochSpanMap") + proto.RegisterMapType((map[uint64]*MinMaxEpochSpan)(nil), "ethereum.beacon.rpc.v1.EpochSpanMap.EpochSpanMapEntry") +} + +func init() { proto.RegisterFile("proto/beacon/rpc/v1/slasher.proto", fileDescriptor_d75c5a5be5c552fc) } + +var fileDescriptor_d75c5a5be5c552fc = []byte{ + // 615 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6a, 0x13, 0x41, + 0x14, 0x66, 0x9b, 0x6a, 0xed, 0x49, 0x6c, 0xd3, 0x11, 0xdb, 0x90, 0x4a, 0xad, 0x41, 0x68, 0x44, + 0xd8, 0x6d, 0x2a, 0x88, 0x08, 0x5e, 0xb4, 0x58, 0x30, 0x68, 0x40, 0xb6, 0x45, 0x41, 0x94, 0x65, + 0xb2, 0x7b, 0xcc, 0xae, 0xdd, 0xcc, 0x8c, 0x33, 0xb3, 0x21, 0x7d, 0x0a, 0x5f, 0xc4, 0x07, 0xf1, + 0xd2, 0x2b, 0xaf, 0xa5, 0x4f, 0x22, 0x3b, 0xbb, 0x69, 0x36, 0x3f, 0x0b, 0xf5, 0x6e, 0xcf, 0x39, + 0xdf, 0xf9, 0xbe, 0x33, 0xdf, 0x9e, 0x19, 0x78, 0x24, 0x24, 0xd7, 0xdc, 0xe9, 0x23, 0xf5, 0x39, + 0x73, 0xa4, 0xf0, 0x9d, 0x51, 0xc7, 0x51, 0x31, 0x55, 0x21, 0x4a, 0xdb, 0xd4, 0xc8, 0x36, 0xea, + 0x10, 0x25, 0x26, 0x43, 0x3b, 0x43, 0xd9, 0x52, 0xf8, 0xf6, 0xa8, 0xd3, 0xdc, 0x1d, 0x70, 0x3e, + 0x88, 0xd1, 0x31, 0xa8, 0x7e, 0xf2, 0xd5, 0xc1, 0xa1, 0xd0, 0x97, 0x59, 0x53, 0xf3, 0x21, 0xea, + 0xd0, 0x19, 0x75, 0x68, 0x2c, 0x42, 0xda, 0xc9, 0xe9, 0xbd, 0x7e, 0xcc, 0xfd, 0x8b, 0x0c, 0xd0, + 0xfa, 0x06, 0xf7, 0x3e, 0xd0, 0x38, 0x0a, 0xa8, 0xe6, 0xb2, 0xfb, 0xfa, 0x9c, 0x77, 0x83, 0xf1, + 0xb1, 0xd6, 0xa4, 0x01, 0x6b, 0x11, 0x0b, 0x22, 0x1f, 0x55, 0xc3, 0xda, 0xaf, 0xb4, 0x57, 0xdd, + 0x49, 0x48, 0x76, 0x61, 0x3d, 0xa0, 0x9a, 0x7a, 0x92, 0x73, 0xdd, 0x58, 0xd9, 0xb7, 0xda, 0x35, + 0xf7, 0x4e, 0x9a, 0x70, 0x39, 0xd7, 0xe4, 0x01, 0xac, 0xab, 0x68, 0xc0, 0xa8, 0x4e, 0x24, 0x36, + 0x2a, 0xa6, 0x38, 0x4d, 0xb4, 0x42, 0xd8, 0x59, 0xa2, 0xf5, 0x2e, 0x52, 0x9a, 0xf4, 0xa0, 0x9a, + 0x0b, 0xa4, 0xa1, 0xd1, 0xac, 0x1e, 0x3d, 0xb5, 0x97, 0x1f, 0xd9, 0x5e, 0xc2, 0xe2, 0x16, 0xfb, + 0x5b, 0x3f, 0x2c, 0xd8, 0x79, 0x2f, 0xb9, 0xe0, 0x0a, 0xe5, 0x59, 0xea, 0x62, 0xc4, 0x06, 0x2e, + 0x7e, 0x4f, 0x50, 0x69, 0xf2, 0x16, 0x6a, 0xc6, 0x00, 0x2f, 0x44, 0x1a, 0xa0, 0x6c, 0x58, 0xfb, + 0x56, 0xbb, 0x7a, 0xd4, 0x9e, 0x6a, 0xa1, 0x0e, 0xed, 0x89, 0x65, 0xf6, 0x89, 0x11, 0x3e, 0x49, + 0x1b, 0xde, 0x18, 0xbc, 0x5b, 0xed, 0x4f, 0x03, 0x72, 0x00, 0x9b, 0xa3, 0xc9, 0x30, 0x5e, 0xc4, + 0x02, 0x1c, 0x1b, 0x4f, 0x56, 0xdd, 0x8d, 0xeb, 0x74, 0x37, 0xcd, 0xb6, 0x04, 0x34, 0x16, 0x07, + 0x52, 0x82, 0x33, 0x85, 0xe4, 0x1c, 0xb6, 0x44, 0x5e, 0xf3, 0x54, 0x5e, 0xcc, 0x2d, 0x38, 0x28, + 0x19, 0x6b, 0x81, 0xab, 0x2e, 0xe6, 0x32, 0xa9, 0xe2, 0xb1, 0xd6, 0xa8, 0xf4, 0x72, 0x45, 0x9a, + 0xd7, 0x6e, 0xaa, 0xb8, 0xc0, 0x55, 0xa7, 0x73, 0x99, 0xd6, 0x17, 0xd8, 0xec, 0x45, 0xac, 0x47, + 0xc7, 0xa7, 0x82, 0xfb, 0xe1, 0x99, 0xa0, 0x8c, 0x3c, 0x86, 0x8d, 0x61, 0xc4, 0x3c, 0x4c, 0x13, + 0x9e, 0x12, 0x94, 0x19, 0xbb, 0xef, 0xba, 0xb5, 0x61, 0xc4, 0x66, 0x51, 0x74, 0x5c, 0x44, 0xad, + 0xe4, 0xa8, 0x02, 0x57, 0xeb, 0x8f, 0x05, 0xb5, 0xeb, 0xa8, 0x47, 0x05, 0xf9, 0x0c, 0x1b, 0xd3, + 0x16, 0x6f, 0x48, 0x45, 0x7e, 0x84, 0xe7, 0x65, 0x7b, 0x53, 0xec, 0x9e, 0x09, 0x4e, 0x99, 0x96, + 0x97, 0x6e, 0x0d, 0x0b, 0xa9, 0x66, 0x08, 0x5b, 0x0b, 0x10, 0x52, 0x87, 0xca, 0x05, 0x5e, 0x9a, + 0x43, 0xac, 0xba, 0xe9, 0x27, 0x79, 0x05, 0xb7, 0x46, 0x34, 0x4e, 0xd0, 0x8c, 0x3c, 0x63, 0xdf, + 0xac, 0xf6, 0x9c, 0x33, 0x6e, 0xd6, 0xf5, 0x72, 0xe5, 0x85, 0x75, 0xf4, 0xb3, 0x02, 0x6b, 0x67, + 0xd9, 0x5d, 0x27, 0x09, 0x6c, 0x77, 0x95, 0x09, 0x68, 0x3f, 0xc6, 0xcc, 0x74, 0xaa, 0x23, 0xce, + 0xc8, 0x93, 0x92, 0x1f, 0x63, 0xf6, 0x0b, 0x83, 0x02, 0xb4, 0x79, 0x58, 0x36, 0x44, 0xe9, 0x42, + 0x24, 0x50, 0x2f, 0xc8, 0x9a, 0x75, 0x27, 0x4e, 0x19, 0x4b, 0xc9, 0xcd, 0x2a, 0x97, 0x2d, 0xdd, + 0xfc, 0x8f, 0x40, 0xae, 0x45, 0x33, 0x10, 0x8d, 0x15, 0xd9, 0xb6, 0xb3, 0x27, 0xcd, 0x9e, 0x3c, + 0x69, 0xf6, 0x69, 0xfa, 0xa4, 0x35, 0x6f, 0x7a, 0x19, 0x0e, 0x2d, 0xf2, 0x09, 0xee, 0x2f, 0x33, + 0xf1, 0xff, 0xb9, 0xe7, 0x1d, 0x3b, 0xb4, 0x4e, 0x6a, 0xbf, 0xae, 0xf6, 0xac, 0xdf, 0x57, 0x7b, + 0xd6, 0xdf, 0xab, 0x3d, 0xab, 0x7f, 0xdb, 0x10, 0x3d, 0xfb, 0x17, 0x00, 0x00, 0xff, 0xff, 0xbc, + 0x4a, 0x19, 0xe8, 0xc2, 0x05, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// SlasherClient is the client API for Slasher service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SlasherClient interface { + IsSlashableAttestation(ctx context.Context, in *v1alpha1.IndexedAttestation, opts ...grpc.CallOption) (*AttesterSlashingResponse, error) + IsSlashableBlock(ctx context.Context, in *ProposerSlashingRequest, opts ...grpc.CallOption) (*ProposerSlashingResponse, error) + SlashableProposals(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (Slasher_SlashableProposalsClient, error) + SlashableAttestations(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (Slasher_SlashableAttestationsClient, error) +} + +type slasherClient struct { + cc *grpc.ClientConn +} + +func NewSlasherClient(cc *grpc.ClientConn) SlasherClient { + return &slasherClient{cc} +} + +func (c *slasherClient) IsSlashableAttestation(ctx context.Context, in *v1alpha1.IndexedAttestation, opts ...grpc.CallOption) (*AttesterSlashingResponse, error) { + out := new(AttesterSlashingResponse) + err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Slasher/IsSlashableAttestation", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *slasherClient) IsSlashableBlock(ctx context.Context, in *ProposerSlashingRequest, opts ...grpc.CallOption) (*ProposerSlashingResponse, error) { + out := new(ProposerSlashingResponse) + err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Slasher/IsSlashableBlock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *slasherClient) SlashableProposals(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (Slasher_SlashableProposalsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Slasher_serviceDesc.Streams[0], "/ethereum.beacon.rpc.v1.Slasher/SlashableProposals", opts...) + if err != nil { + return nil, err + } + x := &slasherSlashableProposalsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Slasher_SlashableProposalsClient interface { + Recv() (*v1alpha1.ProposerSlashing, error) + grpc.ClientStream +} + +type slasherSlashableProposalsClient struct { + grpc.ClientStream +} + +func (x *slasherSlashableProposalsClient) Recv() (*v1alpha1.ProposerSlashing, error) { + m := new(v1alpha1.ProposerSlashing) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *slasherClient) SlashableAttestations(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (Slasher_SlashableAttestationsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Slasher_serviceDesc.Streams[1], "/ethereum.beacon.rpc.v1.Slasher/SlashableAttestations", opts...) + if err != nil { + return nil, err + } + x := &slasherSlashableAttestationsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Slasher_SlashableAttestationsClient interface { + Recv() (*v1alpha1.AttesterSlashing, error) + grpc.ClientStream +} + +type slasherSlashableAttestationsClient struct { + grpc.ClientStream +} + +func (x *slasherSlashableAttestationsClient) Recv() (*v1alpha1.AttesterSlashing, error) { + m := new(v1alpha1.AttesterSlashing) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// SlasherServer is the server API for Slasher service. +type SlasherServer interface { + IsSlashableAttestation(context.Context, *v1alpha1.IndexedAttestation) (*AttesterSlashingResponse, error) + IsSlashableBlock(context.Context, *ProposerSlashingRequest) (*ProposerSlashingResponse, error) + SlashableProposals(*types.Empty, Slasher_SlashableProposalsServer) error + SlashableAttestations(*types.Empty, Slasher_SlashableAttestationsServer) error +} + +func RegisterSlasherServer(s *grpc.Server, srv SlasherServer) { + s.RegisterService(&_Slasher_serviceDesc, srv) +} + +func _Slasher_IsSlashableAttestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1alpha1.IndexedAttestation) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SlasherServer).IsSlashableAttestation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.beacon.rpc.v1.Slasher/IsSlashableAttestation", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SlasherServer).IsSlashableAttestation(ctx, req.(*v1alpha1.IndexedAttestation)) + } + return interceptor(ctx, in, info, handler) +} + +func _Slasher_IsSlashableBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProposerSlashingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SlasherServer).IsSlashableBlock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.beacon.rpc.v1.Slasher/IsSlashableBlock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SlasherServer).IsSlashableBlock(ctx, req.(*ProposerSlashingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Slasher_SlashableProposals_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(types.Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SlasherServer).SlashableProposals(m, &slasherSlashableProposalsServer{stream}) +} + +type Slasher_SlashableProposalsServer interface { + Send(*v1alpha1.ProposerSlashing) error + grpc.ServerStream +} + +type slasherSlashableProposalsServer struct { + grpc.ServerStream +} + +func (x *slasherSlashableProposalsServer) Send(m *v1alpha1.ProposerSlashing) error { + return x.ServerStream.SendMsg(m) +} + +func _Slasher_SlashableAttestations_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(types.Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SlasherServer).SlashableAttestations(m, &slasherSlashableAttestationsServer{stream}) +} + +type Slasher_SlashableAttestationsServer interface { + Send(*v1alpha1.AttesterSlashing) error + grpc.ServerStream +} + +type slasherSlashableAttestationsServer struct { + grpc.ServerStream +} + +func (x *slasherSlashableAttestationsServer) Send(m *v1alpha1.AttesterSlashing) error { + return x.ServerStream.SendMsg(m) +} + +var _Slasher_serviceDesc = grpc.ServiceDesc{ + ServiceName: "ethereum.beacon.rpc.v1.Slasher", + HandlerType: (*SlasherServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "IsSlashableAttestation", + Handler: _Slasher_IsSlashableAttestation_Handler, + }, + { + MethodName: "IsSlashableBlock", + Handler: _Slasher_IsSlashableBlock_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "SlashableProposals", + Handler: _Slasher_SlashableProposals_Handler, + ServerStreams: true, + }, + { + StreamName: "SlashableAttestations", + Handler: _Slasher_SlashableAttestations_Handler, + ServerStreams: true, + }, + }, + Metadata: "proto/beacon/rpc/v1/slasher.proto", +} + +func (m *ValidatorIDToIdxAtt) 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 *ValidatorIDToIdxAtt) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Indices) > 0 { + dAtA2 := make([]byte, len(m.Indices)*10) + var j1 int + for _, num := range m.Indices { + for num >= 1<<7 { + dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j1++ + } + dAtA2[j1] = uint8(num) + j1++ + } + dAtA[i] = 0xa + i++ + i = encodeVarintSlasher(dAtA, i, uint64(j1)) + i += copy(dAtA[i:], dAtA2[:j1]) + } + if len(m.DataRoot) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(len(m.DataRoot))) + i += copy(dAtA[i:], m.DataRoot) + } + if len(m.Signature) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintSlasher(dAtA, i, uint64(len(m.Signature))) + i += copy(dAtA[i:], m.Signature) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ValidatorIDToIdxAttList) 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 *ValidatorIDToIdxAttList) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.IndicesList) > 0 { + for _, msg := range m.IndicesList { + dAtA[i] = 0xa + i++ + i = encodeVarintSlasher(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ProposerSlashingRequest) 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 *ProposerSlashingRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.BlockHeader != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintSlasher(dAtA, i, uint64(m.BlockHeader.Size())) + n3, err := m.BlockHeader.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.ValidatorIndex != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(m.ValidatorIndex)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ProposerSlashingResponse) 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 *ProposerSlashingResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ProposerSlashing) > 0 { + for _, msg := range m.ProposerSlashing { + dAtA[i] = 0xa + i++ + i = encodeVarintSlasher(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AttesterSlashingResponse) 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 *AttesterSlashingResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.AttesterSlashing) > 0 { + for _, msg := range m.AttesterSlashing { + dAtA[i] = 0xa + i++ + i = encodeVarintSlasher(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *MinMaxEpochSpan) 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 *MinMaxEpochSpan) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MinEpochSpan != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(m.MinEpochSpan)) + } + if m.MaxEpochSpan != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(m.MaxEpochSpan)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *EpochSpanMap) 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 *EpochSpanMap) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.EpochSpanMap) > 0 { + for k, _ := range m.EpochSpanMap { + dAtA[i] = 0xa + i++ + v := m.EpochSpanMap[k] + msgSize := 0 + if v != nil { + msgSize = v.Size() + msgSize += 1 + sovSlasher(uint64(msgSize)) + } + mapSize := 1 + sovSlasher(uint64(k)) + msgSize + i = encodeVarintSlasher(dAtA, i, uint64(mapSize)) + dAtA[i] = 0x8 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(k)) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintSlasher(dAtA, i, uint64(v.Size())) + n4, err := v.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + } + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeVarintSlasher(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ValidatorIDToIdxAtt) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Indices) > 0 { + l = 0 + for _, e := range m.Indices { + l += sovSlasher(uint64(e)) + } + n += 1 + sovSlasher(uint64(l)) + l + } + l = len(m.DataRoot) + if l > 0 { + n += 1 + l + sovSlasher(uint64(l)) + } + l = len(m.Signature) + if l > 0 { + n += 1 + l + sovSlasher(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ValidatorIDToIdxAttList) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.IndicesList) > 0 { + for _, e := range m.IndicesList { + l = e.Size() + n += 1 + l + sovSlasher(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ProposerSlashingRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockHeader != nil { + l = m.BlockHeader.Size() + n += 1 + l + sovSlasher(uint64(l)) + } + if m.ValidatorIndex != 0 { + n += 1 + sovSlasher(uint64(m.ValidatorIndex)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ProposerSlashingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ProposerSlashing) > 0 { + for _, e := range m.ProposerSlashing { + l = e.Size() + n += 1 + l + sovSlasher(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AttesterSlashingResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AttesterSlashing) > 0 { + for _, e := range m.AttesterSlashing { + l = e.Size() + n += 1 + l + sovSlasher(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MinMaxEpochSpan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MinEpochSpan != 0 { + n += 1 + sovSlasher(uint64(m.MinEpochSpan)) + } + if m.MaxEpochSpan != 0 { + n += 1 + sovSlasher(uint64(m.MaxEpochSpan)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *EpochSpanMap) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.EpochSpanMap) > 0 { + for k, v := range m.EpochSpanMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovSlasher(uint64(l)) + } + mapEntrySize := 1 + sovSlasher(uint64(k)) + l + n += mapEntrySize + 1 + sovSlasher(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovSlasher(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozSlasher(x uint64) (n int) { + return sovSlasher(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ValidatorIDToIdxAtt) 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 ErrIntOverflowSlasher + } + 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: ValidatorIDToIdxAtt: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorIDToIdxAtt: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Indices = append(m.Indices, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.Indices) == 0 { + m.Indices = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Indices = append(m.Indices, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Indices", wireType) + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataRoot", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DataRoot = append(m.DataRoot[:0], dAtA[iNdEx:postIndex]...) + if m.DataRoot == nil { + m.DataRoot = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...) + if m.Signature == nil { + m.Signature = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *ValidatorIDToIdxAttList) 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 ErrIntOverflowSlasher + } + 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: ValidatorIDToIdxAttList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ValidatorIDToIdxAttList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IndicesList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IndicesList = append(m.IndicesList, &ValidatorIDToIdxAtt{}) + if err := m.IndicesList[len(m.IndicesList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *ProposerSlashingRequest) 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 ErrIntOverflowSlasher + } + 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: ProposerSlashingRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerSlashingRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BlockHeader == nil { + m.BlockHeader = &v1alpha1.BeaconBlockHeader{} + } + if err := m.BlockHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType) + } + m.ValidatorIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ValidatorIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *ProposerSlashingResponse) 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 ErrIntOverflowSlasher + } + 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: ProposerSlashingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProposerSlashingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposerSlashing = append(m.ProposerSlashing, &v1alpha1.ProposerSlashing{}) + if err := m.ProposerSlashing[len(m.ProposerSlashing)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *AttesterSlashingResponse) 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 ErrIntOverflowSlasher + } + 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: AttesterSlashingResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AttesterSlashingResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlashing", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AttesterSlashing = append(m.AttesterSlashing, &v1alpha1.AttesterSlashing{}) + if err := m.AttesterSlashing[len(m.AttesterSlashing)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *MinMaxEpochSpan) 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 ErrIntOverflowSlasher + } + 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: MinMaxEpochSpan: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MinMaxEpochSpan: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinEpochSpan", wireType) + } + m.MinEpochSpan = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinEpochSpan |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxEpochSpan", wireType) + } + m.MaxEpochSpan = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxEpochSpan |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 *EpochSpanMap) 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 ErrIntOverflowSlasher + } + 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: EpochSpanMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EpochSpanMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EpochSpanMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSlasher + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSlasher + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EpochSpanMap == nil { + m.EpochSpanMap = make(map[uint64]*MinMaxEpochSpan) + } + var mapkey uint64 + var mapvalue *MinMaxEpochSpan + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSlasher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthSlasher + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthSlasher + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &MinMaxEpochSpan{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.EpochSpanMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSlasher(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSlasher + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSlasher + } + 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 skipSlasher(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSlasher + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSlasher + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSlasher + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthSlasher + } + iNdEx += length + if iNdEx < 0 { + return 0, ErrInvalidLengthSlasher + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSlasher + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipSlasher(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + if iNdEx < 0 { + return 0, ErrInvalidLengthSlasher + } + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthSlasher = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSlasher = fmt.Errorf("proto: integer overflow") +) diff --git a/proto/beacon/rpc/v1_gateway/services.pb.go b/proto/beacon/rpc/v1_gateway/services.pb.go index 35b1f56e43c..68861c062ad 100755 --- a/proto/beacon/rpc/v1_gateway/services.pb.go +++ b/proto/beacon/rpc/v1_gateway/services.pb.go @@ -6,13 +6,12 @@ package ethereum_beacon_rpc_v1 import ( context "context" fmt "fmt" - math "math" - proto "github.com/golang/protobuf/proto" _ "github.com/golang/protobuf/ptypes/empty" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" + math "math" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/proto/beacon/rpc/v1_gateway/slasher.pb.go b/proto/beacon/rpc/v1_gateway/slasher.pb.go new file mode 100755 index 00000000000..f91d92a2429 --- /dev/null +++ b/proto/beacon/rpc/v1_gateway/slasher.pb.go @@ -0,0 +1,630 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: proto/beacon/rpc/v1/slasher.proto + +package ethereum_beacon_rpc_v1 + +import ( + context "context" + fmt "fmt" + proto "github.com/golang/protobuf/proto" + empty "github.com/golang/protobuf/ptypes/empty" + v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type ValidatorIDToIdxAtt struct { + Indices []uint64 `protobuf:"varint,1,rep,packed,name=indices,proto3" json:"indices,omitempty"` + DataRoot []byte `protobuf:"bytes,2,opt,name=data_root,json=dataRoot,proto3" json:"data_root,omitempty"` + Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidatorIDToIdxAtt) Reset() { *m = ValidatorIDToIdxAtt{} } +func (m *ValidatorIDToIdxAtt) String() string { return proto.CompactTextString(m) } +func (*ValidatorIDToIdxAtt) ProtoMessage() {} +func (*ValidatorIDToIdxAtt) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{0} +} + +func (m *ValidatorIDToIdxAtt) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ValidatorIDToIdxAtt.Unmarshal(m, b) +} +func (m *ValidatorIDToIdxAtt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ValidatorIDToIdxAtt.Marshal(b, m, deterministic) +} +func (m *ValidatorIDToIdxAtt) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorIDToIdxAtt.Merge(m, src) +} +func (m *ValidatorIDToIdxAtt) XXX_Size() int { + return xxx_messageInfo_ValidatorIDToIdxAtt.Size(m) +} +func (m *ValidatorIDToIdxAtt) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorIDToIdxAtt.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorIDToIdxAtt proto.InternalMessageInfo + +func (m *ValidatorIDToIdxAtt) GetIndices() []uint64 { + if m != nil { + return m.Indices + } + return nil +} + +func (m *ValidatorIDToIdxAtt) GetDataRoot() []byte { + if m != nil { + return m.DataRoot + } + return nil +} + +func (m *ValidatorIDToIdxAtt) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +type ValidatorIDToIdxAttList struct { + IndicesList []*ValidatorIDToIdxAtt `protobuf:"bytes,1,rep,name=indicesList,proto3" json:"indicesList,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ValidatorIDToIdxAttList) Reset() { *m = ValidatorIDToIdxAttList{} } +func (m *ValidatorIDToIdxAttList) String() string { return proto.CompactTextString(m) } +func (*ValidatorIDToIdxAttList) ProtoMessage() {} +func (*ValidatorIDToIdxAttList) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{1} +} + +func (m *ValidatorIDToIdxAttList) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ValidatorIDToIdxAttList.Unmarshal(m, b) +} +func (m *ValidatorIDToIdxAttList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ValidatorIDToIdxAttList.Marshal(b, m, deterministic) +} +func (m *ValidatorIDToIdxAttList) XXX_Merge(src proto.Message) { + xxx_messageInfo_ValidatorIDToIdxAttList.Merge(m, src) +} +func (m *ValidatorIDToIdxAttList) XXX_Size() int { + return xxx_messageInfo_ValidatorIDToIdxAttList.Size(m) +} +func (m *ValidatorIDToIdxAttList) XXX_DiscardUnknown() { + xxx_messageInfo_ValidatorIDToIdxAttList.DiscardUnknown(m) +} + +var xxx_messageInfo_ValidatorIDToIdxAttList proto.InternalMessageInfo + +func (m *ValidatorIDToIdxAttList) GetIndicesList() []*ValidatorIDToIdxAtt { + if m != nil { + return m.IndicesList + } + return nil +} + +type ProposerSlashingRequest struct { + BlockHeader *v1alpha1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=block_header,json=blockHeader,proto3" json:"block_header,omitempty"` + ValidatorIndex uint64 `protobuf:"varint,2,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProposerSlashingRequest) Reset() { *m = ProposerSlashingRequest{} } +func (m *ProposerSlashingRequest) String() string { return proto.CompactTextString(m) } +func (*ProposerSlashingRequest) ProtoMessage() {} +func (*ProposerSlashingRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{2} +} + +func (m *ProposerSlashingRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProposerSlashingRequest.Unmarshal(m, b) +} +func (m *ProposerSlashingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProposerSlashingRequest.Marshal(b, m, deterministic) +} +func (m *ProposerSlashingRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposerSlashingRequest.Merge(m, src) +} +func (m *ProposerSlashingRequest) XXX_Size() int { + return xxx_messageInfo_ProposerSlashingRequest.Size(m) +} +func (m *ProposerSlashingRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ProposerSlashingRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposerSlashingRequest proto.InternalMessageInfo + +func (m *ProposerSlashingRequest) GetBlockHeader() *v1alpha1.BeaconBlockHeader { + if m != nil { + return m.BlockHeader + } + return nil +} + +func (m *ProposerSlashingRequest) GetValidatorIndex() uint64 { + if m != nil { + return m.ValidatorIndex + } + return 0 +} + +type ProposerSlashingResponse struct { + ProposerSlashing []*v1alpha1.ProposerSlashing `protobuf:"bytes,1,rep,name=proposer_slashing,json=proposerSlashing,proto3" json:"proposer_slashing,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ProposerSlashingResponse) Reset() { *m = ProposerSlashingResponse{} } +func (m *ProposerSlashingResponse) String() string { return proto.CompactTextString(m) } +func (*ProposerSlashingResponse) ProtoMessage() {} +func (*ProposerSlashingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{3} +} + +func (m *ProposerSlashingResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ProposerSlashingResponse.Unmarshal(m, b) +} +func (m *ProposerSlashingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ProposerSlashingResponse.Marshal(b, m, deterministic) +} +func (m *ProposerSlashingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ProposerSlashingResponse.Merge(m, src) +} +func (m *ProposerSlashingResponse) XXX_Size() int { + return xxx_messageInfo_ProposerSlashingResponse.Size(m) +} +func (m *ProposerSlashingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ProposerSlashingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ProposerSlashingResponse proto.InternalMessageInfo + +func (m *ProposerSlashingResponse) GetProposerSlashing() []*v1alpha1.ProposerSlashing { + if m != nil { + return m.ProposerSlashing + } + return nil +} + +type AttesterSlashingResponse struct { + AttesterSlashing []*v1alpha1.AttesterSlashing `protobuf:"bytes,1,rep,name=attester_slashing,json=attesterSlashing,proto3" json:"attester_slashing,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AttesterSlashingResponse) Reset() { *m = AttesterSlashingResponse{} } +func (m *AttesterSlashingResponse) String() string { return proto.CompactTextString(m) } +func (*AttesterSlashingResponse) ProtoMessage() {} +func (*AttesterSlashingResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{4} +} + +func (m *AttesterSlashingResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AttesterSlashingResponse.Unmarshal(m, b) +} +func (m *AttesterSlashingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AttesterSlashingResponse.Marshal(b, m, deterministic) +} +func (m *AttesterSlashingResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AttesterSlashingResponse.Merge(m, src) +} +func (m *AttesterSlashingResponse) XXX_Size() int { + return xxx_messageInfo_AttesterSlashingResponse.Size(m) +} +func (m *AttesterSlashingResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AttesterSlashingResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AttesterSlashingResponse proto.InternalMessageInfo + +func (m *AttesterSlashingResponse) GetAttesterSlashing() []*v1alpha1.AttesterSlashing { + if m != nil { + return m.AttesterSlashing + } + return nil +} + +type MinMaxEpochSpan struct { + MinEpochSpan uint32 `protobuf:"varint,1,opt,name=min_epoch_span,json=minEpochSpan,proto3" json:"min_epoch_span,omitempty"` + MaxEpochSpan uint32 `protobuf:"varint,2,opt,name=max_epoch_span,json=maxEpochSpan,proto3" json:"max_epoch_span,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MinMaxEpochSpan) Reset() { *m = MinMaxEpochSpan{} } +func (m *MinMaxEpochSpan) String() string { return proto.CompactTextString(m) } +func (*MinMaxEpochSpan) ProtoMessage() {} +func (*MinMaxEpochSpan) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{5} +} + +func (m *MinMaxEpochSpan) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MinMaxEpochSpan.Unmarshal(m, b) +} +func (m *MinMaxEpochSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MinMaxEpochSpan.Marshal(b, m, deterministic) +} +func (m *MinMaxEpochSpan) XXX_Merge(src proto.Message) { + xxx_messageInfo_MinMaxEpochSpan.Merge(m, src) +} +func (m *MinMaxEpochSpan) XXX_Size() int { + return xxx_messageInfo_MinMaxEpochSpan.Size(m) +} +func (m *MinMaxEpochSpan) XXX_DiscardUnknown() { + xxx_messageInfo_MinMaxEpochSpan.DiscardUnknown(m) +} + +var xxx_messageInfo_MinMaxEpochSpan proto.InternalMessageInfo + +func (m *MinMaxEpochSpan) GetMinEpochSpan() uint32 { + if m != nil { + return m.MinEpochSpan + } + return 0 +} + +func (m *MinMaxEpochSpan) GetMaxEpochSpan() uint32 { + if m != nil { + return m.MaxEpochSpan + } + return 0 +} + +type EpochSpanMap struct { + EpochSpanMap map[uint64]*MinMaxEpochSpan `protobuf:"bytes,1,rep,name=epoch_span_map,json=epochSpanMap,proto3" json:"epoch_span_map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EpochSpanMap) Reset() { *m = EpochSpanMap{} } +func (m *EpochSpanMap) String() string { return proto.CompactTextString(m) } +func (*EpochSpanMap) ProtoMessage() {} +func (*EpochSpanMap) Descriptor() ([]byte, []int) { + return fileDescriptor_d75c5a5be5c552fc, []int{6} +} + +func (m *EpochSpanMap) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EpochSpanMap.Unmarshal(m, b) +} +func (m *EpochSpanMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EpochSpanMap.Marshal(b, m, deterministic) +} +func (m *EpochSpanMap) XXX_Merge(src proto.Message) { + xxx_messageInfo_EpochSpanMap.Merge(m, src) +} +func (m *EpochSpanMap) XXX_Size() int { + return xxx_messageInfo_EpochSpanMap.Size(m) +} +func (m *EpochSpanMap) XXX_DiscardUnknown() { + xxx_messageInfo_EpochSpanMap.DiscardUnknown(m) +} + +var xxx_messageInfo_EpochSpanMap proto.InternalMessageInfo + +func (m *EpochSpanMap) GetEpochSpanMap() map[uint64]*MinMaxEpochSpan { + if m != nil { + return m.EpochSpanMap + } + return nil +} + +func init() { + proto.RegisterType((*ValidatorIDToIdxAtt)(nil), "ethereum.beacon.rpc.v1.ValidatorIDToIdxAtt") + proto.RegisterType((*ValidatorIDToIdxAttList)(nil), "ethereum.beacon.rpc.v1.ValidatorIDToIdxAttList") + proto.RegisterType((*ProposerSlashingRequest)(nil), "ethereum.beacon.rpc.v1.ProposerSlashingRequest") + proto.RegisterType((*ProposerSlashingResponse)(nil), "ethereum.beacon.rpc.v1.ProposerSlashingResponse") + proto.RegisterType((*AttesterSlashingResponse)(nil), "ethereum.beacon.rpc.v1.AttesterSlashingResponse") + proto.RegisterType((*MinMaxEpochSpan)(nil), "ethereum.beacon.rpc.v1.MinMaxEpochSpan") + proto.RegisterType((*EpochSpanMap)(nil), "ethereum.beacon.rpc.v1.EpochSpanMap") + proto.RegisterMapType((map[uint64]*MinMaxEpochSpan)(nil), "ethereum.beacon.rpc.v1.EpochSpanMap.EpochSpanMapEntry") +} + +func init() { proto.RegisterFile("proto/beacon/rpc/v1/slasher.proto", fileDescriptor_d75c5a5be5c552fc) } + +var fileDescriptor_d75c5a5be5c552fc = []byte{ + // 597 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x6f, 0x6b, 0xd4, 0x4e, + 0x10, 0x26, 0xbd, 0xfe, 0x7e, 0xb5, 0x73, 0x67, 0x7b, 0x5d, 0xb1, 0x3d, 0xae, 0x82, 0x35, 0x08, + 0x3d, 0x11, 0x92, 0x5e, 0x05, 0x11, 0xc1, 0x17, 0x2d, 0x16, 0x3c, 0xf4, 0x40, 0xd2, 0xa2, 0x20, + 0x4a, 0xd8, 0x24, 0xe3, 0x25, 0x36, 0xb7, 0xbb, 0xee, 0x6e, 0x8e, 0xeb, 0xa7, 0xf0, 0x8b, 0xf8, + 0x79, 0xfc, 0x3c, 0x92, 0x4d, 0xae, 0x97, 0xfb, 0x13, 0xa8, 0xef, 0x32, 0xcf, 0x3c, 0x33, 0xcf, + 0xec, 0x93, 0xd9, 0x85, 0x27, 0x42, 0x72, 0xcd, 0xdd, 0x00, 0x69, 0xc8, 0x99, 0x2b, 0x45, 0xe8, + 0x4e, 0xfa, 0xae, 0x4a, 0xa9, 0x8a, 0x51, 0x3a, 0x26, 0x47, 0xf6, 0x51, 0xc7, 0x28, 0x31, 0x1b, + 0x3b, 0x05, 0xcb, 0x91, 0x22, 0x74, 0x26, 0xfd, 0xee, 0xe1, 0x88, 0xf3, 0x51, 0x8a, 0xae, 0x61, + 0x05, 0xd9, 0x77, 0x17, 0xc7, 0x42, 0xdf, 0x14, 0x45, 0xdd, 0xc7, 0xa8, 0x63, 0x77, 0xd2, 0xa7, + 0xa9, 0x88, 0x69, 0xbf, 0x6c, 0xef, 0x07, 0x29, 0x0f, 0xaf, 0x0b, 0x82, 0xfd, 0x03, 0x1e, 0x7c, + 0xa2, 0x69, 0x12, 0x51, 0xcd, 0xe5, 0xe0, 0xed, 0x15, 0x1f, 0x44, 0xd3, 0x33, 0xad, 0x49, 0x07, + 0xb6, 0x12, 0x16, 0x25, 0x21, 0xaa, 0x8e, 0x75, 0xd4, 0xe8, 0x6d, 0x7a, 0xb3, 0x90, 0x1c, 0xc2, + 0x76, 0x44, 0x35, 0xf5, 0x25, 0xe7, 0xba, 0xb3, 0x71, 0x64, 0xf5, 0x5a, 0xde, 0xbd, 0x1c, 0xf0, + 0x38, 0xd7, 0xe4, 0x11, 0x6c, 0xab, 0x64, 0xc4, 0xa8, 0xce, 0x24, 0x76, 0x1a, 0x26, 0x39, 0x07, + 0xec, 0x18, 0x0e, 0xd6, 0x68, 0x7d, 0x48, 0x94, 0x26, 0x43, 0x68, 0x96, 0x02, 0x79, 0x68, 0x34, + 0x9b, 0xa7, 0xcf, 0x9d, 0xf5, 0x47, 0x76, 0xd6, 0x74, 0xf1, 0xaa, 0xf5, 0xf6, 0x2f, 0x0b, 0x0e, + 0x3e, 0x4a, 0x2e, 0xb8, 0x42, 0x79, 0x99, 0xbb, 0x98, 0xb0, 0x91, 0x87, 0x3f, 0x33, 0x54, 0x9a, + 0xbc, 0x87, 0x96, 0x31, 0xc0, 0x8f, 0x91, 0x46, 0x28, 0x3b, 0xd6, 0x91, 0xd5, 0x6b, 0x9e, 0xf6, + 0xe6, 0x5a, 0xa8, 0x63, 0x67, 0x66, 0x99, 0x73, 0x6e, 0x84, 0xcf, 0xf3, 0x82, 0x77, 0x86, 0xef, + 0x35, 0x83, 0x79, 0x40, 0x8e, 0x61, 0x77, 0x32, 0x1b, 0xc6, 0x4f, 0x58, 0x84, 0x53, 0xe3, 0xc9, + 0xa6, 0xb7, 0x73, 0x0b, 0x0f, 0x72, 0xd4, 0x16, 0xd0, 0x59, 0x1d, 0x48, 0x09, 0xce, 0x14, 0x92, + 0x2b, 0xd8, 0x13, 0x65, 0xce, 0x57, 0x65, 0xb2, 0xb4, 0xe0, 0xb8, 0x66, 0xac, 0x95, 0x5e, 0x6d, + 0xb1, 0x84, 0xe4, 0x8a, 0x67, 0x5a, 0xa3, 0xd2, 0xeb, 0x15, 0x69, 0x99, 0xbb, 0xab, 0xe2, 0x4a, + 0xaf, 0x36, 0x5d, 0x42, 0xec, 0x6f, 0xb0, 0x3b, 0x4c, 0xd8, 0x90, 0x4e, 0x2f, 0x04, 0x0f, 0xe3, + 0x4b, 0x41, 0x19, 0x79, 0x0a, 0x3b, 0xe3, 0x84, 0xf9, 0x98, 0x03, 0xbe, 0x12, 0x94, 0x19, 0xbb, + 0xef, 0x7b, 0xad, 0x71, 0xc2, 0x16, 0x59, 0x74, 0x5a, 0x65, 0x6d, 0x94, 0xac, 0x4a, 0x2f, 0xfb, + 0x8f, 0x05, 0xad, 0xdb, 0x68, 0x48, 0x05, 0xf9, 0x0a, 0x3b, 0xf3, 0x12, 0x7f, 0x4c, 0x45, 0x79, + 0x84, 0x97, 0x75, 0x7b, 0x53, 0xad, 0x5e, 0x08, 0x2e, 0x98, 0x96, 0x37, 0x5e, 0x0b, 0x2b, 0x50, + 0x37, 0x86, 0xbd, 0x15, 0x0a, 0x69, 0x43, 0xe3, 0x1a, 0x6f, 0xcc, 0x21, 0x36, 0xbd, 0xfc, 0x93, + 0xbc, 0x81, 0xff, 0x26, 0x34, 0xcd, 0xd0, 0x8c, 0xbc, 0x60, 0xdf, 0xa2, 0xf6, 0x92, 0x33, 0x5e, + 0x51, 0xf5, 0x7a, 0xe3, 0x95, 0x75, 0xfa, 0xbb, 0x01, 0x5b, 0x97, 0xc5, 0x5d, 0x27, 0x19, 0xec, + 0x0f, 0x94, 0x09, 0x68, 0x90, 0x62, 0x61, 0x3a, 0xd5, 0x09, 0x67, 0xe4, 0x59, 0xcd, 0x8f, 0x31, + 0xfb, 0x85, 0x51, 0x85, 0xda, 0x3d, 0xa9, 0x1b, 0xa2, 0x76, 0x21, 0x32, 0x68, 0x57, 0x64, 0xcd, + 0xba, 0x13, 0xb7, 0xae, 0x4b, 0xcd, 0xcd, 0xaa, 0x97, 0xad, 0xdd, 0xfc, 0xcf, 0x40, 0x6e, 0x45, + 0x0b, 0x12, 0x4d, 0x15, 0xd9, 0x77, 0x8a, 0x27, 0xcd, 0x99, 0x3d, 0x69, 0xce, 0x45, 0xfe, 0xa4, + 0x75, 0xef, 0x7a, 0x19, 0x4e, 0x2c, 0xf2, 0x05, 0x1e, 0xae, 0x33, 0xf1, 0xdf, 0x7b, 0x2f, 0x3b, + 0x76, 0x62, 0x05, 0xff, 0x9b, 0xd2, 0x17, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x23, 0x47, + 0x27, 0xb4, 0x05, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// SlasherClient is the client API for Slasher service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type SlasherClient interface { + IsSlashableAttestation(ctx context.Context, in *v1alpha1.IndexedAttestation, opts ...grpc.CallOption) (*AttesterSlashingResponse, error) + IsSlashableBlock(ctx context.Context, in *ProposerSlashingRequest, opts ...grpc.CallOption) (*ProposerSlashingResponse, error) + SlashableProposals(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (Slasher_SlashableProposalsClient, error) + SlashableAttestations(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (Slasher_SlashableAttestationsClient, error) +} + +type slasherClient struct { + cc *grpc.ClientConn +} + +func NewSlasherClient(cc *grpc.ClientConn) SlasherClient { + return &slasherClient{cc} +} + +func (c *slasherClient) IsSlashableAttestation(ctx context.Context, in *v1alpha1.IndexedAttestation, opts ...grpc.CallOption) (*AttesterSlashingResponse, error) { + out := new(AttesterSlashingResponse) + err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Slasher/IsSlashableAttestation", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *slasherClient) IsSlashableBlock(ctx context.Context, in *ProposerSlashingRequest, opts ...grpc.CallOption) (*ProposerSlashingResponse, error) { + out := new(ProposerSlashingResponse) + err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.Slasher/IsSlashableBlock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *slasherClient) SlashableProposals(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (Slasher_SlashableProposalsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Slasher_serviceDesc.Streams[0], "/ethereum.beacon.rpc.v1.Slasher/SlashableProposals", opts...) + if err != nil { + return nil, err + } + x := &slasherSlashableProposalsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Slasher_SlashableProposalsClient interface { + Recv() (*v1alpha1.ProposerSlashing, error) + grpc.ClientStream +} + +type slasherSlashableProposalsClient struct { + grpc.ClientStream +} + +func (x *slasherSlashableProposalsClient) Recv() (*v1alpha1.ProposerSlashing, error) { + m := new(v1alpha1.ProposerSlashing) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *slasherClient) SlashableAttestations(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (Slasher_SlashableAttestationsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Slasher_serviceDesc.Streams[1], "/ethereum.beacon.rpc.v1.Slasher/SlashableAttestations", opts...) + if err != nil { + return nil, err + } + x := &slasherSlashableAttestationsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Slasher_SlashableAttestationsClient interface { + Recv() (*v1alpha1.AttesterSlashing, error) + grpc.ClientStream +} + +type slasherSlashableAttestationsClient struct { + grpc.ClientStream +} + +func (x *slasherSlashableAttestationsClient) Recv() (*v1alpha1.AttesterSlashing, error) { + m := new(v1alpha1.AttesterSlashing) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// SlasherServer is the server API for Slasher service. +type SlasherServer interface { + IsSlashableAttestation(context.Context, *v1alpha1.IndexedAttestation) (*AttesterSlashingResponse, error) + IsSlashableBlock(context.Context, *ProposerSlashingRequest) (*ProposerSlashingResponse, error) + SlashableProposals(*empty.Empty, Slasher_SlashableProposalsServer) error + SlashableAttestations(*empty.Empty, Slasher_SlashableAttestationsServer) error +} + +// UnimplementedSlasherServer can be embedded to have forward compatible implementations. +type UnimplementedSlasherServer struct { +} + +func (*UnimplementedSlasherServer) IsSlashableAttestation(ctx context.Context, req *v1alpha1.IndexedAttestation) (*AttesterSlashingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IsSlashableAttestation not implemented") +} +func (*UnimplementedSlasherServer) IsSlashableBlock(ctx context.Context, req *ProposerSlashingRequest) (*ProposerSlashingResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IsSlashableBlock not implemented") +} +func (*UnimplementedSlasherServer) SlashableProposals(req *empty.Empty, srv Slasher_SlashableProposalsServer) error { + return status.Errorf(codes.Unimplemented, "method SlashableProposals not implemented") +} +func (*UnimplementedSlasherServer) SlashableAttestations(req *empty.Empty, srv Slasher_SlashableAttestationsServer) error { + return status.Errorf(codes.Unimplemented, "method SlashableAttestations not implemented") +} + +func RegisterSlasherServer(s *grpc.Server, srv SlasherServer) { + s.RegisterService(&_Slasher_serviceDesc, srv) +} + +func _Slasher_IsSlashableAttestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1alpha1.IndexedAttestation) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SlasherServer).IsSlashableAttestation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.beacon.rpc.v1.Slasher/IsSlashableAttestation", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SlasherServer).IsSlashableAttestation(ctx, req.(*v1alpha1.IndexedAttestation)) + } + return interceptor(ctx, in, info, handler) +} + +func _Slasher_IsSlashableBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProposerSlashingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SlasherServer).IsSlashableBlock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.beacon.rpc.v1.Slasher/IsSlashableBlock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SlasherServer).IsSlashableBlock(ctx, req.(*ProposerSlashingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Slasher_SlashableProposals_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(empty.Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SlasherServer).SlashableProposals(m, &slasherSlashableProposalsServer{stream}) +} + +type Slasher_SlashableProposalsServer interface { + Send(*v1alpha1.ProposerSlashing) error + grpc.ServerStream +} + +type slasherSlashableProposalsServer struct { + grpc.ServerStream +} + +func (x *slasherSlashableProposalsServer) Send(m *v1alpha1.ProposerSlashing) error { + return x.ServerStream.SendMsg(m) +} + +func _Slasher_SlashableAttestations_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(empty.Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(SlasherServer).SlashableAttestations(m, &slasherSlashableAttestationsServer{stream}) +} + +type Slasher_SlashableAttestationsServer interface { + Send(*v1alpha1.AttesterSlashing) error + grpc.ServerStream +} + +type slasherSlashableAttestationsServer struct { + grpc.ServerStream +} + +func (x *slasherSlashableAttestationsServer) Send(m *v1alpha1.AttesterSlashing) error { + return x.ServerStream.SendMsg(m) +} + +var _Slasher_serviceDesc = grpc.ServiceDesc{ + ServiceName: "ethereum.beacon.rpc.v1.Slasher", + HandlerType: (*SlasherServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "IsSlashableAttestation", + Handler: _Slasher_IsSlashableAttestation_Handler, + }, + { + MethodName: "IsSlashableBlock", + Handler: _Slasher_IsSlashableBlock_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "SlashableProposals", + Handler: _Slasher_SlashableProposals_Handler, + ServerStreams: true, + }, + { + StreamName: "SlashableAttestations", + Handler: _Slasher_SlashableAttestations_Handler, + ServerStreams: true, + }, + }, + Metadata: "proto/beacon/rpc/v1/slasher.proto", +}