prysm-pulse/proto/beacon/rpc/v1/services.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: proto/beacon/rpc/v1/services.proto

package ethereum_beacon_rpc_v1

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import empty "github.com/golang/protobuf/ptypes/empty"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

type GenesisTimeAndStateResponse struct {
	GenesisTimestamp        *timestamp.Timestamp  `protobuf:"bytes,1,opt,name=genesis_timestamp,json=genesisTimestamp,proto3" json:"genesis_timestamp,omitempty"`
	LatestCrystallizedState *v1.CrystallizedState `protobuf:"bytes,2,opt,name=latest_crystallized_state,json=latestCrystallizedState,proto3" json:"latest_crystallized_state,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}              `json:"-"`
	XXX_unrecognized        []byte                `json:"-"`
	XXX_sizecache           int32                 `json:"-"`
}

func (m *GenesisTimeAndStateResponse) Reset()         { *m = GenesisTimeAndStateResponse{} }
func (m *GenesisTimeAndStateResponse) String() string { return proto.CompactTextString(m) }
func (*GenesisTimeAndStateResponse) ProtoMessage()    {}
func (*GenesisTimeAndStateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{0}
}
func (m *GenesisTimeAndStateResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GenesisTimeAndStateResponse.Unmarshal(m, b)
}
func (m *GenesisTimeAndStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GenesisTimeAndStateResponse.Marshal(b, m, deterministic)
}
func (dst *GenesisTimeAndStateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenesisTimeAndStateResponse.Merge(dst, src)
}
func (m *GenesisTimeAndStateResponse) XXX_Size() int {
	return xxx_messageInfo_GenesisTimeAndStateResponse.Size(m)
}
func (m *GenesisTimeAndStateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GenesisTimeAndStateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisTimeAndStateResponse proto.InternalMessageInfo

func (m *GenesisTimeAndStateResponse) GetGenesisTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.GenesisTimestamp
	}
	return nil
}

func (m *GenesisTimeAndStateResponse) GetLatestCrystallizedState() *v1.CrystallizedState {
	if m != nil {
		return m.LatestCrystallizedState
	}
	return nil
}

type ProposeRequest struct {
	ParentHash              []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
	SlotNumber              uint64               `protobuf:"varint,2,opt,name=slot_number,json=slotNumber,proto3" json:"slot_number,omitempty"`
	RandaoReveal            []byte               `protobuf:"bytes,3,opt,name=randao_reveal,json=randaoReveal,proto3" json:"randao_reveal,omitempty"`
	AttestationBitmask      []byte               `protobuf:"bytes,4,opt,name=attestation_bitmask,json=attestationBitmask,proto3" json:"attestation_bitmask,omitempty"`
	AttestationAggregateSig []uint32             `protobuf:"varint,5,rep,packed,name=attestation_aggregate_sig,json=attestationAggregateSig,proto3" json:"attestation_aggregate_sig,omitempty"`
	Timestamp               *timestamp.Timestamp `protobuf:"bytes,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}             `json:"-"`
	XXX_unrecognized        []byte               `json:"-"`
	XXX_sizecache           int32                `json:"-"`
}

func (m *ProposeRequest) Reset()         { *m = ProposeRequest{} }
func (m *ProposeRequest) String() string { return proto.CompactTextString(m) }
func (*ProposeRequest) ProtoMessage()    {}
func (*ProposeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{1}
}
func (m *ProposeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProposeRequest.Unmarshal(m, b)
}
func (m *ProposeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProposeRequest.Marshal(b, m, deterministic)
}
func (dst *ProposeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProposeRequest.Merge(dst, src)
}
func (m *ProposeRequest) XXX_Size() int {
	return xxx_messageInfo_ProposeRequest.Size(m)
}
func (m *ProposeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ProposeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ProposeRequest proto.InternalMessageInfo

func (m *ProposeRequest) GetParentHash() []byte {
	if m != nil {
		return m.ParentHash
	}
	return nil
}

func (m *ProposeRequest) GetSlotNumber() uint64 {
	if m != nil {
		return m.SlotNumber
	}
	return 0
}

func (m *ProposeRequest) GetRandaoReveal() []byte {
	if m != nil {
		return m.RandaoReveal
	}
	return nil
}

func (m *ProposeRequest) GetAttestationBitmask() []byte {
	if m != nil {
		return m.AttestationBitmask
	}
	return nil
}

func (m *ProposeRequest) GetAttestationAggregateSig() []uint32 {
	if m != nil {
		return m.AttestationAggregateSig
	}
	return nil
}

func (m *ProposeRequest) GetTimestamp() *timestamp.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

type ProposeResponse struct {
	BlockHash            []byte   `protobuf:"bytes,1,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProposeResponse) Reset()         { *m = ProposeResponse{} }
func (m *ProposeResponse) String() string { return proto.CompactTextString(m) }
func (*ProposeResponse) ProtoMessage()    {}
func (*ProposeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{2}
}
func (m *ProposeResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProposeResponse.Unmarshal(m, b)
}
func (m *ProposeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProposeResponse.Marshal(b, m, deterministic)
}
func (dst *ProposeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProposeResponse.Merge(dst, src)
}
func (m *ProposeResponse) XXX_Size() int {
	return xxx_messageInfo_ProposeResponse.Size(m)
}
func (m *ProposeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ProposeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ProposeResponse proto.InternalMessageInfo

func (m *ProposeResponse) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

type AttestRequest struct {
	Attestation          *v1.AggregatedAttestation `protobuf:"bytes,1,opt,name=attestation,proto3" json:"attestation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *AttestRequest) Reset()         { *m = AttestRequest{} }
func (m *AttestRequest) String() string { return proto.CompactTextString(m) }
func (*AttestRequest) ProtoMessage()    {}
func (*AttestRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{3}
}
func (m *AttestRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AttestRequest.Unmarshal(m, b)
}
func (m *AttestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AttestRequest.Marshal(b, m, deterministic)
}
func (dst *AttestRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttestRequest.Merge(dst, src)
}
func (m *AttestRequest) XXX_Size() int {
	return xxx_messageInfo_AttestRequest.Size(m)
}
func (m *AttestRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AttestRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AttestRequest proto.InternalMessageInfo

func (m *AttestRequest) GetAttestation() *v1.AggregatedAttestation {
	if m != nil {
		return m.Attestation
	}
	return nil
}

type AttestResponse struct {
	AttestationHash      []byte   `protobuf:"bytes,1,opt,name=attestation_hash,json=attestationHash,proto3" json:"attestation_hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AttestResponse) Reset()         { *m = AttestResponse{} }
func (m *AttestResponse) String() string { return proto.CompactTextString(m) }
func (*AttestResponse) ProtoMessage()    {}
func (*AttestResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{4}
}
func (m *AttestResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AttestResponse.Unmarshal(m, b)
}
func (m *AttestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AttestResponse.Marshal(b, m, deterministic)
}
func (dst *AttestResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttestResponse.Merge(dst, src)
}
func (m *AttestResponse) XXX_Size() int {
	return xxx_messageInfo_AttestResponse.Size(m)
}
func (m *AttestResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AttestResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AttestResponse proto.InternalMessageInfo

func (m *AttestResponse) GetAttestationHash() []byte {
	if m != nil {
		return m.AttestationHash
	}
	return nil
}

type PublicKey struct {
	PublicKey            uint64   `protobuf:"varint,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublicKey) Reset()         { *m = PublicKey{} }
func (m *PublicKey) String() string { return proto.CompactTextString(m) }
func (*PublicKey) ProtoMessage()    {}
func (*PublicKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{5}
}
func (m *PublicKey) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublicKey.Unmarshal(m, b)
}
func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
}
func (dst *PublicKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublicKey.Merge(dst, src)
}
func (m *PublicKey) XXX_Size() int {
	return xxx_messageInfo_PublicKey.Size(m)
}
func (m *PublicKey) XXX_DiscardUnknown() {
	xxx_messageInfo_PublicKey.DiscardUnknown(m)
}

var xxx_messageInfo_PublicKey proto.InternalMessageInfo

func (m *PublicKey) GetPublicKey() uint64 {
	if m != nil {
		return m.PublicKey
	}
	return 0
}

type ShardIDResponse struct {
	ShardId              uint64   `protobuf:"varint,1,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShardIDResponse) Reset()         { *m = ShardIDResponse{} }
func (m *ShardIDResponse) String() string { return proto.CompactTextString(m) }
func (*ShardIDResponse) ProtoMessage()    {}
func (*ShardIDResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{6}
}
func (m *ShardIDResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShardIDResponse.Unmarshal(m, b)
}
func (m *ShardIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShardIDResponse.Marshal(b, m, deterministic)
}
func (dst *ShardIDResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShardIDResponse.Merge(dst, src)
}
func (m *ShardIDResponse) XXX_Size() int {
	return xxx_messageInfo_ShardIDResponse.Size(m)
}
func (m *ShardIDResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShardIDResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShardIDResponse proto.InternalMessageInfo

func (m *ShardIDResponse) GetShardId() uint64 {
	if m != nil {
		return m.ShardId
	}
	return 0
}

type IndexResponse struct {
	Index                uint32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IndexResponse) Reset()         { *m = IndexResponse{} }
func (m *IndexResponse) String() string { return proto.CompactTextString(m) }
func (*IndexResponse) ProtoMessage()    {}
func (*IndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{7}
}
func (m *IndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexResponse.Unmarshal(m, b)
}
func (m *IndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexResponse.Marshal(b, m, deterministic)
}
func (dst *IndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexResponse.Merge(dst, src)
}
func (m *IndexResponse) XXX_Size() int {
	return xxx_messageInfo_IndexResponse.Size(m)
}
func (m *IndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_IndexResponse proto.InternalMessageInfo

func (m *IndexResponse) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

type SlotResponse struct {
	Slot                 uint64   `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SlotResponse) Reset()         { *m = SlotResponse{} }
func (m *SlotResponse) String() string { return proto.CompactTextString(m) }
func (*SlotResponse) ProtoMessage()    {}
func (*SlotResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_services_593701c51c9f5594, []int{8}
}
func (m *SlotResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SlotResponse.Unmarshal(m, b)
}
func (m *SlotResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SlotResponse.Marshal(b, m, deterministic)
}
func (dst *SlotResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SlotResponse.Merge(dst, src)
}
func (m *SlotResponse) XXX_Size() int {
	return xxx_messageInfo_SlotResponse.Size(m)
}
func (m *SlotResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SlotResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SlotResponse proto.InternalMessageInfo

func (m *SlotResponse) GetSlot() uint64 {
	if m != nil {
		return m.Slot
	}
	return 0
}

func init() {
	proto.RegisterType((*GenesisTimeAndStateResponse)(nil), "ethereum.beacon.rpc.v1.GenesisTimeAndStateResponse")
	proto.RegisterType((*ProposeRequest)(nil), "ethereum.beacon.rpc.v1.ProposeRequest")
	proto.RegisterType((*ProposeResponse)(nil), "ethereum.beacon.rpc.v1.ProposeResponse")
	proto.RegisterType((*AttestRequest)(nil), "ethereum.beacon.rpc.v1.AttestRequest")
	proto.RegisterType((*AttestResponse)(nil), "ethereum.beacon.rpc.v1.AttestResponse")
	proto.RegisterType((*PublicKey)(nil), "ethereum.beacon.rpc.v1.PublicKey")
	proto.RegisterType((*ShardIDResponse)(nil), "ethereum.beacon.rpc.v1.ShardIDResponse")
	proto.RegisterType((*IndexResponse)(nil), "ethereum.beacon.rpc.v1.IndexResponse")
	proto.RegisterType((*SlotResponse)(nil), "ethereum.beacon.rpc.v1.SlotResponse")
}

// 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

// BeaconServiceClient is the client API for BeaconService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BeaconServiceClient interface {
	GenesisTimeAndCanonicalState(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*GenesisTimeAndStateResponse, error)
	CanonicalHead(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v1.BeaconBlock, error)
	LatestCrystallizedState(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (BeaconService_LatestCrystallizedStateClient, error)
	LatestAttestation(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (BeaconService_LatestAttestationClient, error)
}

type beaconServiceClient struct {
	cc *grpc.ClientConn
}

func NewBeaconServiceClient(cc *grpc.ClientConn) BeaconServiceClient {
	return &beaconServiceClient{cc}
}

func (c *beaconServiceClient) GenesisTimeAndCanonicalState(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*GenesisTimeAndStateResponse, error) {
	out := new(GenesisTimeAndStateResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.BeaconService/GenesisTimeAndCanonicalState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconServiceClient) CanonicalHead(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v1.BeaconBlock, error) {
	out := new(v1.BeaconBlock)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.BeaconService/CanonicalHead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconServiceClient) LatestCrystallizedState(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (BeaconService_LatestCrystallizedStateClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconService_serviceDesc.Streams[0], "/ethereum.beacon.rpc.v1.BeaconService/LatestCrystallizedState", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconServiceLatestCrystallizedStateClient{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 BeaconService_LatestCrystallizedStateClient interface {
	Recv() (*v1.CrystallizedState, error)
	grpc.ClientStream
}

type beaconServiceLatestCrystallizedStateClient struct {
	grpc.ClientStream
}

func (x *beaconServiceLatestCrystallizedStateClient) Recv() (*v1.CrystallizedState, error) {
	m := new(v1.CrystallizedState)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *beaconServiceClient) LatestAttestation(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (BeaconService_LatestAttestationClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconService_serviceDesc.Streams[1], "/ethereum.beacon.rpc.v1.BeaconService/LatestAttestation", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconServiceLatestAttestationClient{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 BeaconService_LatestAttestationClient interface {
	Recv() (*v1.AggregatedAttestation, error)
	grpc.ClientStream
}

type beaconServiceLatestAttestationClient struct {
	grpc.ClientStream
}

func (x *beaconServiceLatestAttestationClient) Recv() (*v1.AggregatedAttestation, error) {
	m := new(v1.AggregatedAttestation)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// BeaconServiceServer is the server API for BeaconService service.
type BeaconServiceServer interface {
	GenesisTimeAndCanonicalState(context.Context, *empty.Empty) (*GenesisTimeAndStateResponse, error)
	CanonicalHead(context.Context, *empty.Empty) (*v1.BeaconBlock, error)
	LatestCrystallizedState(*empty.Empty, BeaconService_LatestCrystallizedStateServer) error
	LatestAttestation(*empty.Empty, BeaconService_LatestAttestationServer) error
}

func RegisterBeaconServiceServer(s *grpc.Server, srv BeaconServiceServer) {
	s.RegisterService(&_BeaconService_serviceDesc, srv)
}

func _BeaconService_GenesisTimeAndCanonicalState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconServiceServer).GenesisTimeAndCanonicalState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.BeaconService/GenesisTimeAndCanonicalState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconServiceServer).GenesisTimeAndCanonicalState(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconService_CanonicalHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconServiceServer).CanonicalHead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.BeaconService/CanonicalHead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconServiceServer).CanonicalHead(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconService_LatestCrystallizedState_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(empty.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BeaconServiceServer).LatestCrystallizedState(m, &beaconServiceLatestCrystallizedStateServer{stream})
}

type BeaconService_LatestCrystallizedStateServer interface {
	Send(*v1.CrystallizedState) error
	grpc.ServerStream
}

type beaconServiceLatestCrystallizedStateServer struct {
	grpc.ServerStream
}

func (x *beaconServiceLatestCrystallizedStateServer) Send(m *v1.CrystallizedState) error {
	return x.ServerStream.SendMsg(m)
}

func _BeaconService_LatestAttestation_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(empty.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BeaconServiceServer).LatestAttestation(m, &beaconServiceLatestAttestationServer{stream})
}

type BeaconService_LatestAttestationServer interface {
	Send(*v1.AggregatedAttestation) error
	grpc.ServerStream
}

type beaconServiceLatestAttestationServer struct {
	grpc.ServerStream
}

func (x *beaconServiceLatestAttestationServer) Send(m *v1.AggregatedAttestation) error {
	return x.ServerStream.SendMsg(m)
}

var _BeaconService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.BeaconService",
	HandlerType: (*BeaconServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenesisTimeAndCanonicalState",
			Handler:    _BeaconService_GenesisTimeAndCanonicalState_Handler,
		},
		{
			MethodName: "CanonicalHead",
			Handler:    _BeaconService_CanonicalHead_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "LatestCrystallizedState",
			Handler:       _BeaconService_LatestCrystallizedState_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LatestAttestation",
			Handler:       _BeaconService_LatestAttestation_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "proto/beacon/rpc/v1/services.proto",
}

// AttesterServiceClient is the client API for AttesterService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AttesterServiceClient interface {
	AttestHead(ctx context.Context, in *AttestRequest, opts ...grpc.CallOption) (*AttestResponse, error)
}

type attesterServiceClient struct {
	cc *grpc.ClientConn
}

func NewAttesterServiceClient(cc *grpc.ClientConn) AttesterServiceClient {
	return &attesterServiceClient{cc}
}

func (c *attesterServiceClient) AttestHead(ctx context.Context, in *AttestRequest, opts ...grpc.CallOption) (*AttestResponse, error) {
	out := new(AttestResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.AttesterService/AttestHead", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AttesterServiceServer is the server API for AttesterService service.
type AttesterServiceServer interface {
	AttestHead(context.Context, *AttestRequest) (*AttestResponse, error)
}

func RegisterAttesterServiceServer(s *grpc.Server, srv AttesterServiceServer) {
	s.RegisterService(&_AttesterService_serviceDesc, srv)
}

func _AttesterService_AttestHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AttestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AttesterServiceServer).AttestHead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.AttesterService/AttestHead",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AttesterServiceServer).AttestHead(ctx, req.(*AttestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _AttesterService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.AttesterService",
	HandlerType: (*AttesterServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AttestHead",
			Handler:    _AttesterService_AttestHead_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/beacon/rpc/v1/services.proto",
}

// ProposerServiceClient is the client API for ProposerService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProposerServiceClient interface {
	ProposeBlock(ctx context.Context, in *ProposeRequest, opts ...grpc.CallOption) (*ProposeResponse, error)
}

type proposerServiceClient struct {
	cc *grpc.ClientConn
}

func NewProposerServiceClient(cc *grpc.ClientConn) ProposerServiceClient {
	return &proposerServiceClient{cc}
}

func (c *proposerServiceClient) ProposeBlock(ctx context.Context, in *ProposeRequest, opts ...grpc.CallOption) (*ProposeResponse, error) {
	out := new(ProposeResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ProposerService/ProposeBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProposerServiceServer is the server API for ProposerService service.
type ProposerServiceServer interface {
	ProposeBlock(context.Context, *ProposeRequest) (*ProposeResponse, error)
}

func RegisterProposerServiceServer(s *grpc.Server, srv ProposerServiceServer) {
	s.RegisterService(&_ProposerService_serviceDesc, srv)
}

func _ProposerService_ProposeBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProposeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProposerServiceServer).ProposeBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.ProposerService/ProposeBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProposerServiceServer).ProposeBlock(ctx, req.(*ProposeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ProposerService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.ProposerService",
	HandlerType: (*ProposerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProposeBlock",
			Handler:    _ProposerService_ProposeBlock_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/beacon/rpc/v1/services.proto",
}

// ValidatorServiceClient is the client API for ValidatorService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ValidatorServiceClient interface {
	ValidatorShardID(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*ShardIDResponse, error)
	ValidatorIndex(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*IndexResponse, error)
	ValidatorSlot(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*SlotResponse, error)
}

type validatorServiceClient struct {
	cc *grpc.ClientConn
}

func NewValidatorServiceClient(cc *grpc.ClientConn) ValidatorServiceClient {
	return &validatorServiceClient{cc}
}

func (c *validatorServiceClient) ValidatorShardID(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*ShardIDResponse, error) {
	out := new(ShardIDResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorShardID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validatorServiceClient) ValidatorIndex(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*IndexResponse, error) {
	out := new(IndexResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *validatorServiceClient) ValidatorSlot(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*SlotResponse, error) {
	out := new(SlotResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorSlot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ValidatorServiceServer is the server API for ValidatorService service.
type ValidatorServiceServer interface {
	ValidatorShardID(context.Context, *PublicKey) (*ShardIDResponse, error)
	ValidatorIndex(context.Context, *PublicKey) (*IndexResponse, error)
	ValidatorSlot(context.Context, *PublicKey) (*SlotResponse, error)
}

func RegisterValidatorServiceServer(s *grpc.Server, srv ValidatorServiceServer) {
	s.RegisterService(&_ValidatorService_serviceDesc, srv)
}

func _ValidatorService_ValidatorShardID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidatorServiceServer).ValidatorShardID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorShardID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidatorServiceServer).ValidatorShardID(ctx, req.(*PublicKey))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidatorService_ValidatorIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidatorServiceServer).ValidatorIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidatorServiceServer).ValidatorIndex(ctx, req.(*PublicKey))
	}
	return interceptor(ctx, in, info, handler)
}

func _ValidatorService_ValidatorSlot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ValidatorServiceServer).ValidatorSlot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorSlot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ValidatorServiceServer).ValidatorSlot(ctx, req.(*PublicKey))
	}
	return interceptor(ctx, in, info, handler)
}

var _ValidatorService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.ValidatorService",
	HandlerType: (*ValidatorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ValidatorShardID",
			Handler:    _ValidatorService_ValidatorShardID_Handler,
		},
		{
			MethodName: "ValidatorIndex",
			Handler:    _ValidatorService_ValidatorIndex_Handler,
		},
		{
			MethodName: "ValidatorSlot",
			Handler:    _ValidatorService_ValidatorSlot_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/beacon/rpc/v1/services.proto",
}

func init() {
	proto.RegisterFile("proto/beacon/rpc/v1/services.proto", fileDescriptor_services_593701c51c9f5594)
}

var fileDescriptor_services_593701c51c9f5594 = []byte{
	// 742 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xd1, 0x52, 0xd3, 0x50,
	0x10, 0x9d, 0x42, 0x41, 0xbb, 0x34, 0x14, 0xa2, 0x03, 0xa5, 0xe8, 0x80, 0x41, 0x14, 0x1c, 0x4d,
	0xa1, 0xbc, 0x38, 0xfa, 0x54, 0xd0, 0x01, 0x46, 0x46, 0x99, 0x94, 0x71, 0x1c, 0x75, 0x88, 0xb7,
	0xc9, 0x9a, 0x66, 0x9a, 0xe4, 0xc6, 0xdc, 0xdb, 0x8e, 0xf5, 0x0b, 0xfc, 0x0a, 0x9f, 0xfd, 0x19,
	0xff, 0xc9, 0xc9, 0xbd, 0x49, 0x9a, 0x02, 0x11, 0x7c, 0xeb, 0x3d, 0xbb, 0x7b, 0xf6, 0x74, 0x77,
	0x4f, 0x40, 0x0b, 0x23, 0xca, 0x69, 0xb3, 0x8b, 0xc4, 0xa2, 0x41, 0x33, 0x0a, 0xad, 0xe6, 0x70,
	0xb7, 0xc9, 0x30, 0x1a, 0xba, 0x16, 0x32, 0x5d, 0x04, 0xd5, 0x25, 0xe4, 0x3d, 0x8c, 0x70, 0xe0,
	0xeb, 0x32, 0x4d, 0x8f, 0x42, 0x4b, 0x1f, 0xee, 0x36, 0x26, 0x6b, 0xc3, 0x56, 0x18, 0xd7, 0xfa,
	0xc8, 0x18, 0x71, 0xd2, 0xda, 0xc6, 0xaa, 0x43, 0xa9, 0xe3, 0x61, 0x53, 0xbc, 0xba, 0x83, 0xaf,
	0x4d, 0xf4, 0x43, 0x3e, 0x4a, 0x82, 0x6b, 0x17, 0x83, 0xdc, 0xf5, 0x91, 0x71, 0xe2, 0x87, 0x32,
	0x41, 0xfb, 0x53, 0x82, 0xd5, 0x43, 0x0c, 0x90, 0xb9, 0xec, 0xcc, 0xf5, 0xb1, 0x1d, 0xd8, 0x1d,
	0x4e, 0x38, 0x1a, 0xc8, 0x42, 0x1a, 0x30, 0x54, 0x0f, 0x61, 0xd1, 0x91, 0x61, 0x33, 0x2b, 0xad,
	0x97, 0xd6, 0x4b, 0x5b, 0x73, 0xad, 0x86, 0x2e, 0xc9, 0xf5, 0x94, 0x5c, 0x3f, 0x4b, 0x33, 0x8c,
	0x05, 0x67, 0xcc, 0x29, 0x10, 0x15, 0x61, 0xc5, 0x23, 0x1c, 0x19, 0x37, 0xad, 0x68, 0xc4, 0x38,
	0xf1, 0x3c, 0xf7, 0x07, 0xda, 0x26, 0x8b, 0xbb, 0xd5, 0xa7, 0x04, 0xe1, 0xb6, 0x7e, 0x71, 0x0c,
	0x61, 0x2b, 0xd4, 0x87, 0xbb, 0xfa, 0x41, 0xae, 0x42, 0xca, 0x5b, 0x96, 0x5c, 0x97, 0x02, 0xda,
	0xaf, 0x29, 0x98, 0x3f, 0x8d, 0x68, 0x48, 0x19, 0x1a, 0xf8, 0x6d, 0x80, 0x8c, 0xab, 0x6b, 0x30,
	0x17, 0x92, 0x08, 0x03, 0x6e, 0xf6, 0x08, 0xeb, 0x09, 0xf1, 0x55, 0x03, 0x24, 0x74, 0x44, 0x58,
	0x2f, 0x4e, 0x60, 0x1e, 0xe5, 0x66, 0x30, 0xf0, 0xbb, 0x18, 0x09, 0x31, 0x65, 0x03, 0x62, 0xe8,
	0xad, 0x40, 0xd4, 0x0d, 0x50, 0x22, 0x12, 0xd8, 0x84, 0x9a, 0x11, 0x0e, 0x91, 0x78, 0xf5, 0x69,
	0xc1, 0x51, 0x95, 0xa0, 0x21, 0x30, 0xb5, 0x09, 0x77, 0x08, 0x8f, 0x45, 0x11, 0xee, 0xd2, 0xc0,
	0xec, 0xba, 0xdc, 0x27, 0xac, 0x5f, 0x2f, 0x8b, 0x54, 0x35, 0x17, 0xda, 0x97, 0x11, 0xf5, 0x05,
	0xac, 0xe4, 0x0b, 0x88, 0xe3, 0x44, 0xe8, 0x10, 0x8e, 0x26, 0x73, 0x9d, 0xfa, 0xcc, 0xfa, 0xf4,
	0x96, 0x62, 0x2c, 0xe7, 0x12, 0xda, 0x69, 0xbc, 0xe3, 0x3a, 0xea, 0x73, 0xa8, 0x8c, 0xd7, 0x31,
	0x7b, 0xed, 0x3a, 0xc6, 0xc9, 0xda, 0x0e, 0xd4, 0xb2, 0xf9, 0x24, 0x3b, 0xbe, 0x0f, 0xd0, 0xf5,
	0xa8, 0xd5, 0xcf, 0xcf, 0xa7, 0x22, 0x90, 0x78, 0x3c, 0xda, 0x17, 0x50, 0xda, 0x42, 0x46, 0x3a,
	0xd0, 0x77, 0x30, 0x97, 0xd3, 0x95, 0x5c, 0xc3, 0xb3, 0xa2, 0xe5, 0x65, 0xba, 0xed, 0xf6, 0xb8,
	0xc8, 0xc8, 0x33, 0x68, 0x2f, 0x61, 0x3e, 0xed, 0x90, 0x48, 0xda, 0x86, 0x85, 0xfc, 0x6c, 0x72,
	0xc2, 0x6a, 0x39, 0x5c, 0xc8, 0x7b, 0x02, 0x95, 0xd3, 0x41, 0xd7, 0x73, 0xad, 0x37, 0x38, 0x8a,
	0xff, 0x4a, 0x28, 0x1e, 0x66, 0x1f, 0x47, 0xa2, 0xa2, 0x6c, 0x54, 0xc2, 0x34, 0xac, 0x3d, 0x85,
	0x5a, 0xa7, 0x47, 0x22, 0xfb, 0xf8, 0x55, 0xd6, 0x69, 0x05, 0x6e, 0xb3, 0x18, 0x32, 0x5d, 0x3b,
	0xc9, 0xbf, 0x25, 0xde, 0xc7, 0xb6, 0xb6, 0x09, 0xca, 0x71, 0x60, 0xe3, 0xf7, 0x2c, 0xf7, 0x2e,
	0xcc, 0xb8, 0x31, 0x20, 0x12, 0x15, 0x43, 0x3e, 0x34, 0x0d, 0xaa, 0x1d, 0x8f, 0x8e, 0xb5, 0xab,
	0x50, 0x8e, 0x6f, 0x27, 0x61, 0x13, 0xbf, 0x5b, 0x3f, 0xa7, 0x41, 0xd9, 0x17, 0x63, 0xe9, 0x48,
	0xe7, 0xab, 0x7d, 0xb8, 0x37, 0xe9, 0xbb, 0x03, 0x12, 0xd0, 0xc0, 0xb5, 0x88, 0x27, 0x0e, 0x59,
	0x5d, 0xba, 0xb4, 0xce, 0xd7, 0xb1, 0xaf, 0x1b, 0x7b, 0xfa, 0xd5, 0xdf, 0x0a, 0xfd, 0x5f, 0x2e,
	0x3e, 0x01, 0x25, 0xa3, 0x3f, 0x42, 0x62, 0x17, 0xb2, 0x6f, 0x14, 0x6d, 0x51, 0x8a, 0xdf, 0x8f,
	0x8f, 0x42, 0x3d, 0x87, 0xe5, 0x93, 0xab, 0xed, 0x57, 0xc8, 0x7b, 0x73, 0x6b, 0xef, 0x94, 0xd4,
	0xcf, 0xb0, 0x28, 0xf9, 0x73, 0x07, 0x53, 0xc8, 0xfc, 0x7f, 0x77, 0xb7, 0x53, 0x6a, 0x05, 0x50,
	0x93, 0x00, 0x46, 0xe9, 0x2e, 0x3e, 0x01, 0x48, 0x48, 0xcc, 0x66, 0xb3, 0x68, 0xc2, 0x13, 0x2e,
	0x68, 0x3c, 0xba, 0x2e, 0x4d, 0xce, 0xbe, 0x15, 0x65, 0x86, 0xcb, 0xfa, 0x99, 0x50, 0x4d, 0x20,
	0x39, 0xd0, 0x42, 0xaa, 0xc9, 0x2f, 0x59, 0xe3, 0xf1, 0xb5, 0x79, 0x49, 0xcf, 0xdf, 0x53, 0xb0,
	0xf0, 0x9e, 0x78, 0xae, 0x4d, 0x38, 0xcd, 0xba, 0x9e, 0xe7, 0x31, 0xe9, 0x02, 0xf5, 0x41, 0x21,
	0x63, 0xea, 0x99, 0xe2, 0xa6, 0x17, 0x9d, 0xf4, 0x11, 0xe6, 0x33, 0x7e, 0xe1, 0x9b, 0x9b, 0xb0,
	0x17, 0x0e, 0x7b, 0xd2, 0x79, 0x1f, 0x40, 0x19, 0x6b, 0xf7, 0x28, 0xbf, 0x09, 0xf5, 0xc3, 0x42,
	0xe1, 0x39, 0xb7, 0x76, 0x67, 0xc5, 0x3d, 0xed, 0xfd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x79, 0xa1,
	0x46, 0xbd, 0xa7, 0x07, 0x00, 0x00,
}