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

package ethereum_beacon_rpc_v1

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"

	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	_ "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options"
	_ "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
	v1alpha1 "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type ValidatorRole int32

const (
	ValidatorRole_UNKNOWN  ValidatorRole = 0
	ValidatorRole_ATTESTER ValidatorRole = 1
	ValidatorRole_PROPOSER ValidatorRole = 2
)

var ValidatorRole_name = map[int32]string{
	0: "UNKNOWN",
	1: "ATTESTER",
	2: "PROPOSER",
}

var ValidatorRole_value = map[string]int32{
	"UNKNOWN":  0,
	"ATTESTER": 1,
	"PROPOSER": 2,
}

func (x ValidatorRole) String() string {
	return proto.EnumName(ValidatorRole_name, int32(x))
}

func (ValidatorRole) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{0}
}

type ValidatorStatus int32

const (
	ValidatorStatus_UNKNOWN_STATUS ValidatorStatus = 0
	ValidatorStatus_PENDING_ACTIVE ValidatorStatus = 1
	ValidatorStatus_ACTIVE         ValidatorStatus = 2
	ValidatorStatus_INITIATED_EXIT ValidatorStatus = 3
	ValidatorStatus_WITHDRAWABLE   ValidatorStatus = 4
	ValidatorStatus_EXITED         ValidatorStatus = 5
	ValidatorStatus_EXITED_SLASHED ValidatorStatus = 6
)

var ValidatorStatus_name = map[int32]string{
	0: "UNKNOWN_STATUS",
	1: "PENDING_ACTIVE",
	2: "ACTIVE",
	3: "INITIATED_EXIT",
	4: "WITHDRAWABLE",
	5: "EXITED",
	6: "EXITED_SLASHED",
}

var ValidatorStatus_value = map[string]int32{
	"UNKNOWN_STATUS": 0,
	"PENDING_ACTIVE": 1,
	"ACTIVE":         2,
	"INITIATED_EXIT": 3,
	"WITHDRAWABLE":   4,
	"EXITED":         5,
	"EXITED_SLASHED": 6,
}

func (x ValidatorStatus) String() string {
	return proto.EnumName(ValidatorStatus_name, int32(x))
}

func (ValidatorStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{1}
}

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

func (m *BlockRequest) Reset()         { *m = BlockRequest{} }
func (m *BlockRequest) String() string { return proto.CompactTextString(m) }
func (*BlockRequest) ProtoMessage()    {}
func (*BlockRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{0}
}
func (m *BlockRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockRequest.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 *BlockRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockRequest.Merge(m, src)
}
func (m *BlockRequest) XXX_Size() int {
	return m.Size()
}
func (m *BlockRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BlockRequest proto.InternalMessageInfo

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

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

type ProposeResponse struct {
	BlockRoot            []byte   `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,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_9eb4e94b85965285, []int{1}
}
func (m *ProposeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProposeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProposeResponse.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 *ProposeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProposeResponse.Merge(m, src)
}
func (m *ProposeResponse) XXX_Size() int {
	return m.Size()
}
func (m *ProposeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ProposeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ProposeResponse proto.InternalMessageInfo

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

type AttestationRequest struct {
	PublicKey            []byte   `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	PocBit               []byte   `protobuf:"bytes,2,opt,name=poc_bit,json=pocBit,proto3" json:"poc_bit,omitempty"`
	Slot                 uint64   `protobuf:"varint,3,opt,name=slot,proto3" json:"slot,omitempty"`
	Shard                uint64   `protobuf:"varint,4,opt,name=shard,proto3" json:"shard,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AttestationRequest) Reset()         { *m = AttestationRequest{} }
func (m *AttestationRequest) String() string { return proto.CompactTextString(m) }
func (*AttestationRequest) ProtoMessage()    {}
func (*AttestationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{2}
}
func (m *AttestationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AttestationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AttestationRequest.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 *AttestationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttestationRequest.Merge(m, src)
}
func (m *AttestationRequest) XXX_Size() int {
	return m.Size()
}
func (m *AttestationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AttestationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AttestationRequest proto.InternalMessageInfo

func (m *AttestationRequest) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *AttestationRequest) GetPocBit() []byte {
	if m != nil {
		return m.PocBit
	}
	return nil
}

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

func (m *AttestationRequest) GetShard() uint64 {
	if m != nil {
		return m.Shard
	}
	return 0
}

type AttestResponse struct {
	Root                 []byte   `protobuf:"bytes,1,opt,name=root,proto3" json:"root,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_9eb4e94b85965285, []int{3}
}
func (m *AttestResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AttestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AttestResponse.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 *AttestResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AttestResponse.Merge(m, src)
}
func (m *AttestResponse) XXX_Size() int {
	return m.Size()
}
func (m *AttestResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AttestResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AttestResponse proto.InternalMessageInfo

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

type ValidatorPerformanceRequest struct {
	Slot                 uint64   `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	PublicKey            []byte   `protobuf:"bytes,2,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 *ValidatorPerformanceRequest) Reset()         { *m = ValidatorPerformanceRequest{} }
func (m *ValidatorPerformanceRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorPerformanceRequest) ProtoMessage()    {}
func (*ValidatorPerformanceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{4}
}
func (m *ValidatorPerformanceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorPerformanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorPerformanceRequest.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 *ValidatorPerformanceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorPerformanceRequest.Merge(m, src)
}
func (m *ValidatorPerformanceRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorPerformanceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorPerformanceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorPerformanceRequest proto.InternalMessageInfo

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

func (m *ValidatorPerformanceRequest) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type ValidatorPerformanceResponse struct {
	Balance                       uint64   `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty"`
	TotalValidators               uint64   `protobuf:"varint,2,opt,name=total_validators,json=totalValidators,proto3" json:"total_validators,omitempty"`
	TotalActiveValidators         uint64   `protobuf:"varint,3,opt,name=total_active_validators,json=totalActiveValidators,proto3" json:"total_active_validators,omitempty"`
	AverageActiveValidatorBalance float32  `protobuf:"fixed32,4,opt,name=average_active_validator_balance,json=averageActiveValidatorBalance,proto3" json:"average_active_validator_balance,omitempty"`
	XXX_NoUnkeyedLiteral          struct{} `json:"-"`
	XXX_unrecognized              []byte   `json:"-"`
	XXX_sizecache                 int32    `json:"-"`
}

func (m *ValidatorPerformanceResponse) Reset()         { *m = ValidatorPerformanceResponse{} }
func (m *ValidatorPerformanceResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorPerformanceResponse) ProtoMessage()    {}
func (*ValidatorPerformanceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{5}
}
func (m *ValidatorPerformanceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorPerformanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorPerformanceResponse.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 *ValidatorPerformanceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorPerformanceResponse.Merge(m, src)
}
func (m *ValidatorPerformanceResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorPerformanceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorPerformanceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorPerformanceResponse proto.InternalMessageInfo

func (m *ValidatorPerformanceResponse) GetBalance() uint64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (m *ValidatorPerformanceResponse) GetTotalValidators() uint64 {
	if m != nil {
		return m.TotalValidators
	}
	return 0
}

func (m *ValidatorPerformanceResponse) GetTotalActiveValidators() uint64 {
	if m != nil {
		return m.TotalActiveValidators
	}
	return 0
}

func (m *ValidatorPerformanceResponse) GetAverageActiveValidatorBalance() float32 {
	if m != nil {
		return m.AverageActiveValidatorBalance
	}
	return 0
}

type ValidatorActivationRequest struct {
	PublicKeys           [][]byte `protobuf:"bytes,1,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ValidatorActivationRequest) Reset()         { *m = ValidatorActivationRequest{} }
func (m *ValidatorActivationRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorActivationRequest) ProtoMessage()    {}
func (*ValidatorActivationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{6}
}
func (m *ValidatorActivationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorActivationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorActivationRequest.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 *ValidatorActivationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorActivationRequest.Merge(m, src)
}
func (m *ValidatorActivationRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorActivationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorActivationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorActivationRequest proto.InternalMessageInfo

func (m *ValidatorActivationRequest) GetPublicKeys() [][]byte {
	if m != nil {
		return m.PublicKeys
	}
	return nil
}

type ValidatorActivationResponse struct {
	ActivatedPublicKeys  [][]byte                              `protobuf:"bytes,1,rep,name=activated_public_keys,json=activatedPublicKeys,proto3" json:"activated_public_keys,omitempty"` // Deprecated: Do not use.
	Statuses             []*ValidatorActivationResponse_Status `protobuf:"bytes,2,rep,name=statuses,proto3" json:"statuses,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *ValidatorActivationResponse) Reset()         { *m = ValidatorActivationResponse{} }
func (m *ValidatorActivationResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorActivationResponse) ProtoMessage()    {}
func (*ValidatorActivationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{7}
}
func (m *ValidatorActivationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorActivationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorActivationResponse.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 *ValidatorActivationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorActivationResponse.Merge(m, src)
}
func (m *ValidatorActivationResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorActivationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorActivationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorActivationResponse proto.InternalMessageInfo

// Deprecated: Do not use.
func (m *ValidatorActivationResponse) GetActivatedPublicKeys() [][]byte {
	if m != nil {
		return m.ActivatedPublicKeys
	}
	return nil
}

func (m *ValidatorActivationResponse) GetStatuses() []*ValidatorActivationResponse_Status {
	if m != nil {
		return m.Statuses
	}
	return nil
}

type ValidatorActivationResponse_Status struct {
	PublicKey            []byte                   `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	Status               *ValidatorStatusResponse `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *ValidatorActivationResponse_Status) Reset()         { *m = ValidatorActivationResponse_Status{} }
func (m *ValidatorActivationResponse_Status) String() string { return proto.CompactTextString(m) }
func (*ValidatorActivationResponse_Status) ProtoMessage()    {}
func (*ValidatorActivationResponse_Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{7, 0}
}
func (m *ValidatorActivationResponse_Status) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorActivationResponse_Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorActivationResponse_Status.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 *ValidatorActivationResponse_Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorActivationResponse_Status.Merge(m, src)
}
func (m *ValidatorActivationResponse_Status) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorActivationResponse_Status) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorActivationResponse_Status.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorActivationResponse_Status proto.InternalMessageInfo

func (m *ValidatorActivationResponse_Status) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *ValidatorActivationResponse_Status) GetStatus() *ValidatorStatusResponse {
	if m != nil {
		return m.Status
	}
	return nil
}

type ExitedValidatorsRequest struct {
	PublicKeys           [][]byte `protobuf:"bytes,1,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExitedValidatorsRequest) Reset()         { *m = ExitedValidatorsRequest{} }
func (m *ExitedValidatorsRequest) String() string { return proto.CompactTextString(m) }
func (*ExitedValidatorsRequest) ProtoMessage()    {}
func (*ExitedValidatorsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{8}
}
func (m *ExitedValidatorsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExitedValidatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExitedValidatorsRequest.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 *ExitedValidatorsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExitedValidatorsRequest.Merge(m, src)
}
func (m *ExitedValidatorsRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExitedValidatorsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExitedValidatorsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExitedValidatorsRequest proto.InternalMessageInfo

func (m *ExitedValidatorsRequest) GetPublicKeys() [][]byte {
	if m != nil {
		return m.PublicKeys
	}
	return nil
}

type ExitedValidatorsResponse struct {
	PublicKeys           [][]byte `protobuf:"bytes,1,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExitedValidatorsResponse) Reset()         { *m = ExitedValidatorsResponse{} }
func (m *ExitedValidatorsResponse) String() string { return proto.CompactTextString(m) }
func (*ExitedValidatorsResponse) ProtoMessage()    {}
func (*ExitedValidatorsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{9}
}
func (m *ExitedValidatorsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExitedValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExitedValidatorsResponse.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 *ExitedValidatorsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExitedValidatorsResponse.Merge(m, src)
}
func (m *ExitedValidatorsResponse) XXX_Size() int {
	return m.Size()
}
func (m *ExitedValidatorsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExitedValidatorsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExitedValidatorsResponse proto.InternalMessageInfo

func (m *ExitedValidatorsResponse) GetPublicKeys() [][]byte {
	if m != nil {
		return m.PublicKeys
	}
	return nil
}

type ChainStartResponse struct {
	Started              bool     `protobuf:"varint,1,opt,name=started,proto3" json:"started,omitempty"`
	GenesisTime          uint64   `protobuf:"varint,2,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChainStartResponse) Reset()         { *m = ChainStartResponse{} }
func (m *ChainStartResponse) String() string { return proto.CompactTextString(m) }
func (*ChainStartResponse) ProtoMessage()    {}
func (*ChainStartResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{10}
}
func (m *ChainStartResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChainStartResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChainStartResponse.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 *ChainStartResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChainStartResponse.Merge(m, src)
}
func (m *ChainStartResponse) XXX_Size() int {
	return m.Size()
}
func (m *ChainStartResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ChainStartResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ChainStartResponse proto.InternalMessageInfo

func (m *ChainStartResponse) GetStarted() bool {
	if m != nil {
		return m.Started
	}
	return false
}

func (m *ChainStartResponse) GetGenesisTime() uint64 {
	if m != nil {
		return m.GenesisTime
	}
	return 0
}

type ValidatorIndexRequest struct {
	PublicKey            []byte   `protobuf:"bytes,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 *ValidatorIndexRequest) Reset()         { *m = ValidatorIndexRequest{} }
func (m *ValidatorIndexRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorIndexRequest) ProtoMessage()    {}
func (*ValidatorIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{11}
}
func (m *ValidatorIndexRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorIndexRequest.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 *ValidatorIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorIndexRequest.Merge(m, src)
}
func (m *ValidatorIndexRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorIndexRequest proto.InternalMessageInfo

func (m *ValidatorIndexRequest) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

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

func (m *ValidatorIndexResponse) Reset()         { *m = ValidatorIndexResponse{} }
func (m *ValidatorIndexResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorIndexResponse) ProtoMessage()    {}
func (*ValidatorIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{12}
}
func (m *ValidatorIndexResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorIndexResponse.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 *ValidatorIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorIndexResponse.Merge(m, src)
}
func (m *ValidatorIndexResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorIndexResponse proto.InternalMessageInfo

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

type AssignmentRequest struct {
	EpochStart           uint64   `protobuf:"varint,1,opt,name=epoch_start,json=epochStart,proto3" json:"epoch_start,omitempty"`
	PublicKeys           [][]byte `protobuf:"bytes,2,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AssignmentRequest) Reset()         { *m = AssignmentRequest{} }
func (m *AssignmentRequest) String() string { return proto.CompactTextString(m) }
func (*AssignmentRequest) ProtoMessage()    {}
func (*AssignmentRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{13}
}
func (m *AssignmentRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AssignmentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AssignmentRequest.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 *AssignmentRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssignmentRequest.Merge(m, src)
}
func (m *AssignmentRequest) XXX_Size() int {
	return m.Size()
}
func (m *AssignmentRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AssignmentRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AssignmentRequest proto.InternalMessageInfo

func (m *AssignmentRequest) GetEpochStart() uint64 {
	if m != nil {
		return m.EpochStart
	}
	return 0
}

func (m *AssignmentRequest) GetPublicKeys() [][]byte {
	if m != nil {
		return m.PublicKeys
	}
	return nil
}

type AssignmentResponse struct {
	ValidatorAssignment  []*AssignmentResponse_ValidatorAssignment `protobuf:"bytes,1,rep,name=validator_assignment,json=validatorAssignment,proto3" json:"validator_assignment,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                  `json:"-"`
	XXX_unrecognized     []byte                                    `json:"-"`
	XXX_sizecache        int32                                     `json:"-"`
}

func (m *AssignmentResponse) Reset()         { *m = AssignmentResponse{} }
func (m *AssignmentResponse) String() string { return proto.CompactTextString(m) }
func (*AssignmentResponse) ProtoMessage()    {}
func (*AssignmentResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{14}
}
func (m *AssignmentResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AssignmentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AssignmentResponse.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 *AssignmentResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssignmentResponse.Merge(m, src)
}
func (m *AssignmentResponse) XXX_Size() int {
	return m.Size()
}
func (m *AssignmentResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AssignmentResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AssignmentResponse proto.InternalMessageInfo

func (m *AssignmentResponse) GetValidatorAssignment() []*AssignmentResponse_ValidatorAssignment {
	if m != nil {
		return m.ValidatorAssignment
	}
	return nil
}

type AssignmentResponse_ValidatorAssignment struct {
	Committee            []uint64        `protobuf:"varint,1,rep,packed,name=committee,proto3" json:"committee,omitempty"`
	Shard                uint64          `protobuf:"varint,2,opt,name=shard,proto3" json:"shard,omitempty"`
	Slot                 uint64          `protobuf:"varint,3,opt,name=slot,proto3" json:"slot,omitempty"`
	IsProposer           bool            `protobuf:"varint,4,opt,name=is_proposer,json=isProposer,proto3" json:"is_proposer,omitempty"`
	PublicKey            []byte          `protobuf:"bytes,5,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	Status               ValidatorStatus `protobuf:"varint,6,opt,name=status,proto3,enum=ethereum.beacon.rpc.v1.ValidatorStatus" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AssignmentResponse_ValidatorAssignment) Reset() {
	*m = AssignmentResponse_ValidatorAssignment{}
}
func (m *AssignmentResponse_ValidatorAssignment) String() string { return proto.CompactTextString(m) }
func (*AssignmentResponse_ValidatorAssignment) ProtoMessage()    {}
func (*AssignmentResponse_ValidatorAssignment) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{14, 0}
}
func (m *AssignmentResponse_ValidatorAssignment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AssignmentResponse_ValidatorAssignment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AssignmentResponse_ValidatorAssignment.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 *AssignmentResponse_ValidatorAssignment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AssignmentResponse_ValidatorAssignment.Merge(m, src)
}
func (m *AssignmentResponse_ValidatorAssignment) XXX_Size() int {
	return m.Size()
}
func (m *AssignmentResponse_ValidatorAssignment) XXX_DiscardUnknown() {
	xxx_messageInfo_AssignmentResponse_ValidatorAssignment.DiscardUnknown(m)
}

var xxx_messageInfo_AssignmentResponse_ValidatorAssignment proto.InternalMessageInfo

func (m *AssignmentResponse_ValidatorAssignment) GetCommittee() []uint64 {
	if m != nil {
		return m.Committee
	}
	return nil
}

func (m *AssignmentResponse_ValidatorAssignment) GetShard() uint64 {
	if m != nil {
		return m.Shard
	}
	return 0
}

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

func (m *AssignmentResponse_ValidatorAssignment) GetIsProposer() bool {
	if m != nil {
		return m.IsProposer
	}
	return false
}

func (m *AssignmentResponse_ValidatorAssignment) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *AssignmentResponse_ValidatorAssignment) GetStatus() ValidatorStatus {
	if m != nil {
		return m.Status
	}
	return ValidatorStatus_UNKNOWN_STATUS
}

type ValidatorStatusResponse struct {
	Status                    ValidatorStatus `protobuf:"varint,1,opt,name=status,proto3,enum=ethereum.beacon.rpc.v1.ValidatorStatus" json:"status,omitempty"`
	Eth1DepositBlockNumber    uint64          `protobuf:"varint,2,opt,name=eth1_deposit_block_number,json=eth1DepositBlockNumber,proto3" json:"eth1_deposit_block_number,omitempty"`
	DepositInclusionSlot      uint64          `protobuf:"varint,3,opt,name=deposit_inclusion_slot,json=depositInclusionSlot,proto3" json:"deposit_inclusion_slot,omitempty"`
	ActivationEpoch           uint64          `protobuf:"varint,4,opt,name=activation_epoch,json=activationEpoch,proto3" json:"activation_epoch,omitempty"`
	PositionInActivationQueue uint64          `protobuf:"varint,5,opt,name=position_in_activation_queue,json=positionInActivationQueue,proto3" json:"position_in_activation_queue,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}        `json:"-"`
	XXX_unrecognized          []byte          `json:"-"`
	XXX_sizecache             int32           `json:"-"`
}

func (m *ValidatorStatusResponse) Reset()         { *m = ValidatorStatusResponse{} }
func (m *ValidatorStatusResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorStatusResponse) ProtoMessage()    {}
func (*ValidatorStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{15}
}
func (m *ValidatorStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorStatusResponse.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 *ValidatorStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorStatusResponse.Merge(m, src)
}
func (m *ValidatorStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorStatusResponse proto.InternalMessageInfo

func (m *ValidatorStatusResponse) GetStatus() ValidatorStatus {
	if m != nil {
		return m.Status
	}
	return ValidatorStatus_UNKNOWN_STATUS
}

func (m *ValidatorStatusResponse) GetEth1DepositBlockNumber() uint64 {
	if m != nil {
		return m.Eth1DepositBlockNumber
	}
	return 0
}

func (m *ValidatorStatusResponse) GetDepositInclusionSlot() uint64 {
	if m != nil {
		return m.DepositInclusionSlot
	}
	return 0
}

func (m *ValidatorStatusResponse) GetActivationEpoch() uint64 {
	if m != nil {
		return m.ActivationEpoch
	}
	return 0
}

func (m *ValidatorStatusResponse) GetPositionInActivationQueue() uint64 {
	if m != nil {
		return m.PositionInActivationQueue
	}
	return 0
}

type DomainRequest struct {
	Epoch                uint64   `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Domain               []byte   `protobuf:"bytes,2,opt,name=domain,proto3" json:"domain,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DomainRequest) Reset()         { *m = DomainRequest{} }
func (m *DomainRequest) String() string { return proto.CompactTextString(m) }
func (*DomainRequest) ProtoMessage()    {}
func (*DomainRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{16}
}
func (m *DomainRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DomainRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DomainRequest.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 *DomainRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DomainRequest.Merge(m, src)
}
func (m *DomainRequest) XXX_Size() int {
	return m.Size()
}
func (m *DomainRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DomainRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DomainRequest proto.InternalMessageInfo

func (m *DomainRequest) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *DomainRequest) GetDomain() []byte {
	if m != nil {
		return m.Domain
	}
	return nil
}

type DomainResponse struct {
	SignatureDomain      uint64   `protobuf:"varint,1,opt,name=signature_domain,json=signatureDomain,proto3" json:"signature_domain,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DomainResponse) Reset()         { *m = DomainResponse{} }
func (m *DomainResponse) String() string { return proto.CompactTextString(m) }
func (*DomainResponse) ProtoMessage()    {}
func (*DomainResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{17}
}
func (m *DomainResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DomainResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DomainResponse.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 *DomainResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DomainResponse.Merge(m, src)
}
func (m *DomainResponse) XXX_Size() int {
	return m.Size()
}
func (m *DomainResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DomainResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DomainResponse proto.InternalMessageInfo

func (m *DomainResponse) GetSignatureDomain() uint64 {
	if m != nil {
		return m.SignatureDomain
	}
	return 0
}

type BlockTreeResponse struct {
	Tree                 []*BlockTreeResponse_TreeNode `protobuf:"bytes,1,rep,name=tree,proto3" json:"tree,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *BlockTreeResponse) Reset()         { *m = BlockTreeResponse{} }
func (m *BlockTreeResponse) String() string { return proto.CompactTextString(m) }
func (*BlockTreeResponse) ProtoMessage()    {}
func (*BlockTreeResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{18}
}
func (m *BlockTreeResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockTreeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockTreeResponse.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 *BlockTreeResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockTreeResponse.Merge(m, src)
}
func (m *BlockTreeResponse) XXX_Size() int {
	return m.Size()
}
func (m *BlockTreeResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockTreeResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BlockTreeResponse proto.InternalMessageInfo

func (m *BlockTreeResponse) GetTree() []*BlockTreeResponse_TreeNode {
	if m != nil {
		return m.Tree
	}
	return nil
}

type BlockTreeResponse_TreeNode struct {
	Block                *v1alpha1.BeaconBlock `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	BlockRoot            []byte                `protobuf:"bytes,2,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty"`
	ParticipatedVotes    uint64                `protobuf:"varint,3,opt,name=participated_votes,json=participatedVotes,proto3" json:"participated_votes,omitempty"`
	TotalVotes           uint64                `protobuf:"varint,4,opt,name=total_votes,json=totalVotes,proto3" json:"total_votes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *BlockTreeResponse_TreeNode) Reset()         { *m = BlockTreeResponse_TreeNode{} }
func (m *BlockTreeResponse_TreeNode) String() string { return proto.CompactTextString(m) }
func (*BlockTreeResponse_TreeNode) ProtoMessage()    {}
func (*BlockTreeResponse_TreeNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{18, 0}
}
func (m *BlockTreeResponse_TreeNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockTreeResponse_TreeNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockTreeResponse_TreeNode.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 *BlockTreeResponse_TreeNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockTreeResponse_TreeNode.Merge(m, src)
}
func (m *BlockTreeResponse_TreeNode) XXX_Size() int {
	return m.Size()
}
func (m *BlockTreeResponse_TreeNode) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockTreeResponse_TreeNode.DiscardUnknown(m)
}

var xxx_messageInfo_BlockTreeResponse_TreeNode proto.InternalMessageInfo

func (m *BlockTreeResponse_TreeNode) GetBlock() *v1alpha1.BeaconBlock {
	if m != nil {
		return m.Block
	}
	return nil
}

func (m *BlockTreeResponse_TreeNode) GetBlockRoot() []byte {
	if m != nil {
		return m.BlockRoot
	}
	return nil
}

func (m *BlockTreeResponse_TreeNode) GetParticipatedVotes() uint64 {
	if m != nil {
		return m.ParticipatedVotes
	}
	return 0
}

func (m *BlockTreeResponse_TreeNode) GetTotalVotes() uint64 {
	if m != nil {
		return m.TotalVotes
	}
	return 0
}

type TreeBlockSlotRequest struct {
	SlotFrom             uint64   `protobuf:"varint,1,opt,name=slot_from,json=slotFrom,proto3" json:"slot_from,omitempty"`
	SlotTo               uint64   `protobuf:"varint,2,opt,name=slot_to,json=slotTo,proto3" json:"slot_to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TreeBlockSlotRequest) Reset()         { *m = TreeBlockSlotRequest{} }
func (m *TreeBlockSlotRequest) String() string { return proto.CompactTextString(m) }
func (*TreeBlockSlotRequest) ProtoMessage()    {}
func (*TreeBlockSlotRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9eb4e94b85965285, []int{19}
}
func (m *TreeBlockSlotRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TreeBlockSlotRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TreeBlockSlotRequest.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 *TreeBlockSlotRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TreeBlockSlotRequest.Merge(m, src)
}
func (m *TreeBlockSlotRequest) XXX_Size() int {
	return m.Size()
}
func (m *TreeBlockSlotRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TreeBlockSlotRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TreeBlockSlotRequest proto.InternalMessageInfo

func (m *TreeBlockSlotRequest) GetSlotFrom() uint64 {
	if m != nil {
		return m.SlotFrom
	}
	return 0
}

func (m *TreeBlockSlotRequest) GetSlotTo() uint64 {
	if m != nil {
		return m.SlotTo
	}
	return 0
}

func init() {
	proto.RegisterEnum("ethereum.beacon.rpc.v1.ValidatorRole", ValidatorRole_name, ValidatorRole_value)
	proto.RegisterEnum("ethereum.beacon.rpc.v1.ValidatorStatus", ValidatorStatus_name, ValidatorStatus_value)
	proto.RegisterType((*BlockRequest)(nil), "ethereum.beacon.rpc.v1.BlockRequest")
	proto.RegisterType((*ProposeResponse)(nil), "ethereum.beacon.rpc.v1.ProposeResponse")
	proto.RegisterType((*AttestationRequest)(nil), "ethereum.beacon.rpc.v1.AttestationRequest")
	proto.RegisterType((*AttestResponse)(nil), "ethereum.beacon.rpc.v1.AttestResponse")
	proto.RegisterType((*ValidatorPerformanceRequest)(nil), "ethereum.beacon.rpc.v1.ValidatorPerformanceRequest")
	proto.RegisterType((*ValidatorPerformanceResponse)(nil), "ethereum.beacon.rpc.v1.ValidatorPerformanceResponse")
	proto.RegisterType((*ValidatorActivationRequest)(nil), "ethereum.beacon.rpc.v1.ValidatorActivationRequest")
	proto.RegisterType((*ValidatorActivationResponse)(nil), "ethereum.beacon.rpc.v1.ValidatorActivationResponse")
	proto.RegisterType((*ValidatorActivationResponse_Status)(nil), "ethereum.beacon.rpc.v1.ValidatorActivationResponse.Status")
	proto.RegisterType((*ExitedValidatorsRequest)(nil), "ethereum.beacon.rpc.v1.ExitedValidatorsRequest")
	proto.RegisterType((*ExitedValidatorsResponse)(nil), "ethereum.beacon.rpc.v1.ExitedValidatorsResponse")
	proto.RegisterType((*ChainStartResponse)(nil), "ethereum.beacon.rpc.v1.ChainStartResponse")
	proto.RegisterType((*ValidatorIndexRequest)(nil), "ethereum.beacon.rpc.v1.ValidatorIndexRequest")
	proto.RegisterType((*ValidatorIndexResponse)(nil), "ethereum.beacon.rpc.v1.ValidatorIndexResponse")
	proto.RegisterType((*AssignmentRequest)(nil), "ethereum.beacon.rpc.v1.AssignmentRequest")
	proto.RegisterType((*AssignmentResponse)(nil), "ethereum.beacon.rpc.v1.AssignmentResponse")
	proto.RegisterType((*AssignmentResponse_ValidatorAssignment)(nil), "ethereum.beacon.rpc.v1.AssignmentResponse.ValidatorAssignment")
	proto.RegisterType((*ValidatorStatusResponse)(nil), "ethereum.beacon.rpc.v1.ValidatorStatusResponse")
	proto.RegisterType((*DomainRequest)(nil), "ethereum.beacon.rpc.v1.DomainRequest")
	proto.RegisterType((*DomainResponse)(nil), "ethereum.beacon.rpc.v1.DomainResponse")
	proto.RegisterType((*BlockTreeResponse)(nil), "ethereum.beacon.rpc.v1.BlockTreeResponse")
	proto.RegisterType((*BlockTreeResponse_TreeNode)(nil), "ethereum.beacon.rpc.v1.BlockTreeResponse.TreeNode")
	proto.RegisterType((*TreeBlockSlotRequest)(nil), "ethereum.beacon.rpc.v1.TreeBlockSlotRequest")
}

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

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

// 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 {
	WaitForChainStart(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconService_WaitForChainStartClient, error)
	CanonicalHead(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*v1alpha1.BeaconBlock, error)
	BlockTree(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*BlockTreeResponse, error)
	BlockTreeBySlots(ctx context.Context, in *TreeBlockSlotRequest, opts ...grpc.CallOption) (*BlockTreeResponse, error)
}

type beaconServiceClient struct {
	cc *grpc.ClientConn
}

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

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

type beaconServiceWaitForChainStartClient struct {
	grpc.ClientStream
}

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

func (c *beaconServiceClient) CanonicalHead(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*v1alpha1.BeaconBlock, error) {
	out := new(v1alpha1.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) BlockTree(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*BlockTreeResponse, error) {
	out := new(BlockTreeResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.BeaconService/BlockTree", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

// BeaconServiceServer is the server API for BeaconService service.
type BeaconServiceServer interface {
	WaitForChainStart(*types.Empty, BeaconService_WaitForChainStartServer) error
	CanonicalHead(context.Context, *types.Empty) (*v1alpha1.BeaconBlock, error)
	BlockTree(context.Context, *types.Empty) (*BlockTreeResponse, error)
	BlockTreeBySlots(context.Context, *TreeBlockSlotRequest) (*BlockTreeResponse, error)
}

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

func _BeaconService_WaitForChainStart_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(types.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BeaconServiceServer).WaitForChainStart(m, &beaconServiceWaitForChainStartServer{stream})
}

type BeaconService_WaitForChainStartServer interface {
	Send(*ChainStartResponse) error
	grpc.ServerStream
}

type beaconServiceWaitForChainStartServer struct {
	grpc.ServerStream
}

func (x *beaconServiceWaitForChainStartServer) Send(m *ChainStartResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _BeaconService_CanonicalHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.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.(*types.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

var _BeaconService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.BeaconService",
	HandlerType: (*BeaconServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CanonicalHead",
			Handler:    _BeaconService_CanonicalHead_Handler,
		},
		{
			MethodName: "BlockTree",
			Handler:    _BeaconService_BlockTree_Handler,
		},
		{
			MethodName: "BlockTreeBySlots",
			Handler:    _BeaconService_BlockTreeBySlots_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WaitForChainStart",
			Handler:       _BeaconService_WaitForChainStart_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 {
	RequestAttestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (*v1alpha1.AttestationData, error)
	SubmitAttestation(ctx context.Context, in *v1alpha1.Attestation, opts ...grpc.CallOption) (*AttestResponse, error)
}

type attesterServiceClient struct {
	cc *grpc.ClientConn
}

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

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

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

// AttesterServiceServer is the server API for AttesterService service.
type AttesterServiceServer interface {
	RequestAttestation(context.Context, *AttestationRequest) (*v1alpha1.AttestationData, error)
	SubmitAttestation(context.Context, *v1alpha1.Attestation) (*AttestResponse, error)
}

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

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

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

var _AttesterService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.AttesterService",
	HandlerType: (*AttesterServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RequestAttestation",
			Handler:    _AttesterService_RequestAttestation_Handler,
		},
		{
			MethodName: "SubmitAttestation",
			Handler:    _AttesterService_SubmitAttestation_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 {
	RequestBlock(ctx context.Context, in *BlockRequest, opts ...grpc.CallOption) (*v1alpha1.BeaconBlock, error)
	ProposeBlock(ctx context.Context, in *v1alpha1.BeaconBlock, opts ...grpc.CallOption) (*ProposeResponse, error)
}

type proposerServiceClient struct {
	cc *grpc.ClientConn
}

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

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

func (c *proposerServiceClient) ProposeBlock(ctx context.Context, in *v1alpha1.BeaconBlock, 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 {
	RequestBlock(context.Context, *BlockRequest) (*v1alpha1.BeaconBlock, error)
	ProposeBlock(context.Context, *v1alpha1.BeaconBlock) (*ProposeResponse, error)
}

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

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

func _ProposerService_ProposeBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(v1alpha1.BeaconBlock)
	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.(*v1alpha1.BeaconBlock))
	}
	return interceptor(ctx, in, info, handler)
}

var _ProposerService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.ProposerService",
	HandlerType: (*ProposerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RequestBlock",
			Handler:    _ProposerService_RequestBlock_Handler,
		},
		{
			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 {
	DomainData(ctx context.Context, in *DomainRequest, opts ...grpc.CallOption) (*DomainResponse, error)
	WaitForActivation(ctx context.Context, in *ValidatorActivationRequest, opts ...grpc.CallOption) (ValidatorService_WaitForActivationClient, error)
	ValidatorIndex(ctx context.Context, in *ValidatorIndexRequest, opts ...grpc.CallOption) (*ValidatorIndexResponse, error)
	CommitteeAssignment(ctx context.Context, in *AssignmentRequest, opts ...grpc.CallOption) (*AssignmentResponse, error)
	ValidatorStatus(ctx context.Context, in *ValidatorIndexRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error)
	ValidatorPerformance(ctx context.Context, in *ValidatorPerformanceRequest, opts ...grpc.CallOption) (*ValidatorPerformanceResponse, error)
	ExitedValidators(ctx context.Context, in *ExitedValidatorsRequest, opts ...grpc.CallOption) (*ExitedValidatorsResponse, error)
}

type validatorServiceClient struct {
	cc *grpc.ClientConn
}

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

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

func (c *validatorServiceClient) WaitForActivation(ctx context.Context, in *ValidatorActivationRequest, opts ...grpc.CallOption) (ValidatorService_WaitForActivationClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ValidatorService_serviceDesc.Streams[0], "/ethereum.beacon.rpc.v1.ValidatorService/WaitForActivation", opts...)
	if err != nil {
		return nil, err
	}
	x := &validatorServiceWaitForActivationClient{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 ValidatorService_WaitForActivationClient interface {
	Recv() (*ValidatorActivationResponse, error)
	grpc.ClientStream
}

type validatorServiceWaitForActivationClient struct {
	grpc.ClientStream
}

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

func (c *validatorServiceClient) ValidatorIndex(ctx context.Context, in *ValidatorIndexRequest, opts ...grpc.CallOption) (*ValidatorIndexResponse, error) {
	out := new(ValidatorIndexResponse)
	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) CommitteeAssignment(ctx context.Context, in *AssignmentRequest, opts ...grpc.CallOption) (*AssignmentResponse, error) {
	out := new(AssignmentResponse)
	err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/CommitteeAssignment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

// ValidatorServiceServer is the server API for ValidatorService service.
type ValidatorServiceServer interface {
	DomainData(context.Context, *DomainRequest) (*DomainResponse, error)
	WaitForActivation(*ValidatorActivationRequest, ValidatorService_WaitForActivationServer) error
	ValidatorIndex(context.Context, *ValidatorIndexRequest) (*ValidatorIndexResponse, error)
	CommitteeAssignment(context.Context, *AssignmentRequest) (*AssignmentResponse, error)
	ValidatorStatus(context.Context, *ValidatorIndexRequest) (*ValidatorStatusResponse, error)
	ValidatorPerformance(context.Context, *ValidatorPerformanceRequest) (*ValidatorPerformanceResponse, error)
	ExitedValidators(context.Context, *ExitedValidatorsRequest) (*ExitedValidatorsResponse, error)
}

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

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

func _ValidatorService_WaitForActivation_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ValidatorActivationRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ValidatorServiceServer).WaitForActivation(m, &validatorServiceWaitForActivationServer{stream})
}

type ValidatorService_WaitForActivationServer interface {
	Send(*ValidatorActivationResponse) error
	grpc.ServerStream
}

type validatorServiceWaitForActivationServer struct {
	grpc.ServerStream
}

func (x *validatorServiceWaitForActivationServer) Send(m *ValidatorActivationResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ValidatorService_ValidatorIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidatorIndexRequest)
	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.(*ValidatorIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

var _ValidatorService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.beacon.rpc.v1.ValidatorService",
	HandlerType: (*ValidatorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DomainData",
			Handler:    _ValidatorService_DomainData_Handler,
		},
		{
			MethodName: "ValidatorIndex",
			Handler:    _ValidatorService_ValidatorIndex_Handler,
		},
		{
			MethodName: "CommitteeAssignment",
			Handler:    _ValidatorService_CommitteeAssignment_Handler,
		},
		{
			MethodName: "ValidatorStatus",
			Handler:    _ValidatorService_ValidatorStatus_Handler,
		},
		{
			MethodName: "ValidatorPerformance",
			Handler:    _ValidatorService_ValidatorPerformance_Handler,
		},
		{
			MethodName: "ExitedValidators",
			Handler:    _ValidatorService_ExitedValidators_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WaitForActivation",
			Handler:       _ValidatorService_WaitForActivation_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "proto/beacon/rpc/v1/services.proto",
}

func (m *BlockRequest) 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 *BlockRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Slot != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Slot))
	}
	if len(m.RandaoReveal) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.RandaoReveal)))
		i += copy(dAtA[i:], m.RandaoReveal)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ProposeResponse) 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 *ProposeResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.BlockRoot) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.BlockRoot)))
		i += copy(dAtA[i:], m.BlockRoot)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AttestationRequest) 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 *AttestationRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if len(m.PocBit) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PocBit)))
		i += copy(dAtA[i:], m.PocBit)
	}
	if m.Slot != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Slot))
	}
	if m.Shard != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Shard))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AttestResponse) 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 *AttestResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Root) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.Root)))
		i += copy(dAtA[i:], m.Root)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorPerformanceRequest) 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 *ValidatorPerformanceRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Slot != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Slot))
	}
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorPerformanceResponse) 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 *ValidatorPerformanceResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Balance != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Balance))
	}
	if m.TotalValidators != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.TotalValidators))
	}
	if m.TotalActiveValidators != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.TotalActiveValidators))
	}
	if m.AverageActiveValidatorBalance != 0 {
		dAtA[i] = 0x25
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.AverageActiveValidatorBalance))))
		i += 4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorActivationRequest) 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 *ValidatorActivationRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorActivationResponse) 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 *ValidatorActivationResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ActivatedPublicKeys) > 0 {
		for _, b := range m.ActivatedPublicKeys {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if len(m.Statuses) > 0 {
		for _, msg := range m.Statuses {
			dAtA[i] = 0x12
			i++
			i = encodeVarintServices(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 *ValidatorActivationResponse_Status) 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 *ValidatorActivationResponse_Status) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Status.Size()))
		n1, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ExitedValidatorsRequest) 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 *ExitedValidatorsRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ExitedValidatorsResponse) 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 *ExitedValidatorsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChainStartResponse) 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 *ChainStartResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Started {
		dAtA[i] = 0x8
		i++
		if m.Started {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.GenesisTime != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.GenesisTime))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorIndexRequest) 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 *ValidatorIndexRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorIndexResponse) 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 *ValidatorIndexResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AssignmentRequest) 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 *AssignmentRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.EpochStart != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.EpochStart))
	}
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			dAtA[i] = 0x12
			i++
			i = encodeVarintServices(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *AssignmentResponse) 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 *AssignmentResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ValidatorAssignment) > 0 {
		for _, msg := range m.ValidatorAssignment {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(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 *AssignmentResponse_ValidatorAssignment) 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 *AssignmentResponse_ValidatorAssignment) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Committee) > 0 {
		dAtA3 := make([]byte, len(m.Committee)*10)
		var j2 int
		for _, num := range m.Committee {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(j2))
		i += copy(dAtA[i:], dAtA3[:j2])
	}
	if m.Shard != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Shard))
	}
	if m.Slot != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Slot))
	}
	if m.IsProposer {
		dAtA[i] = 0x20
		i++
		if m.IsProposer {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Status))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorStatusResponse) 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 *ValidatorStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Status != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Status))
	}
	if m.Eth1DepositBlockNumber != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Eth1DepositBlockNumber))
	}
	if m.DepositInclusionSlot != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.DepositInclusionSlot))
	}
	if m.ActivationEpoch != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.ActivationEpoch))
	}
	if m.PositionInActivationQueue != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.PositionInActivationQueue))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DomainRequest) 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 *DomainRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Epoch != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Epoch))
	}
	if len(m.Domain) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.Domain)))
		i += copy(dAtA[i:], m.Domain)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *DomainResponse) 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 *DomainResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SignatureDomain != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.SignatureDomain))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BlockTreeResponse) 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 *BlockTreeResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tree) > 0 {
		for _, msg := range m.Tree {
			dAtA[i] = 0xa
			i++
			i = encodeVarintServices(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 *BlockTreeResponse_TreeNode) 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 *BlockTreeResponse_TreeNode) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Block != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.Block.Size()))
		n4, err := m.Block.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if len(m.BlockRoot) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintServices(dAtA, i, uint64(len(m.BlockRoot)))
		i += copy(dAtA[i:], m.BlockRoot)
	}
	if m.ParticipatedVotes != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.ParticipatedVotes))
	}
	if m.TotalVotes != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.TotalVotes))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TreeBlockSlotRequest) 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 *TreeBlockSlotRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SlotFrom != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.SlotFrom))
	}
	if m.SlotTo != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintServices(dAtA, i, uint64(m.SlotTo))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintServices(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 *BlockRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Slot != 0 {
		n += 1 + sovServices(uint64(m.Slot))
	}
	l = len(m.RandaoReveal)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ProposeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BlockRoot)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AttestationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	l = len(m.PocBit)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.Slot != 0 {
		n += 1 + sovServices(uint64(m.Slot))
	}
	if m.Shard != 0 {
		n += 1 + sovServices(uint64(m.Shard))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AttestResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Root)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorPerformanceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Slot != 0 {
		n += 1 + sovServices(uint64(m.Slot))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorPerformanceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Balance != 0 {
		n += 1 + sovServices(uint64(m.Balance))
	}
	if m.TotalValidators != 0 {
		n += 1 + sovServices(uint64(m.TotalValidators))
	}
	if m.TotalActiveValidators != 0 {
		n += 1 + sovServices(uint64(m.TotalActiveValidators))
	}
	if m.AverageActiveValidatorBalance != 0 {
		n += 5
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorActivationRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			l = len(b)
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorActivationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ActivatedPublicKeys) > 0 {
		for _, b := range m.ActivatedPublicKeys {
			l = len(b)
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if len(m.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorActivationResponse_Status) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExitedValidatorsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			l = len(b)
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExitedValidatorsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			l = len(b)
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChainStartResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Started {
		n += 2
	}
	if m.GenesisTime != 0 {
		n += 1 + sovServices(uint64(m.GenesisTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorIndexRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorIndexResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovServices(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AssignmentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochStart != 0 {
		n += 1 + sovServices(uint64(m.EpochStart))
	}
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			l = len(b)
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AssignmentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ValidatorAssignment) > 0 {
		for _, e := range m.ValidatorAssignment {
			l = e.Size()
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AssignmentResponse_ValidatorAssignment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Committee) > 0 {
		l = 0
		for _, e := range m.Committee {
			l += sovServices(uint64(e))
		}
		n += 1 + sovServices(uint64(l)) + l
	}
	if m.Shard != 0 {
		n += 1 + sovServices(uint64(m.Shard))
	}
	if m.Slot != 0 {
		n += 1 + sovServices(uint64(m.Slot))
	}
	if m.IsProposer {
		n += 2
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovServices(uint64(m.Status))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != 0 {
		n += 1 + sovServices(uint64(m.Status))
	}
	if m.Eth1DepositBlockNumber != 0 {
		n += 1 + sovServices(uint64(m.Eth1DepositBlockNumber))
	}
	if m.DepositInclusionSlot != 0 {
		n += 1 + sovServices(uint64(m.DepositInclusionSlot))
	}
	if m.ActivationEpoch != 0 {
		n += 1 + sovServices(uint64(m.ActivationEpoch))
	}
	if m.PositionInActivationQueue != 0 {
		n += 1 + sovServices(uint64(m.PositionInActivationQueue))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DomainRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Epoch != 0 {
		n += 1 + sovServices(uint64(m.Epoch))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DomainResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignatureDomain != 0 {
		n += 1 + sovServices(uint64(m.SignatureDomain))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BlockTreeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tree) > 0 {
		for _, e := range m.Tree {
			l = e.Size()
			n += 1 + l + sovServices(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BlockTreeResponse_TreeNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Block != nil {
		l = m.Block.Size()
		n += 1 + l + sovServices(uint64(l))
	}
	l = len(m.BlockRoot)
	if l > 0 {
		n += 1 + l + sovServices(uint64(l))
	}
	if m.ParticipatedVotes != 0 {
		n += 1 + sovServices(uint64(m.ParticipatedVotes))
	}
	if m.TotalVotes != 0 {
		n += 1 + sovServices(uint64(m.TotalVotes))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TreeBlockSlotRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlotFrom != 0 {
		n += 1 + sovServices(uint64(m.SlotFrom))
	}
	if m.SlotTo != 0 {
		n += 1 + sovServices(uint64(m.SlotTo))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovServices(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozServices(x uint64) (n int) {
	return sovServices(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BlockRequest) 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 ErrIntOverflowServices
			}
			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: BlockRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockRequest: 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 ErrIntOverflowServices
				}
				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 RandaoReveal", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RandaoReveal = append(m.RandaoReveal[:0], dAtA[iNdEx:postIndex]...)
			if m.RandaoReveal == nil {
				m.RandaoReveal = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ProposeResponse) 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 ErrIntOverflowServices
			}
			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: ProposeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProposeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockRoot = append(m.BlockRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockRoot == nil {
				m.BlockRoot = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *AttestationRequest) 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 ErrIntOverflowServices
			}
			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: AttestationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttestationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PocBit", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PocBit = append(m.PocBit[:0], dAtA[iNdEx:postIndex]...)
			if m.PocBit == nil {
				m.PocBit = []byte{}
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
			}
			m.Shard = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Shard |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *AttestResponse) 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 ErrIntOverflowServices
			}
			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: AttestResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttestResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Root = append(m.Root[:0], dAtA[iNdEx:postIndex]...)
			if m.Root == nil {
				m.Root = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorPerformanceRequest) 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 ErrIntOverflowServices
			}
			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: ValidatorPerformanceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorPerformanceRequest: 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 ErrIntOverflowServices
				}
				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 PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorPerformanceResponse) 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 ErrIntOverflowServices
			}
			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: ValidatorPerformanceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorPerformanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
			}
			m.Balance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalValidators", wireType)
			}
			m.TotalValidators = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalValidators |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalActiveValidators", wireType)
			}
			m.TotalActiveValidators = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalActiveValidators |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field AverageActiveValidatorBalance", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.AverageActiveValidatorBalance = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorActivationRequest) 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 ErrIntOverflowServices
			}
			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: ValidatorActivationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorActivationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKeys = append(m.PublicKeys, make([]byte, postIndex-iNdEx))
			copy(m.PublicKeys[len(m.PublicKeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorActivationResponse) 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 ErrIntOverflowServices
			}
			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: ValidatorActivationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorActivationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivatedPublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ActivatedPublicKeys = append(m.ActivatedPublicKeys, make([]byte, postIndex-iNdEx))
			copy(m.ActivatedPublicKeys[len(m.ActivatedPublicKeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Statuses = append(m.Statuses, &ValidatorActivationResponse_Status{})
			if err := m.Statuses[len(m.Statuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorActivationResponse_Status) 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 ErrIntOverflowServices
			}
			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: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &ValidatorStatusResponse{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ExitedValidatorsRequest) 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 ErrIntOverflowServices
			}
			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: ExitedValidatorsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExitedValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKeys = append(m.PublicKeys, make([]byte, postIndex-iNdEx))
			copy(m.PublicKeys[len(m.PublicKeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ExitedValidatorsResponse) 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 ErrIntOverflowServices
			}
			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: ExitedValidatorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExitedValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKeys = append(m.PublicKeys, make([]byte, postIndex-iNdEx))
			copy(m.PublicKeys[len(m.PublicKeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ChainStartResponse) 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 ErrIntOverflowServices
			}
			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: ChainStartResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChainStartResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Started", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Started = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisTime", wireType)
			}
			m.GenesisTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GenesisTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorIndexRequest) 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 ErrIntOverflowServices
			}
			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: ValidatorIndexRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorIndexResponse) 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 ErrIntOverflowServices
			}
			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: ValidatorIndexResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorIndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *AssignmentRequest) 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 ErrIntOverflowServices
			}
			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: AssignmentRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssignmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochStart", wireType)
			}
			m.EpochStart = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochStart |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKeys = append(m.PublicKeys, make([]byte, postIndex-iNdEx))
			copy(m.PublicKeys[len(m.PublicKeys)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *AssignmentResponse) 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 ErrIntOverflowServices
			}
			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: AssignmentResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AssignmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAssignment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAssignment = append(m.ValidatorAssignment, &AssignmentResponse_ValidatorAssignment{})
			if err := m.ValidatorAssignment[len(m.ValidatorAssignment)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *AssignmentResponse_ValidatorAssignment) 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 ErrIntOverflowServices
			}
			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: ValidatorAssignment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorAssignment: 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 ErrIntOverflowServices
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Committee = append(m.Committee, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowServices
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthServices
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthServices
				}
				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.Committee) == 0 {
					m.Committee = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowServices
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Committee = append(m.Committee, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Committee", wireType)
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
			}
			m.Shard = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Shard |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsProposer", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsProposer = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ValidatorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *ValidatorStatusResponse) 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 ErrIntOverflowServices
			}
			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: ValidatorStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ValidatorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eth1DepositBlockNumber", wireType)
			}
			m.Eth1DepositBlockNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Eth1DepositBlockNumber |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DepositInclusionSlot", wireType)
			}
			m.DepositInclusionSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DepositInclusionSlot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivationEpoch", wireType)
			}
			m.ActivationEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActivationEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PositionInActivationQueue", wireType)
			}
			m.PositionInActivationQueue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PositionInActivationQueue |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *DomainRequest) 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 ErrIntOverflowServices
			}
			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: DomainRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DomainRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = append(m.Domain[:0], dAtA[iNdEx:postIndex]...)
			if m.Domain == nil {
				m.Domain = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *DomainResponse) 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 ErrIntOverflowServices
			}
			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: DomainResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DomainResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignatureDomain", wireType)
			}
			m.SignatureDomain = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignatureDomain |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *BlockTreeResponse) 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 ErrIntOverflowServices
			}
			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: BlockTreeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockTreeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tree = append(m.Tree, &BlockTreeResponse_TreeNode{})
			if err := m.Tree[len(m.Tree)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *BlockTreeResponse_TreeNode) 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 ErrIntOverflowServices
			}
			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: TreeNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Block == nil {
				m.Block = &v1alpha1.BeaconBlock{}
			}
			if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthServices
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthServices
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BlockRoot = append(m.BlockRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.BlockRoot == nil {
				m.BlockRoot = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParticipatedVotes", wireType)
			}
			m.ParticipatedVotes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ParticipatedVotes |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalVotes", wireType)
			}
			m.TotalVotes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalVotes |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 *TreeBlockSlotRequest) 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 ErrIntOverflowServices
			}
			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: TreeBlockSlotRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TreeBlockSlotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotFrom", wireType)
			}
			m.SlotFrom = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlotFrom |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotTo", wireType)
			}
			m.SlotTo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowServices
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlotTo |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipServices(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthServices
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthServices
			}
			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 skipServices(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, ErrIntOverflowServices
			}
			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, ErrIntOverflowServices
				}
				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, ErrIntOverflowServices
				}
				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, ErrInvalidLengthServices
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthServices
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowServices
					}
					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 := skipServices(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthServices
				}
			}
			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 (
	ErrInvalidLengthServices = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowServices   = fmt.Errorf("proto: integer overflow")
)