validator.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: eth/v1alpha1/validator.proto

package eth

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	io "io"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type ValidatorStatus int32

const (
	ValidatorStatus_UNKNOWN_STATUS ValidatorStatus = 0
	ValidatorStatus_DEPOSITED      ValidatorStatus = 1
	ValidatorStatus_PENDING        ValidatorStatus = 2
	ValidatorStatus_ACTIVE         ValidatorStatus = 3
	ValidatorStatus_EXITING        ValidatorStatus = 4
	ValidatorStatus_SLASHING       ValidatorStatus = 5
	ValidatorStatus_EXITED         ValidatorStatus = 6
)

var ValidatorStatus_name = map[int32]string{
	0: "UNKNOWN_STATUS",
	1: "DEPOSITED",
	2: "PENDING",
	3: "ACTIVE",
	4: "EXITING",
	5: "SLASHING",
	6: "EXITED",
}

var ValidatorStatus_value = map[string]int32{
	"UNKNOWN_STATUS": 0,
	"DEPOSITED":      1,
	"PENDING":        2,
	"ACTIVE":         3,
	"EXITING":        4,
	"SLASHING":       5,
	"EXITED":         6,
}

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

func (ValidatorStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f8ef4b6a7db76675, []int{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_f8ef4b6a7db76675, []int{0}
}
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      []byte   `protobuf:"bytes,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_f8ef4b6a7db76675, []int{1}
}
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() []byte {
	if m != nil {
		return m.SignatureDomain
	}
	return nil
}

type ValidatorActivationRequest struct {
	PublicKeys           [][]byte `protobuf:"bytes,1,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty" ssz-size:"?,48"`
	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_f8ef4b6a7db76675, []int{2}
}
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 {
	Statuses             []*ValidatorActivationResponse_Status `protobuf:"bytes,1,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_f8ef4b6a7db76675, []int{3}
}
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

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_f8ef4b6a7db76675, []int{3, 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
}

// Deprecated: Do not use.
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_f8ef4b6a7db76675, []int{4}
}
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 SyncedResponse struct {
	Synced               bool     `protobuf:"varint,1,opt,name=synced,proto3" json:"synced,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 *SyncedResponse) Reset()         { *m = SyncedResponse{} }
func (m *SyncedResponse) String() string { return proto.CompactTextString(m) }
func (*SyncedResponse) ProtoMessage()    {}
func (*SyncedResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_f8ef4b6a7db76675, []int{5}
}
func (m *SyncedResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SyncedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SyncedResponse.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 *SyncedResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncedResponse.Merge(m, src)
}
func (m *SyncedResponse) XXX_Size() int {
	return m.Size()
}
func (m *SyncedResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncedResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SyncedResponse proto.InternalMessageInfo

func (m *SyncedResponse) GetSynced() bool {
	if m != nil {
		return m.Synced
	}
	return false
}

func (m *SyncedResponse) 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" ssz-size:"48"`
	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_f8ef4b6a7db76675, []int{6}
}
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_f8ef4b6a7db76675, []int{7}
}
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 ValidatorStatusRequest struct {
	PublicKey            []byte   `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" ssz-size:"48"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ValidatorStatusRequest proto.InternalMessageInfo

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

type ValidatorStatusResponse struct {
	Status                    ValidatorStatus `protobuf:"varint,1,opt,name=status,proto3,enum=ethereum.eth.v1alpha1.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_f8ef4b6a7db76675, []int{9}
}
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 DutiesRequest struct {
	Epoch                uint64   `protobuf:"varint,1,opt,name=epoch,proto3" json:"epoch,omitempty"`
	PublicKeys           [][]byte `protobuf:"bytes,2,rep,name=public_keys,json=publicKeys,proto3" json:"public_keys,omitempty" ssz-size:"?,48"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DutiesRequest proto.InternalMessageInfo

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

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

type DutiesResponse struct {
	Duties               []*DutiesResponse_Duty `protobuf:"bytes,1,rep,name=duties,proto3" json:"duties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_DutiesResponse proto.InternalMessageInfo

func (m *DutiesResponse) GetDuties() []*DutiesResponse_Duty {
	if m != nil {
		return m.Duties
	}
	return nil
}

type DutiesResponse_Duty struct {
	Committee            []uint64        `protobuf:"varint,1,rep,packed,name=committee,proto3" json:"committee,omitempty"`
	CommitteeIndex       uint64          `protobuf:"varint,2,opt,name=committee_index,json=committeeIndex,proto3" json:"committee_index,omitempty"`
	AttesterSlot         uint64          `protobuf:"varint,3,opt,name=attester_slot,json=attesterSlot,proto3" json:"attester_slot,omitempty"`
	ProposerSlots        []uint64        `protobuf:"varint,4,rep,packed,name=proposer_slots,json=proposerSlots,proto3" json:"proposer_slots,omitempty"`
	PublicKey            []byte          `protobuf:"bytes,5,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" ssz-size:"48"`
	Status               ValidatorStatus `protobuf:"varint,6,opt,name=status,proto3,enum=ethereum.eth.v1alpha1.ValidatorStatus" json:"status,omitempty"`
	ValidatorIndex       uint64          `protobuf:"varint,7,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_DutiesResponse_Duty proto.InternalMessageInfo

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

func (m *DutiesResponse_Duty) GetCommitteeIndex() uint64 {
	if m != nil {
		return m.CommitteeIndex
	}
	return 0
}

func (m *DutiesResponse_Duty) GetAttesterSlot() uint64 {
	if m != nil {
		return m.AttesterSlot
	}
	return 0
}

func (m *DutiesResponse_Duty) GetProposerSlots() []uint64 {
	if m != nil {
		return m.ProposerSlots
	}
	return nil
}

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

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

func (m *DutiesResponse_Duty) GetValidatorIndex() uint64 {
	if m != nil {
		return m.ValidatorIndex
	}
	return 0
}

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" ssz-size:"48"`
	Graffiti             []byte   `protobuf:"bytes,3,opt,name=graffiti,proto3" json:"graffiti,omitempty" ssz-size:"32"`
	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_f8ef4b6a7db76675, []int{12}
}
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
}

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

type ProposeResponse struct {
	BlockRoot            []byte   `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"`
	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_f8ef4b6a7db76675, []int{13}
}
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 AttestationDataRequest struct {
	Slot                 uint64   `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	CommitteeIndex       uint64   `protobuf:"varint,2,opt,name=committee_index,json=committeeIndex,proto3" json:"committee_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AttestationDataRequest proto.InternalMessageInfo

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

func (m *AttestationDataRequest) GetCommitteeIndex() uint64 {
	if m != nil {
		return m.CommitteeIndex
	}
	return 0
}

type AttestResponse struct {
	AttestationDataRoot  []byte   `protobuf:"bytes,1,opt,name=attestation_data_root,json=attestationDataRoot,proto3" json:"attestation_data_root,omitempty" ssz-size:"32"`
	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_f8ef4b6a7db76675, []int{15}
}
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) GetAttestationDataRoot() []byte {
	if m != nil {
		return m.AttestationDataRoot
	}
	return nil
}

type AggregateSelectionRequest struct {
	Slot                 uint64   `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
	CommitteeIndex       uint64   `protobuf:"varint,2,opt,name=committee_index,json=committeeIndex,proto3" json:"committee_index,omitempty"`
	PublicKey            []byte   `protobuf:"bytes,3,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" ssz-size:"48" spec-name:"pubkey"`
	SlotSignature        []byte   `protobuf:"bytes,4,opt,name=slot_signature,json=slotSignature,proto3" json:"slot_signature,omitempty" ssz-size:"96"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AggregateSelectionRequest proto.InternalMessageInfo

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

func (m *AggregateSelectionRequest) GetCommitteeIndex() uint64 {
	if m != nil {
		return m.CommitteeIndex
	}
	return 0
}

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

func (m *AggregateSelectionRequest) GetSlotSignature() []byte {
	if m != nil {
		return m.SlotSignature
	}
	return nil
}

type AggregateSelectionResponse struct {
	AggregateAndProof    *AggregateAttestationAndProof `protobuf:"bytes,1,opt,name=aggregate_and_proof,json=aggregateAndProof,proto3" json:"aggregate_and_proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

var xxx_messageInfo_AggregateSelectionResponse proto.InternalMessageInfo

func (m *AggregateSelectionResponse) GetAggregateAndProof() *AggregateAttestationAndProof {
	if m != nil {
		return m.AggregateAndProof
	}
	return nil
}

type SignedAggregateSubmitRequest struct {
	SignedAggregateAndProof *SignedAggregateAttestationAndProof `protobuf:"bytes,1,opt,name=signed_aggregate_and_proof,json=signedAggregateAndProof,proto3" json:"signed_aggregate_and_proof,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                            `json:"-"`
	XXX_unrecognized        []byte                              `json:"-"`
	XXX_sizecache           int32                               `json:"-"`
}

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

var xxx_messageInfo_SignedAggregateSubmitRequest proto.InternalMessageInfo

func (m *SignedAggregateSubmitRequest) GetSignedAggregateAndProof() *SignedAggregateAttestationAndProof {
	if m != nil {
		return m.SignedAggregateAndProof
	}
	return nil
}

type SignedAggregateSubmitResponse struct {
	AttestationDataRoot  []byte   `protobuf:"bytes,1,opt,name=attestation_data_root,json=attestationDataRoot,proto3" json:"attestation_data_root,omitempty" ssz-size:"32"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SignedAggregateSubmitResponse proto.InternalMessageInfo

func (m *SignedAggregateSubmitResponse) GetAttestationDataRoot() []byte {
	if m != nil {
		return m.AttestationDataRoot
	}
	return nil
}

type CommitteeSubnetsSubscribeRequest struct {
	Slots                []uint64 `protobuf:"varint,1,rep,packed,name=slots,proto3" json:"slots,omitempty"`
	CommitteeIds         []uint64 `protobuf:"varint,2,rep,packed,name=committee_ids,json=committeeIds,proto3" json:"committee_ids,omitempty"`
	IsAggregator         []bool   `protobuf:"varint,3,rep,packed,name=is_aggregator,json=isAggregator,proto3" json:"is_aggregator,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CommitteeSubnetsSubscribeRequest proto.InternalMessageInfo

func (m *CommitteeSubnetsSubscribeRequest) GetSlots() []uint64 {
	if m != nil {
		return m.Slots
	}
	return nil
}

func (m *CommitteeSubnetsSubscribeRequest) GetCommitteeIds() []uint64 {
	if m != nil {
		return m.CommitteeIds
	}
	return nil
}

func (m *CommitteeSubnetsSubscribeRequest) GetIsAggregator() []bool {
	if m != nil {
		return m.IsAggregator
	}
	return nil
}

type Validator struct {
	PublicKey                  []byte   `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty" ssz-size:"48" spec-name:"pubkey"`
	WithdrawalCredentials      []byte   `protobuf:"bytes,2,opt,name=withdrawal_credentials,json=withdrawalCredentials,proto3" json:"withdrawal_credentials,omitempty" ssz-size:"32"`
	EffectiveBalance           uint64   `protobuf:"varint,3,opt,name=effective_balance,json=effectiveBalance,proto3" json:"effective_balance,omitempty"`
	Slashed                    bool     `protobuf:"varint,4,opt,name=slashed,proto3" json:"slashed,omitempty"`
	ActivationEligibilityEpoch uint64   `protobuf:"varint,5,opt,name=activation_eligibility_epoch,json=activationEligibilityEpoch,proto3" json:"activation_eligibility_epoch,omitempty"`
	ActivationEpoch            uint64   `protobuf:"varint,6,opt,name=activation_epoch,json=activationEpoch,proto3" json:"activation_epoch,omitempty"`
	ExitEpoch                  uint64   `protobuf:"varint,7,opt,name=exit_epoch,json=exitEpoch,proto3" json:"exit_epoch,omitempty"`
	WithdrawableEpoch          uint64   `protobuf:"varint,8,opt,name=withdrawable_epoch,json=withdrawableEpoch,proto3" json:"withdrawable_epoch,omitempty"`
	XXX_NoUnkeyedLiteral       struct{} `json:"-"`
	XXX_unrecognized           []byte   `json:"-"`
	XXX_sizecache              int32    `json:"-"`
}

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

var xxx_messageInfo_Validator proto.InternalMessageInfo

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

func (m *Validator) GetWithdrawalCredentials() []byte {
	if m != nil {
		return m.WithdrawalCredentials
	}
	return nil
}

func (m *Validator) GetEffectiveBalance() uint64 {
	if m != nil {
		return m.EffectiveBalance
	}
	return 0
}

func (m *Validator) GetSlashed() bool {
	if m != nil {
		return m.Slashed
	}
	return false
}

func (m *Validator) GetActivationEligibilityEpoch() uint64 {
	if m != nil {
		return m.ActivationEligibilityEpoch
	}
	return 0
}

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

func (m *Validator) GetExitEpoch() uint64 {
	if m != nil {
		return m.ExitEpoch
	}
	return 0
}

func (m *Validator) GetWithdrawableEpoch() uint64 {
	if m != nil {
		return m.WithdrawableEpoch
	}
	return 0
}

type ValidatorParticipation struct {
	GlobalParticipationRate float32  `protobuf:"fixed32,1,opt,name=global_participation_rate,json=globalParticipationRate,proto3" json:"global_participation_rate,omitempty"`
	VotedEther              uint64   `protobuf:"varint,2,opt,name=voted_ether,json=votedEther,proto3" json:"voted_ether,omitempty"`
	EligibleEther           uint64   `protobuf:"varint,3,opt,name=eligible_ether,json=eligibleEther,proto3" json:"eligible_ether,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_unrecognized        []byte   `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

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

var xxx_messageInfo_ValidatorParticipation proto.InternalMessageInfo

func (m *ValidatorParticipation) GetGlobalParticipationRate() float32 {
	if m != nil {
		return m.GlobalParticipationRate
	}
	return 0
}

func (m *ValidatorParticipation) GetVotedEther() uint64 {
	if m != nil {
		return m.VotedEther
	}
	return 0
}

func (m *ValidatorParticipation) GetEligibleEther() uint64 {
	if m != nil {
		return m.EligibleEther
	}
	return 0
}

type ValidatorInfo struct {
	PublicKey            []byte          `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	Index                uint64          `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Epoch                uint64          `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Status               ValidatorStatus `protobuf:"varint,4,opt,name=status,proto3,enum=ethereum.eth.v1alpha1.ValidatorStatus" json:"status,omitempty"`
	TransitionTimestamp  uint64          `protobuf:"varint,5,opt,name=transition_timestamp,json=transitionTimestamp,proto3" json:"transition_timestamp,omitempty"`
	Balance              uint64          `protobuf:"varint,6,opt,name=balance,proto3" json:"balance,omitempty"`
	EffectiveBalance     uint64          `protobuf:"varint,7,opt,name=effective_balance,json=effectiveBalance,proto3" json:"effective_balance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_ValidatorInfo proto.InternalMessageInfo

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

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

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

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

func (m *ValidatorInfo) GetTransitionTimestamp() uint64 {
	if m != nil {
		return m.TransitionTimestamp
	}
	return 0
}

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

func (m *ValidatorInfo) GetEffectiveBalance() uint64 {
	if m != nil {
		return m.EffectiveBalance
	}
	return 0
}

func init() {
	proto.RegisterEnum("ethereum.eth.v1alpha1.ValidatorStatus", ValidatorStatus_name, ValidatorStatus_value)
	proto.RegisterType((*DomainRequest)(nil), "ethereum.eth.v1alpha1.DomainRequest")
	proto.RegisterType((*DomainResponse)(nil), "ethereum.eth.v1alpha1.DomainResponse")
	proto.RegisterType((*ValidatorActivationRequest)(nil), "ethereum.eth.v1alpha1.ValidatorActivationRequest")
	proto.RegisterType((*ValidatorActivationResponse)(nil), "ethereum.eth.v1alpha1.ValidatorActivationResponse")
	proto.RegisterType((*ValidatorActivationResponse_Status)(nil), "ethereum.eth.v1alpha1.ValidatorActivationResponse.Status")
	proto.RegisterType((*ChainStartResponse)(nil), "ethereum.eth.v1alpha1.ChainStartResponse")
	proto.RegisterType((*SyncedResponse)(nil), "ethereum.eth.v1alpha1.SyncedResponse")
	proto.RegisterType((*ValidatorIndexRequest)(nil), "ethereum.eth.v1alpha1.ValidatorIndexRequest")
	proto.RegisterType((*ValidatorIndexResponse)(nil), "ethereum.eth.v1alpha1.ValidatorIndexResponse")
	proto.RegisterType((*ValidatorStatusRequest)(nil), "ethereum.eth.v1alpha1.ValidatorStatusRequest")
	proto.RegisterType((*ValidatorStatusResponse)(nil), "ethereum.eth.v1alpha1.ValidatorStatusResponse")
	proto.RegisterType((*DutiesRequest)(nil), "ethereum.eth.v1alpha1.DutiesRequest")
	proto.RegisterType((*DutiesResponse)(nil), "ethereum.eth.v1alpha1.DutiesResponse")
	proto.RegisterType((*DutiesResponse_Duty)(nil), "ethereum.eth.v1alpha1.DutiesResponse.Duty")
	proto.RegisterType((*BlockRequest)(nil), "ethereum.eth.v1alpha1.BlockRequest")
	proto.RegisterType((*ProposeResponse)(nil), "ethereum.eth.v1alpha1.ProposeResponse")
	proto.RegisterType((*AttestationDataRequest)(nil), "ethereum.eth.v1alpha1.AttestationDataRequest")
	proto.RegisterType((*AttestResponse)(nil), "ethereum.eth.v1alpha1.AttestResponse")
	proto.RegisterType((*AggregateSelectionRequest)(nil), "ethereum.eth.v1alpha1.AggregateSelectionRequest")
	proto.RegisterType((*AggregateSelectionResponse)(nil), "ethereum.eth.v1alpha1.AggregateSelectionResponse")
	proto.RegisterType((*SignedAggregateSubmitRequest)(nil), "ethereum.eth.v1alpha1.SignedAggregateSubmitRequest")
	proto.RegisterType((*SignedAggregateSubmitResponse)(nil), "ethereum.eth.v1alpha1.SignedAggregateSubmitResponse")
	proto.RegisterType((*CommitteeSubnetsSubscribeRequest)(nil), "ethereum.eth.v1alpha1.CommitteeSubnetsSubscribeRequest")
	proto.RegisterType((*Validator)(nil), "ethereum.eth.v1alpha1.Validator")
	proto.RegisterType((*ValidatorParticipation)(nil), "ethereum.eth.v1alpha1.ValidatorParticipation")
	proto.RegisterType((*ValidatorInfo)(nil), "ethereum.eth.v1alpha1.ValidatorInfo")
}

func init() { proto.RegisterFile("eth/v1alpha1/validator.proto", fileDescriptor_f8ef4b6a7db76675) }

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

// BeaconNodeValidatorClient is the client API for BeaconNodeValidator service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BeaconNodeValidatorClient interface {
	GetDuties(ctx context.Context, in *DutiesRequest, opts ...grpc.CallOption) (*DutiesResponse, error)
	StreamDuties(ctx context.Context, opts ...grpc.CallOption) (BeaconNodeValidator_StreamDutiesClient, error)
	DomainData(ctx context.Context, in *DomainRequest, opts ...grpc.CallOption) (*DomainResponse, error)
	WaitForChainStart(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForChainStartClient, error)
	WaitForSynced(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForSyncedClient, error)
	WaitForActivation(ctx context.Context, in *ValidatorActivationRequest, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForActivationClient, error)
	ValidatorIndex(ctx context.Context, in *ValidatorIndexRequest, opts ...grpc.CallOption) (*ValidatorIndexResponse, error)
	ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error)
	GetBlock(ctx context.Context, in *BlockRequest, opts ...grpc.CallOption) (*BeaconBlock, error)
	ProposeBlock(ctx context.Context, in *SignedBeaconBlock, opts ...grpc.CallOption) (*ProposeResponse, error)
	GetAttestationData(ctx context.Context, in *AttestationDataRequest, opts ...grpc.CallOption) (*AttestationData, error)
	ProposeAttestation(ctx context.Context, in *Attestation, opts ...grpc.CallOption) (*AttestResponse, error)
	SubmitAggregateSelectionProof(ctx context.Context, in *AggregateSelectionRequest, opts ...grpc.CallOption) (*AggregateSelectionResponse, error)
	SubmitSignedAggregateSelectionProof(ctx context.Context, in *SignedAggregateSubmitRequest, opts ...grpc.CallOption) (*SignedAggregateSubmitResponse, error)
	ProposeExit(ctx context.Context, in *SignedVoluntaryExit, opts ...grpc.CallOption) (*types.Empty, error)
	SubscribeCommitteeSubnets(ctx context.Context, in *CommitteeSubnetsSubscribeRequest, opts ...grpc.CallOption) (*types.Empty, error)
}

type beaconNodeValidatorClient struct {
	cc *grpc.ClientConn
}

func NewBeaconNodeValidatorClient(cc *grpc.ClientConn) BeaconNodeValidatorClient {
	return &beaconNodeValidatorClient{cc}
}

func (c *beaconNodeValidatorClient) GetDuties(ctx context.Context, in *DutiesRequest, opts ...grpc.CallOption) (*DutiesResponse, error) {
	out := new(DutiesResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetDuties", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) StreamDuties(ctx context.Context, opts ...grpc.CallOption) (BeaconNodeValidator_StreamDutiesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconNodeValidator_serviceDesc.Streams[0], "/ethereum.eth.v1alpha1.BeaconNodeValidator/StreamDuties", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconNodeValidatorStreamDutiesClient{stream}
	return x, nil
}

type BeaconNodeValidator_StreamDutiesClient interface {
	Send(*DutiesRequest) error
	Recv() (*DutiesResponse, error)
	grpc.ClientStream
}

type beaconNodeValidatorStreamDutiesClient struct {
	grpc.ClientStream
}

func (x *beaconNodeValidatorStreamDutiesClient) Send(m *DutiesRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *beaconNodeValidatorClient) DomainData(ctx context.Context, in *DomainRequest, opts ...grpc.CallOption) (*DomainResponse, error) {
	out := new(DomainResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/DomainData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *beaconNodeValidatorClient) WaitForChainStart(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForChainStartClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconNodeValidator_serviceDesc.Streams[1], "/ethereum.eth.v1alpha1.BeaconNodeValidator/WaitForChainStart", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconNodeValidatorWaitForChainStartClient{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 BeaconNodeValidator_WaitForChainStartClient interface {
	Recv() (*ChainStartResponse, error)
	grpc.ClientStream
}

type beaconNodeValidatorWaitForChainStartClient struct {
	grpc.ClientStream
}

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

func (c *beaconNodeValidatorClient) WaitForSynced(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForSyncedClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconNodeValidator_serviceDesc.Streams[2], "/ethereum.eth.v1alpha1.BeaconNodeValidator/WaitForSynced", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconNodeValidatorWaitForSyncedClient{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 BeaconNodeValidator_WaitForSyncedClient interface {
	Recv() (*SyncedResponse, error)
	grpc.ClientStream
}

type beaconNodeValidatorWaitForSyncedClient struct {
	grpc.ClientStream
}

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

func (c *beaconNodeValidatorClient) WaitForActivation(ctx context.Context, in *ValidatorActivationRequest, opts ...grpc.CallOption) (BeaconNodeValidator_WaitForActivationClient, error) {
	stream, err := c.cc.NewStream(ctx, &_BeaconNodeValidator_serviceDesc.Streams[3], "/ethereum.eth.v1alpha1.BeaconNodeValidator/WaitForActivation", opts...)
	if err != nil {
		return nil, err
	}
	x := &beaconNodeValidatorWaitForActivationClient{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 BeaconNodeValidator_WaitForActivationClient interface {
	Recv() (*ValidatorActivationResponse, error)
	grpc.ClientStream
}

type beaconNodeValidatorWaitForActivationClient struct {
	grpc.ClientStream
}

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

func (c *beaconNodeValidatorClient) ValidatorIndex(ctx context.Context, in *ValidatorIndexRequest, opts ...grpc.CallOption) (*ValidatorIndexResponse, error) {
	out := new(ValidatorIndexResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/ValidatorIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) {
	out := new(ValidatorStatusResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/ValidatorStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) GetBlock(ctx context.Context, in *BlockRequest, opts ...grpc.CallOption) (*BeaconBlock, error) {
	out := new(BeaconBlock)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) ProposeBlock(ctx context.Context, in *SignedBeaconBlock, opts ...grpc.CallOption) (*ProposeResponse, error) {
	out := new(ProposeResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) GetAttestationData(ctx context.Context, in *AttestationDataRequest, opts ...grpc.CallOption) (*AttestationData, error) {
	out := new(AttestationData)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetAttestationData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) ProposeAttestation(ctx context.Context, in *Attestation, opts ...grpc.CallOption) (*AttestResponse, error) {
	out := new(AttestResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeAttestation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) SubmitAggregateSelectionProof(ctx context.Context, in *AggregateSelectionRequest, opts ...grpc.CallOption) (*AggregateSelectionResponse, error) {
	out := new(AggregateSelectionResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubmitAggregateSelectionProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) SubmitSignedAggregateSelectionProof(ctx context.Context, in *SignedAggregateSubmitRequest, opts ...grpc.CallOption) (*SignedAggregateSubmitResponse, error) {
	out := new(SignedAggregateSubmitResponse)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubmitSignedAggregateSelectionProof", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) ProposeExit(ctx context.Context, in *SignedVoluntaryExit, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeExit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *beaconNodeValidatorClient) SubscribeCommitteeSubnets(ctx context.Context, in *CommitteeSubnetsSubscribeRequest, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubscribeCommitteeSubnets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BeaconNodeValidatorServer is the server API for BeaconNodeValidator service.
type BeaconNodeValidatorServer interface {
	GetDuties(context.Context, *DutiesRequest) (*DutiesResponse, error)
	StreamDuties(BeaconNodeValidator_StreamDutiesServer) error
	DomainData(context.Context, *DomainRequest) (*DomainResponse, error)
	WaitForChainStart(*types.Empty, BeaconNodeValidator_WaitForChainStartServer) error
	WaitForSynced(*types.Empty, BeaconNodeValidator_WaitForSyncedServer) error
	WaitForActivation(*ValidatorActivationRequest, BeaconNodeValidator_WaitForActivationServer) error
	ValidatorIndex(context.Context, *ValidatorIndexRequest) (*ValidatorIndexResponse, error)
	ValidatorStatus(context.Context, *ValidatorStatusRequest) (*ValidatorStatusResponse, error)
	GetBlock(context.Context, *BlockRequest) (*BeaconBlock, error)
	ProposeBlock(context.Context, *SignedBeaconBlock) (*ProposeResponse, error)
	GetAttestationData(context.Context, *AttestationDataRequest) (*AttestationData, error)
	ProposeAttestation(context.Context, *Attestation) (*AttestResponse, error)
	SubmitAggregateSelectionProof(context.Context, *AggregateSelectionRequest) (*AggregateSelectionResponse, error)
	SubmitSignedAggregateSelectionProof(context.Context, *SignedAggregateSubmitRequest) (*SignedAggregateSubmitResponse, error)
	ProposeExit(context.Context, *SignedVoluntaryExit) (*types.Empty, error)
	SubscribeCommitteeSubnets(context.Context, *CommitteeSubnetsSubscribeRequest) (*types.Empty, error)
}

func RegisterBeaconNodeValidatorServer(s *grpc.Server, srv BeaconNodeValidatorServer) {
	s.RegisterService(&_BeaconNodeValidator_serviceDesc, srv)
}

func _BeaconNodeValidator_GetDuties_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DutiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).GetDuties(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetDuties",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).GetDuties(ctx, req.(*DutiesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_StreamDuties_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(BeaconNodeValidatorServer).StreamDuties(&beaconNodeValidatorStreamDutiesServer{stream})
}

type BeaconNodeValidator_StreamDutiesServer interface {
	Send(*DutiesResponse) error
	Recv() (*DutiesRequest, error)
	grpc.ServerStream
}

type beaconNodeValidatorStreamDutiesServer struct {
	grpc.ServerStream
}

func (x *beaconNodeValidatorStreamDutiesServer) Send(m *DutiesResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *beaconNodeValidatorStreamDutiesServer) Recv() (*DutiesRequest, error) {
	m := new(DutiesRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _BeaconNodeValidator_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.(BeaconNodeValidatorServer).DomainData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/DomainData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).DomainData(ctx, req.(*DomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

type beaconNodeValidatorWaitForChainStartServer struct {
	grpc.ServerStream
}

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

func _BeaconNodeValidator_WaitForSynced_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(types.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(BeaconNodeValidatorServer).WaitForSynced(m, &beaconNodeValidatorWaitForSyncedServer{stream})
}

type BeaconNodeValidator_WaitForSyncedServer interface {
	Send(*SyncedResponse) error
	grpc.ServerStream
}

type beaconNodeValidatorWaitForSyncedServer struct {
	grpc.ServerStream
}

func (x *beaconNodeValidatorWaitForSyncedServer) Send(m *SyncedResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

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

type beaconNodeValidatorWaitForActivationServer struct {
	grpc.ServerStream
}

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

func _BeaconNodeValidator_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.(BeaconNodeValidatorServer).ValidatorIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/ValidatorIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).ValidatorIndex(ctx, req.(*ValidatorIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_ValidatorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidatorStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).ValidatorStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/ValidatorStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).ValidatorStatus(ctx, req.(*ValidatorStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_GetBlock_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.(BeaconNodeValidatorServer).GetBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).GetBlock(ctx, req.(*BlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_ProposeBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedBeaconBlock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).ProposeBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).ProposeBlock(ctx, req.(*SignedBeaconBlock))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_GetAttestationData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AttestationDataRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).GetAttestationData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/GetAttestationData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).GetAttestationData(ctx, req.(*AttestationDataRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_ProposeAttestation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Attestation)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).ProposeAttestation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeAttestation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).ProposeAttestation(ctx, req.(*Attestation))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_SubmitAggregateSelectionProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AggregateSelectionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).SubmitAggregateSelectionProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubmitAggregateSelectionProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).SubmitAggregateSelectionProof(ctx, req.(*AggregateSelectionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_SubmitSignedAggregateSelectionProof_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedAggregateSubmitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).SubmitSignedAggregateSelectionProof(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubmitSignedAggregateSelectionProof",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).SubmitSignedAggregateSelectionProof(ctx, req.(*SignedAggregateSubmitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_ProposeExit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedVoluntaryExit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).ProposeExit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/ProposeExit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).ProposeExit(ctx, req.(*SignedVoluntaryExit))
	}
	return interceptor(ctx, in, info, handler)
}

func _BeaconNodeValidator_SubscribeCommitteeSubnets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommitteeSubnetsSubscribeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BeaconNodeValidatorServer).SubscribeCommitteeSubnets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ethereum.eth.v1alpha1.BeaconNodeValidator/SubscribeCommitteeSubnets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BeaconNodeValidatorServer).SubscribeCommitteeSubnets(ctx, req.(*CommitteeSubnetsSubscribeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _BeaconNodeValidator_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ethereum.eth.v1alpha1.BeaconNodeValidator",
	HandlerType: (*BeaconNodeValidatorServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetDuties",
			Handler:    _BeaconNodeValidator_GetDuties_Handler,
		},
		{
			MethodName: "DomainData",
			Handler:    _BeaconNodeValidator_DomainData_Handler,
		},
		{
			MethodName: "ValidatorIndex",
			Handler:    _BeaconNodeValidator_ValidatorIndex_Handler,
		},
		{
			MethodName: "ValidatorStatus",
			Handler:    _BeaconNodeValidator_ValidatorStatus_Handler,
		},
		{
			MethodName: "GetBlock",
			Handler:    _BeaconNodeValidator_GetBlock_Handler,
		},
		{
			MethodName: "ProposeBlock",
			Handler:    _BeaconNodeValidator_ProposeBlock_Handler,
		},
		{
			MethodName: "GetAttestationData",
			Handler:    _BeaconNodeValidator_GetAttestationData_Handler,
		},
		{
			MethodName: "ProposeAttestation",
			Handler:    _BeaconNodeValidator_ProposeAttestation_Handler,
		},
		{
			MethodName: "SubmitAggregateSelectionProof",
			Handler:    _BeaconNodeValidator_SubmitAggregateSelectionProof_Handler,
		},
		{
			MethodName: "SubmitSignedAggregateSelectionProof",
			Handler:    _BeaconNodeValidator_SubmitSignedAggregateSelectionProof_Handler,
		},
		{
			MethodName: "ProposeExit",
			Handler:    _BeaconNodeValidator_ProposeExit_Handler,
		},
		{
			MethodName: "SubscribeCommitteeSubnets",
			Handler:    _BeaconNodeValidator_SubscribeCommitteeSubnets_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamDuties",
			Handler:       _BeaconNodeValidator_StreamDuties_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "WaitForChainStart",
			Handler:       _BeaconNodeValidator_WaitForChainStart_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WaitForSynced",
			Handler:       _BeaconNodeValidator_WaitForSynced_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WaitForActivation",
			Handler:       _BeaconNodeValidator_WaitForActivation_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "eth/v1alpha1/validator.proto",
}

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 = encodeVarintValidator(dAtA, i, uint64(m.Epoch))
	}
	if len(m.Domain) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintValidator(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 len(m.SignatureDomain) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.SignatureDomain)))
		i += copy(dAtA[i:], m.SignatureDomain)
	}
	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 = encodeVarintValidator(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.Statuses) > 0 {
		for _, msg := range m.Statuses {
			dAtA[i] = 0xa
			i++
			i = encodeVarintValidator(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 = encodeVarintValidator(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintValidator(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 *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 = encodeVarintValidator(dAtA, i, uint64(m.GenesisTime))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

func (m *DutiesRequest) 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 *DutiesRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Epoch != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Epoch))
	}
	if len(m.PublicKeys) > 0 {
		for _, b := range m.PublicKeys {
			dAtA[i] = 0x12
			i++
			i = encodeVarintValidator(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 *DutiesResponse) 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 *DutiesResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Duties) > 0 {
		for _, msg := range m.Duties {
			dAtA[i] = 0xa
			i++
			i = encodeVarintValidator(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 *DutiesResponse_Duty) 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 *DutiesResponse_Duty) 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 = encodeVarintValidator(dAtA, i, uint64(j2))
		i += copy(dAtA[i:], dAtA3[:j2])
	}
	if m.CommitteeIndex != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.CommitteeIndex))
	}
	if m.AttesterSlot != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.AttesterSlot))
	}
	if len(m.ProposerSlots) > 0 {
		dAtA5 := make([]byte, len(m.ProposerSlots)*10)
		var j4 int
		for _, num := range m.ProposerSlots {
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		dAtA[i] = 0x22
		i++
		i = encodeVarintValidator(dAtA, i, uint64(j4))
		i += copy(dAtA[i:], dAtA5[:j4])
	}
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.Status != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Status))
	}
	if m.ValidatorIndex != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.ValidatorIndex))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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 = encodeVarintValidator(dAtA, i, uint64(m.Slot))
	}
	if len(m.RandaoReveal) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.RandaoReveal)))
		i += copy(dAtA[i:], m.RandaoReveal)
	}
	if len(m.Graffiti) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.Graffiti)))
		i += copy(dAtA[i:], m.Graffiti)
	}
	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 = encodeVarintValidator(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 *AttestationDataRequest) 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 *AttestationDataRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Slot != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Slot))
	}
	if m.CommitteeIndex != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.CommitteeIndex))
	}
	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.AttestationDataRoot) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.AttestationDataRoot)))
		i += copy(dAtA[i:], m.AttestationDataRoot)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

func (m *CommitteeSubnetsSubscribeRequest) 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 *CommitteeSubnetsSubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Slots) > 0 {
		dAtA9 := make([]byte, len(m.Slots)*10)
		var j8 int
		for _, num := range m.Slots {
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintValidator(dAtA, i, uint64(j8))
		i += copy(dAtA[i:], dAtA9[:j8])
	}
	if len(m.CommitteeIds) > 0 {
		dAtA11 := make([]byte, len(m.CommitteeIds)*10)
		var j10 int
		for _, num := range m.CommitteeIds {
			for num >= 1<<7 {
				dAtA11[j10] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j10++
			}
			dAtA11[j10] = uint8(num)
			j10++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintValidator(dAtA, i, uint64(j10))
		i += copy(dAtA[i:], dAtA11[:j10])
	}
	if len(m.IsAggregator) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.IsAggregator)))
		for _, b := range m.IsAggregator {
			if b {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Validator) 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 *Validator) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if len(m.WithdrawalCredentials) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.WithdrawalCredentials)))
		i += copy(dAtA[i:], m.WithdrawalCredentials)
	}
	if m.EffectiveBalance != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.EffectiveBalance))
	}
	if m.Slashed {
		dAtA[i] = 0x20
		i++
		if m.Slashed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.ActivationEligibilityEpoch != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.ActivationEligibilityEpoch))
	}
	if m.ActivationEpoch != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.ActivationEpoch))
	}
	if m.ExitEpoch != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.ExitEpoch))
	}
	if m.WithdrawableEpoch != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.WithdrawableEpoch))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorParticipation) 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 *ValidatorParticipation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GlobalParticipationRate != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.GlobalParticipationRate))))
		i += 4
	}
	if m.VotedEther != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.VotedEther))
	}
	if m.EligibleEther != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.EligibleEther))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ValidatorInfo) 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 *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintValidator(dAtA, i, uint64(len(m.PublicKey)))
		i += copy(dAtA[i:], m.PublicKey)
	}
	if m.Index != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Index))
	}
	if m.Epoch != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Epoch))
	}
	if m.Status != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Status))
	}
	if m.TransitionTimestamp != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.TransitionTimestamp))
	}
	if m.Balance != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.Balance))
	}
	if m.EffectiveBalance != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintValidator(dAtA, i, uint64(m.EffectiveBalance))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintValidator(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 *DomainRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Epoch != 0 {
		n += 1 + sovValidator(uint64(m.Epoch))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovValidator(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
	l = len(m.SignatureDomain)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	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 + sovValidator(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.Statuses) > 0 {
		for _, e := range m.Statuses {
			l = e.Size()
			n += 1 + l + sovValidator(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 + sovValidator(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovValidator(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 + sovValidator(uint64(m.GenesisTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SyncedResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Synced {
		n += 2
	}
	if m.GenesisTime != 0 {
		n += 1 + sovValidator(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 + sovValidator(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 + sovValidator(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	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 + sovValidator(uint64(m.Status))
	}
	if m.Eth1DepositBlockNumber != 0 {
		n += 1 + sovValidator(uint64(m.Eth1DepositBlockNumber))
	}
	if m.DepositInclusionSlot != 0 {
		n += 1 + sovValidator(uint64(m.DepositInclusionSlot))
	}
	if m.ActivationEpoch != 0 {
		n += 1 + sovValidator(uint64(m.ActivationEpoch))
	}
	if m.PositionInActivationQueue != 0 {
		n += 1 + sovValidator(uint64(m.PositionInActivationQueue))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *DutiesResponse_Duty) 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 += sovValidator(uint64(e))
		}
		n += 1 + sovValidator(uint64(l)) + l
	}
	if m.CommitteeIndex != 0 {
		n += 1 + sovValidator(uint64(m.CommitteeIndex))
	}
	if m.AttesterSlot != 0 {
		n += 1 + sovValidator(uint64(m.AttesterSlot))
	}
	if len(m.ProposerSlots) > 0 {
		l = 0
		for _, e := range m.ProposerSlots {
			l += sovValidator(uint64(e))
		}
		n += 1 + sovValidator(uint64(l)) + l
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovValidator(uint64(m.Status))
	}
	if m.ValidatorIndex != 0 {
		n += 1 + sovValidator(uint64(m.ValidatorIndex))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

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

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

func (m *CommitteeSubnetsSubscribeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Slots) > 0 {
		l = 0
		for _, e := range m.Slots {
			l += sovValidator(uint64(e))
		}
		n += 1 + sovValidator(uint64(l)) + l
	}
	if len(m.CommitteeIds) > 0 {
		l = 0
		for _, e := range m.CommitteeIds {
			l += sovValidator(uint64(e))
		}
		n += 1 + sovValidator(uint64(l)) + l
	}
	if len(m.IsAggregator) > 0 {
		n += 1 + sovValidator(uint64(len(m.IsAggregator))) + len(m.IsAggregator)*1
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Validator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	l = len(m.WithdrawalCredentials)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	if m.EffectiveBalance != 0 {
		n += 1 + sovValidator(uint64(m.EffectiveBalance))
	}
	if m.Slashed {
		n += 2
	}
	if m.ActivationEligibilityEpoch != 0 {
		n += 1 + sovValidator(uint64(m.ActivationEligibilityEpoch))
	}
	if m.ActivationEpoch != 0 {
		n += 1 + sovValidator(uint64(m.ActivationEpoch))
	}
	if m.ExitEpoch != 0 {
		n += 1 + sovValidator(uint64(m.ExitEpoch))
	}
	if m.WithdrawableEpoch != 0 {
		n += 1 + sovValidator(uint64(m.WithdrawableEpoch))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorParticipation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GlobalParticipationRate != 0 {
		n += 5
	}
	if m.VotedEther != 0 {
		n += 1 + sovValidator(uint64(m.VotedEther))
	}
	if m.EligibleEther != 0 {
		n += 1 + sovValidator(uint64(m.EligibleEther))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ValidatorInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovValidator(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovValidator(uint64(m.Index))
	}
	if m.Epoch != 0 {
		n += 1 + sovValidator(uint64(m.Epoch))
	}
	if m.Status != 0 {
		n += 1 + sovValidator(uint64(m.Status))
	}
	if m.TransitionTimestamp != 0 {
		n += 1 + sovValidator(uint64(m.TransitionTimestamp))
	}
	if m.Balance != 0 {
		n += 1 + sovValidator(uint64(m.Balance))
	}
	if m.EffectiveBalance != 0 {
		n += 1 + sovValidator(uint64(m.EffectiveBalance))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovValidator(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozValidator(x uint64) (n int) {
	return sovValidator(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignatureDomain", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SignatureDomain = append(m.SignatureDomain[:0], dAtA[iNdEx:postIndex]...)
			if m.SignatureDomain == nil {
				m.SignatureDomain = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 Statuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *SyncedResponse) 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 ErrIntOverflowValidator
			}
			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: SyncedResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SyncedResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Synced", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Synced = 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 ErrIntOverflowValidator
				}
				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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *ValidatorStatusRequest) 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 ErrIntOverflowValidator
			}
			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: ValidatorStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorStatusRequest: 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *DutiesRequest) 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 ErrIntOverflowValidator
			}
			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: DutiesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DutiesRequest: 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 ErrIntOverflowValidator
				}
				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 PublicKeys", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *DutiesResponse) 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 ErrIntOverflowValidator
			}
			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: DutiesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DutiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Duties = append(m.Duties, &DutiesResponse_Duty{})
			if err := m.Duties[len(m.Duties)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *DutiesResponse_Duty) 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 ErrIntOverflowValidator
			}
			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: Duty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Duty: 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 ErrIntOverflowValidator
					}
					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 ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthValidator
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthValidator
				}
				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 ErrIntOverflowValidator
						}
						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 CommitteeIndex", wireType)
			}
			m.CommitteeIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttesterSlot", wireType)
			}
			m.AttesterSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AttesterSlot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ProposerSlots = append(m.ProposerSlots, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthValidator
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthValidator
				}
				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.ProposerSlots) == 0 {
					m.ProposerSlots = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowValidator
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ProposerSlots = append(m.ProposerSlots, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposerSlots", wireType)
			}
		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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ValidatorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIndex", wireType)
			}
			m.ValidatorIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ValidatorIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RandaoReveal = append(m.RandaoReveal[:0], dAtA[iNdEx:postIndex]...)
			if m.RandaoReveal == nil {
				m.RandaoReveal = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Graffiti", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Graffiti = append(m.Graffiti[:0], dAtA[iNdEx:postIndex]...)
			if m.Graffiti == nil {
				m.Graffiti = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *AttestationDataRequest) 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 ErrIntOverflowValidator
			}
			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: AttestationDataRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttestationDataRequest: 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeIndex", wireType)
			}
			m.CommitteeIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 ErrIntOverflowValidator
			}
			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 AttestationDataRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AttestationDataRoot = append(m.AttestationDataRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.AttestationDataRoot == nil {
				m.AttestationDataRoot = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *AggregateSelectionRequest) 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 ErrIntOverflowValidator
			}
			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: AggregateSelectionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AggregateSelectionRequest: 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Slot |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeIndex", wireType)
			}
			m.CommitteeIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommitteeIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlotSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SlotSignature = append(m.SlotSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.SlotSignature == nil {
				m.SlotSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *AggregateSelectionResponse) 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 ErrIntOverflowValidator
			}
			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: AggregateSelectionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AggregateSelectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AggregateAndProof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AggregateAndProof == nil {
				m.AggregateAndProof = &AggregateAttestationAndProof{}
			}
			if err := m.AggregateAndProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *SignedAggregateSubmitRequest) 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 ErrIntOverflowValidator
			}
			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: SignedAggregateSubmitRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedAggregateSubmitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignedAggregateAndProof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SignedAggregateAndProof == nil {
				m.SignedAggregateAndProof = &SignedAggregateAttestationAndProof{}
			}
			if err := m.SignedAggregateAndProof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *SignedAggregateSubmitResponse) 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 ErrIntOverflowValidator
			}
			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: SignedAggregateSubmitResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedAggregateSubmitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttestationDataRoot", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AttestationDataRoot = append(m.AttestationDataRoot[:0], dAtA[iNdEx:postIndex]...)
			if m.AttestationDataRoot == nil {
				m.AttestationDataRoot = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *CommitteeSubnetsSubscribeRequest) 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 ErrIntOverflowValidator
			}
			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: CommitteeSubnetsSubscribeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommitteeSubnetsSubscribeRequest: 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 ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Slots = append(m.Slots, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthValidator
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthValidator
				}
				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.Slots) == 0 {
					m.Slots = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowValidator
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Slots = append(m.Slots, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Slots", wireType)
			}
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.CommitteeIds = append(m.CommitteeIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthValidator
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthValidator
				}
				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.CommitteeIds) == 0 {
					m.CommitteeIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowValidator
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.CommitteeIds = append(m.CommitteeIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitteeIds", wireType)
			}
		case 3:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.IsAggregator = append(m.IsAggregator, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowValidator
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthValidator
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthValidator
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.IsAggregator) == 0 {
					m.IsAggregator = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowValidator
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.IsAggregator = append(m.IsAggregator, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field IsAggregator", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *Validator) 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 ErrIntOverflowValidator
			}
			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: Validator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Validator: 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 WithdrawalCredentials", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WithdrawalCredentials = append(m.WithdrawalCredentials[:0], dAtA[iNdEx:postIndex]...)
			if m.WithdrawalCredentials == nil {
				m.WithdrawalCredentials = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveBalance", wireType)
			}
			m.EffectiveBalance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EffectiveBalance |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Slashed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Slashed = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivationEligibilityEpoch", wireType)
			}
			m.ActivationEligibilityEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActivationEligibilityEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActivationEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExitEpoch", wireType)
			}
			m.ExitEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExitEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawableEpoch", wireType)
			}
			m.WithdrawableEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WithdrawableEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *ValidatorParticipation) 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 ErrIntOverflowValidator
			}
			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: ValidatorParticipation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorParticipation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalParticipationRate", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.GlobalParticipationRate = float32(math.Float32frombits(v))
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotedEther", wireType)
			}
			m.VotedEther = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotedEther |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EligibleEther", wireType)
			}
			m.EligibleEther = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EligibleEther |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 *ValidatorInfo) 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 ErrIntOverflowValidator
			}
			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: ValidatorInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorInfo: 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthValidator
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthValidator
			}
			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 != 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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ValidatorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransitionTimestamp", wireType)
			}
			m.TransitionTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TransitionTimestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EffectiveBalance", wireType)
			}
			m.EffectiveBalance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowValidator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EffectiveBalance |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipValidator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthValidator
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthValidator
			}
			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 skipValidator(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, ErrIntOverflowValidator
			}
			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, ErrIntOverflowValidator
				}
				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, ErrIntOverflowValidator
				}
				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, ErrInvalidLengthValidator
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthValidator
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowValidator
					}
					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 := skipValidator(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthValidator
				}
			}
			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 (
	ErrInvalidLengthValidator = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowValidator   = fmt.Errorf("proto: integer overflow")
)