mirror/prysm-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/prysm-pulse.git synced 2025-01-20 08:31:11 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
prysm-pulse/proto/beacon/rpc/v1/services.pb.go
Preston Van Loon 10f45744d6
Use gogo protobuf as the protoc compiler (#1165) 
* first commit, remote att types

* no more agg attestation proto

* regen mock

* only attestations

* proto

* att process

* fix att references

* more tests passing

* use att protos

* complete

* change visibility

* use gogoprotobu
2018-12-23 15:34:59 -05:00

3288 lines
86 KiB
Go
Executable File
Raw Blame History

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: proto/beacon/rpc/v1/services.proto
package v1
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import types "github.com/gogo/protobuf/types"
import v1 "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"
import io "io"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type ValidatorRole int32
const (
ValidatorRole_UNKNOWN ValidatorRole = 0
ValidatorRole_ATTESTER ValidatorRole = 1
ValidatorRole_PROPOSER ValidatorRole = 2
)
var ValidatorRole_name = map[int32]string{
0: "UNKNOWN",
1: "ATTESTER",
2: "PROPOSER",
}
var ValidatorRole_value = map[string]int32{
"UNKNOWN": 0,
"ATTESTER": 1,
"PROPOSER": 2,
}
func (x ValidatorRole) String() string {
return proto.EnumName(ValidatorRole_name, int32(x))
}
func (ValidatorRole) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{0}
}
type ProposeRequest struct {
ParentHash []byte `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
SlotNumber uint64 `protobuf:"varint,2,opt,name=slot_number,json=slotNumber,proto3" json:"slot_number,omitempty"`
RandaoRevealHash32 []byte `protobuf:"bytes,3,opt,name=randao_reveal_hash32,json=randaoRevealHash32,proto3" json:"randao_reveal_hash32,omitempty"`
AttestationBitmask []byte `protobuf:"bytes,4,opt,name=attestation_bitmask,json=attestationBitmask,proto3" json:"attestation_bitmask,omitempty"`
AttestationAggregateSig []uint32 `protobuf:"varint,5,rep,packed,name=attestation_aggregate_sig,json=attestationAggregateSig" json:"attestation_aggregate_sig,omitempty"`
Timestamp *types.Timestamp `protobuf:"bytes,6,opt,name=timestamp" json:"timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ProposeRequest) Reset() { *m = ProposeRequest{} }
func (m *ProposeRequest) String() string { return proto.CompactTextString(m) }
func (*ProposeRequest) ProtoMessage() {}
func (*ProposeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{0}
}
func (m *ProposeRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ProposeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ProposeRequest.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 (dst *ProposeRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ProposeRequest.Merge(dst, src)
}
func (m *ProposeRequest) XXX_Size() int {
return m.Size()
}
func (m *ProposeRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ProposeRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ProposeRequest proto.InternalMessageInfo
func (m *ProposeRequest) GetParentHash() []byte {
if m != nil {
return m.ParentHash
}
return nil
}
func (m *ProposeRequest) GetSlotNumber() uint64 {
if m != nil {
return m.SlotNumber
}
return 0
}
func (m *ProposeRequest) GetRandaoRevealHash32() []byte {
if m != nil {
return m.RandaoRevealHash32
}
return nil
}
func (m *ProposeRequest) GetAttestationBitmask() []byte {
if m != nil {
return m.AttestationBitmask
}
return nil
}
func (m *ProposeRequest) GetAttestationAggregateSig() []uint32 {
if m != nil {
return m.AttestationAggregateSig
}
return nil
}
func (m *ProposeRequest) GetTimestamp() *types.Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
type ProposeResponse struct {
BlockHash []byte `protobuf:"bytes,1,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ProposeResponse) Reset() { *m = ProposeResponse{} }
func (m *ProposeResponse) String() string { return proto.CompactTextString(m) }
func (*ProposeResponse) ProtoMessage() {}
func (*ProposeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{1}
}
func (m *ProposeResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ProposeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ProposeResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalTo(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (dst *ProposeResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ProposeResponse.Merge(dst, 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) GetBlockHash() []byte {
if m != nil {
return m.BlockHash
}
return nil
}
type AttestRequest struct {
Attestation *v1.Attestation `protobuf:"bytes,1,opt,name=attestation" json:"attestation,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AttestRequest) Reset() { *m = AttestRequest{} }
func (m *AttestRequest) String() string { return proto.CompactTextString(m) }
func (*AttestRequest) ProtoMessage() {}
func (*AttestRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{2}
}
func (m *AttestRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *AttestRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_AttestRequest.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 (dst *AttestRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_AttestRequest.Merge(dst, src)
}
func (m *AttestRequest) XXX_Size() int {
return m.Size()
}
func (m *AttestRequest) XXX_DiscardUnknown() {
xxx_messageInfo_AttestRequest.DiscardUnknown(m)
}
var xxx_messageInfo_AttestRequest proto.InternalMessageInfo
func (m *AttestRequest) GetAttestation() *v1.Attestation {
if m != nil {
return m.Attestation
}
return nil
}
type AttestResponse struct {
AttestationHash []byte `protobuf:"bytes,1,opt,name=attestation_hash,json=attestationHash,proto3" json:"attestation_hash,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *AttestResponse) Reset() { *m = AttestResponse{} }
func (m *AttestResponse) String() string { return proto.CompactTextString(m) }
func (*AttestResponse) ProtoMessage() {}
func (*AttestResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{3}
}
func (m *AttestResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *AttestResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_AttestResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalTo(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (dst *AttestResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_AttestResponse.Merge(dst, 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) GetAttestationHash() []byte {
if m != nil {
return m.AttestationHash
}
return nil
}
type ValidatorAssignmentRequest struct {
AllValidators bool `protobuf:"varint,1,opt,name=all_validators,json=allValidators,proto3" json:"all_validators,omitempty"`
PublicKeys []*PublicKey `protobuf:"bytes,2,rep,name=public_keys,json=publicKeys" json:"public_keys,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ValidatorAssignmentRequest) Reset() { *m = ValidatorAssignmentRequest{} }
func (m *ValidatorAssignmentRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorAssignmentRequest) ProtoMessage() {}
func (*ValidatorAssignmentRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{4}
}
func (m *ValidatorAssignmentRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ValidatorAssignmentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ValidatorAssignmentRequest.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 (dst *ValidatorAssignmentRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_ValidatorAssignmentRequest.Merge(dst, src)
}
func (m *ValidatorAssignmentRequest) XXX_Size() int {
return m.Size()
}
func (m *ValidatorAssignmentRequest) XXX_DiscardUnknown() {
xxx_messageInfo_ValidatorAssignmentRequest.DiscardUnknown(m)
}
var xxx_messageInfo_ValidatorAssignmentRequest proto.InternalMessageInfo
func (m *ValidatorAssignmentRequest) GetAllValidators() bool {
if m != nil {
return m.AllValidators
}
return false
}
func (m *ValidatorAssignmentRequest) GetPublicKeys() []*PublicKey {
if m != nil {
return m.PublicKeys
}
return nil
}
type ValidatorAssignmentResponse struct {
Assignments []*Assignment `protobuf:"bytes,1,rep,name=assignments" json:"assignments,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ValidatorAssignmentResponse) Reset() { *m = ValidatorAssignmentResponse{} }
func (m *ValidatorAssignmentResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorAssignmentResponse) ProtoMessage() {}
func (*ValidatorAssignmentResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{5}
}
func (m *ValidatorAssignmentResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ValidatorAssignmentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ValidatorAssignmentResponse.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 (dst *ValidatorAssignmentResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ValidatorAssignmentResponse.Merge(dst, src)
}
func (m *ValidatorAssignmentResponse) XXX_Size() int {
return m.Size()
}
func (m *ValidatorAssignmentResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ValidatorAssignmentResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ValidatorAssignmentResponse proto.InternalMessageInfo
func (m *ValidatorAssignmentResponse) GetAssignments() []*Assignment {
if m != nil {
return m.Assignments
}
return nil
}
type Assignment struct {
PublicKey *PublicKey `protobuf:"bytes,1,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
ShardId uint64 `protobuf:"varint,2,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
Role ValidatorRole `protobuf:"varint,3,opt,name=role,proto3,enum=ethereum.beacon.rpc.v1.ValidatorRole" json:"role,omitempty"`
AssignedSlot uint64 `protobuf:"varint,4,opt,name=assigned_slot,json=assignedSlot,proto3" json:"assigned_slot,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Assignment) Reset() { *m = Assignment{} }
func (m *Assignment) String() string { return proto.CompactTextString(m) }
func (*Assignment) ProtoMessage() {}
func (*Assignment) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{6}
}
func (m *Assignment) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Assignment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Assignment.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 (dst *Assignment) XXX_Merge(src proto.Message) {
xxx_messageInfo_Assignment.Merge(dst, src)
}
func (m *Assignment) XXX_Size() int {
return m.Size()
}
func (m *Assignment) XXX_DiscardUnknown() {
xxx_messageInfo_Assignment.DiscardUnknown(m)
}
var xxx_messageInfo_Assignment proto.InternalMessageInfo
func (m *Assignment) GetPublicKey() *PublicKey {
if m != nil {
return m.PublicKey
}
return nil
}
func (m *Assignment) GetShardId() uint64 {
if m != nil {
return m.ShardId
}
return 0
}
func (m *Assignment) GetRole() ValidatorRole {
if m != nil {
return m.Role
}
return ValidatorRole_UNKNOWN
}
func (m *Assignment) GetAssignedSlot() uint64 {
if m != nil {
return m.AssignedSlot
}
return 0
}
type PublicKey struct {
PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PublicKey) Reset() { *m = PublicKey{} }
func (m *PublicKey) String() string { return proto.CompactTextString(m) }
func (*PublicKey) ProtoMessage() {}
func (*PublicKey) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{7}
}
func (m *PublicKey) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_PublicKey.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 (dst *PublicKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_PublicKey.Merge(dst, src)
}
func (m *PublicKey) XXX_Size() int {
return m.Size()
}
func (m *PublicKey) XXX_DiscardUnknown() {
xxx_messageInfo_PublicKey.DiscardUnknown(m)
}
var xxx_messageInfo_PublicKey proto.InternalMessageInfo
func (m *PublicKey) GetPublicKey() []byte {
if m != nil {
return m.PublicKey
}
return nil
}
type SlotResponsibilityResponse struct {
Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
Role ValidatorRole `protobuf:"varint,2,opt,name=role,proto3,enum=ethereum.beacon.rpc.v1.ValidatorRole" json:"role,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SlotResponsibilityResponse) Reset() { *m = SlotResponsibilityResponse{} }
func (m *SlotResponsibilityResponse) String() string { return proto.CompactTextString(m) }
func (*SlotResponsibilityResponse) ProtoMessage() {}
func (*SlotResponsibilityResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{8}
}
func (m *SlotResponsibilityResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SlotResponsibilityResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SlotResponsibilityResponse.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 (dst *SlotResponsibilityResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SlotResponsibilityResponse.Merge(dst, src)
}
func (m *SlotResponsibilityResponse) XXX_Size() int {
return m.Size()
}
func (m *SlotResponsibilityResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SlotResponsibilityResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SlotResponsibilityResponse proto.InternalMessageInfo
func (m *SlotResponsibilityResponse) GetSlot() uint64 {
if m != nil {
return m.Slot
}
return 0
}
func (m *SlotResponsibilityResponse) GetRole() ValidatorRole {
if m != nil {
return m.Role
}
return ValidatorRole_UNKNOWN
}
type IndexResponse struct {
Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *IndexResponse) Reset() { *m = IndexResponse{} }
func (m *IndexResponse) String() string { return proto.CompactTextString(m) }
func (*IndexResponse) ProtoMessage() {}
func (*IndexResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{9}
}
func (m *IndexResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *IndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_IndexResponse.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 (dst *IndexResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_IndexResponse.Merge(dst, src)
}
func (m *IndexResponse) XXX_Size() int {
return m.Size()
}
func (m *IndexResponse) XXX_DiscardUnknown() {
xxx_messageInfo_IndexResponse.DiscardUnknown(m)
}
var xxx_messageInfo_IndexResponse proto.InternalMessageInfo
func (m *IndexResponse) GetIndex() uint32 {
if m != nil {
return m.Index
}
return 0
}
type ShardIDResponse struct {
ShardId uint64 `protobuf:"varint,1,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ShardIDResponse) Reset() { *m = ShardIDResponse{} }
func (m *ShardIDResponse) String() string { return proto.CompactTextString(m) }
func (*ShardIDResponse) ProtoMessage() {}
func (*ShardIDResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{10}
}
func (m *ShardIDResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ShardIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ShardIDResponse.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 (dst *ShardIDResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ShardIDResponse.Merge(dst, src)
}
func (m *ShardIDResponse) XXX_Size() int {
return m.Size()
}
func (m *ShardIDResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ShardIDResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ShardIDResponse proto.InternalMessageInfo
func (m *ShardIDResponse) GetShardId() uint64 {
if m != nil {
return m.ShardId
}
return 0
}
type CurrentAssignmentsResponse struct {
Assignments []*Assignment `protobuf:"bytes,1,rep,name=assignments" json:"assignments,omitempty"`
GenesisTimestamp *types.Timestamp `protobuf:"bytes,2,opt,name=genesis_timestamp,json=genesisTimestamp" json:"genesis_timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CurrentAssignmentsResponse) Reset() { *m = CurrentAssignmentsResponse{} }
func (m *CurrentAssignmentsResponse) String() string { return proto.CompactTextString(m) }
func (*CurrentAssignmentsResponse) ProtoMessage() {}
func (*CurrentAssignmentsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_3b6f14e6d00f3ce9, []int{11}
}
func (m *CurrentAssignmentsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *CurrentAssignmentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_CurrentAssignmentsResponse.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 (dst *CurrentAssignmentsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CurrentAssignmentsResponse.Merge(dst, src)
}
func (m *CurrentAssignmentsResponse) XXX_Size() int {
return m.Size()
}
func (m *CurrentAssignmentsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CurrentAssignmentsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CurrentAssignmentsResponse proto.InternalMessageInfo
func (m *CurrentAssignmentsResponse) GetAssignments() []*Assignment {
if m != nil {
return m.Assignments
}
return nil
}
func (m *CurrentAssignmentsResponse) GetGenesisTimestamp() *types.Timestamp {
if m != nil {
return m.GenesisTimestamp
}
return nil
}
func init() {
proto.RegisterType((*ProposeRequest)(nil), "ethereum.beacon.rpc.v1.ProposeRequest")
proto.RegisterType((*ProposeResponse)(nil), "ethereum.beacon.rpc.v1.ProposeResponse")
proto.RegisterType((*AttestRequest)(nil), "ethereum.beacon.rpc.v1.AttestRequest")
proto.RegisterType((*AttestResponse)(nil), "ethereum.beacon.rpc.v1.AttestResponse")
proto.RegisterType((*ValidatorAssignmentRequest)(nil), "ethereum.beacon.rpc.v1.ValidatorAssignmentRequest")
proto.RegisterType((*ValidatorAssignmentResponse)(nil), "ethereum.beacon.rpc.v1.ValidatorAssignmentResponse")
proto.RegisterType((*Assignment)(nil), "ethereum.beacon.rpc.v1.Assignment")
proto.RegisterType((*PublicKey)(nil), "ethereum.beacon.rpc.v1.PublicKey")
proto.RegisterType((*SlotResponsibilityResponse)(nil), "ethereum.beacon.rpc.v1.SlotResponsibilityResponse")
proto.RegisterType((*IndexResponse)(nil), "ethereum.beacon.rpc.v1.IndexResponse")
proto.RegisterType((*ShardIDResponse)(nil), "ethereum.beacon.rpc.v1.ShardIDResponse")
proto.RegisterType((*CurrentAssignmentsResponse)(nil), "ethereum.beacon.rpc.v1.CurrentAssignmentsResponse")
proto.RegisterEnum("ethereum.beacon.rpc.v1.ValidatorRole", ValidatorRole_name, ValidatorRole_value)
}
// 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
// Client API for BeaconService service
type BeaconServiceClient interface {
CanonicalHead(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*v1.BeaconBlock, error)
LatestAttestation(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconService_LatestAttestationClient, error)
CurrentAssignmentsAndGenesisTime(ctx context.Context, in *ValidatorAssignmentRequest, opts ...grpc.CallOption) (*CurrentAssignmentsResponse, error)
ValidatorAssignments(ctx context.Context, in *ValidatorAssignmentRequest, opts ...grpc.CallOption) (BeaconService_ValidatorAssignmentsClient, error)
}
type beaconServiceClient struct {
cc *grpc.ClientConn
}
func NewBeaconServiceClient(cc *grpc.ClientConn) BeaconServiceClient {
return &beaconServiceClient{cc}
}
func (c *beaconServiceClient) CanonicalHead(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*v1.BeaconBlock, error) {
out := new(v1.BeaconBlock)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.BeaconService/CanonicalHead", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *beaconServiceClient) LatestAttestation(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (BeaconService_LatestAttestationClient, error) {
stream, err := c.cc.NewStream(ctx, &_BeaconService_serviceDesc.Streams[0], "/ethereum.beacon.rpc.v1.BeaconService/LatestAttestation", opts...)
if err != nil {
return nil, err
}
x := &beaconServiceLatestAttestationClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BeaconService_LatestAttestationClient interface {
Recv() (*v1.Attestation, error)
grpc.ClientStream
}
type beaconServiceLatestAttestationClient struct {
grpc.ClientStream
}
func (x *beaconServiceLatestAttestationClient) Recv() (*v1.Attestation, error) {
m := new(v1.Attestation)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *beaconServiceClient) CurrentAssignmentsAndGenesisTime(ctx context.Context, in *ValidatorAssignmentRequest, opts ...grpc.CallOption) (*CurrentAssignmentsResponse, error) {
out := new(CurrentAssignmentsResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.BeaconService/CurrentAssignmentsAndGenesisTime", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *beaconServiceClient) ValidatorAssignments(ctx context.Context, in *ValidatorAssignmentRequest, opts ...grpc.CallOption) (BeaconService_ValidatorAssignmentsClient, error) {
stream, err := c.cc.NewStream(ctx, &_BeaconService_serviceDesc.Streams[1], "/ethereum.beacon.rpc.v1.BeaconService/ValidatorAssignments", opts...)
if err != nil {
return nil, err
}
x := &beaconServiceValidatorAssignmentsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BeaconService_ValidatorAssignmentsClient interface {
Recv() (*ValidatorAssignmentResponse, error)
grpc.ClientStream
}
type beaconServiceValidatorAssignmentsClient struct {
grpc.ClientStream
}
func (x *beaconServiceValidatorAssignmentsClient) Recv() (*ValidatorAssignmentResponse, error) {
m := new(ValidatorAssignmentResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for BeaconService service
type BeaconServiceServer interface {
CanonicalHead(context.Context, *types.Empty) (*v1.BeaconBlock, error)
LatestAttestation(*types.Empty, BeaconService_LatestAttestationServer) error
CurrentAssignmentsAndGenesisTime(context.Context, *ValidatorAssignmentRequest) (*CurrentAssignmentsResponse, error)
ValidatorAssignments(*ValidatorAssignmentRequest, BeaconService_ValidatorAssignmentsServer) error
}
func RegisterBeaconServiceServer(s *grpc.Server, srv BeaconServiceServer) {
s.RegisterService(&_BeaconService_serviceDesc, srv)
}
func _BeaconService_CanonicalHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(types.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BeaconServiceServer).CanonicalHead(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.BeaconService/CanonicalHead",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BeaconServiceServer).CanonicalHead(ctx, req.(*types.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _BeaconService_LatestAttestation_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(types.Empty)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BeaconServiceServer).LatestAttestation(m, &beaconServiceLatestAttestationServer{stream})
}
type BeaconService_LatestAttestationServer interface {
Send(*v1.Attestation) error
grpc.ServerStream
}
type beaconServiceLatestAttestationServer struct {
grpc.ServerStream
}
func (x *beaconServiceLatestAttestationServer) Send(m *v1.Attestation) error {
return x.ServerStream.SendMsg(m)
}
func _BeaconService_CurrentAssignmentsAndGenesisTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ValidatorAssignmentRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(BeaconServiceServer).CurrentAssignmentsAndGenesisTime(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.BeaconService/CurrentAssignmentsAndGenesisTime",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(BeaconServiceServer).CurrentAssignmentsAndGenesisTime(ctx, req.(*ValidatorAssignmentRequest))
}
return interceptor(ctx, in, info, handler)
}
func _BeaconService_ValidatorAssignments_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ValidatorAssignmentRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BeaconServiceServer).ValidatorAssignments(m, &beaconServiceValidatorAssignmentsServer{stream})
}
type BeaconService_ValidatorAssignmentsServer interface {
Send(*ValidatorAssignmentResponse) error
grpc.ServerStream
}
type beaconServiceValidatorAssignmentsServer struct {
grpc.ServerStream
}
func (x *beaconServiceValidatorAssignmentsServer) Send(m *ValidatorAssignmentResponse) error {
return x.ServerStream.SendMsg(m)
}
var _BeaconService_serviceDesc = grpc.ServiceDesc{
ServiceName: "ethereum.beacon.rpc.v1.BeaconService",
HandlerType: (*BeaconServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CanonicalHead",
Handler: _BeaconService_CanonicalHead_Handler,
},
{
MethodName: "CurrentAssignmentsAndGenesisTime",
Handler: _BeaconService_CurrentAssignmentsAndGenesisTime_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "LatestAttestation",
Handler: _BeaconService_LatestAttestation_Handler,
ServerStreams: true,
},
{
StreamName: "ValidatorAssignments",
Handler: _BeaconService_ValidatorAssignments_Handler,
ServerStreams: true,
},
},
Metadata: "proto/beacon/rpc/v1/services.proto",
}
// Client API for AttesterService service
type AttesterServiceClient interface {
AttestHead(ctx context.Context, in *AttestRequest, opts ...grpc.CallOption) (*AttestResponse, error)
}
type attesterServiceClient struct {
cc *grpc.ClientConn
}
func NewAttesterServiceClient(cc *grpc.ClientConn) AttesterServiceClient {
return &attesterServiceClient{cc}
}
func (c *attesterServiceClient) AttestHead(ctx context.Context, in *AttestRequest, opts ...grpc.CallOption) (*AttestResponse, error) {
out := new(AttestResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.AttesterService/AttestHead", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for AttesterService service
type AttesterServiceServer interface {
AttestHead(context.Context, *AttestRequest) (*AttestResponse, error)
}
func RegisterAttesterServiceServer(s *grpc.Server, srv AttesterServiceServer) {
s.RegisterService(&_AttesterService_serviceDesc, srv)
}
func _AttesterService_AttestHead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AttestRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AttesterServiceServer).AttestHead(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.AttesterService/AttestHead",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AttesterServiceServer).AttestHead(ctx, req.(*AttestRequest))
}
return interceptor(ctx, in, info, handler)
}
var _AttesterService_serviceDesc = grpc.ServiceDesc{
ServiceName: "ethereum.beacon.rpc.v1.AttesterService",
HandlerType: (*AttesterServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "AttestHead",
Handler: _AttesterService_AttestHead_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "proto/beacon/rpc/v1/services.proto",
}
// Client API for ProposerService service
type ProposerServiceClient interface {
ProposeBlock(ctx context.Context, in *ProposeRequest, opts ...grpc.CallOption) (*ProposeResponse, error)
}
type proposerServiceClient struct {
cc *grpc.ClientConn
}
func NewProposerServiceClient(cc *grpc.ClientConn) ProposerServiceClient {
return &proposerServiceClient{cc}
}
func (c *proposerServiceClient) ProposeBlock(ctx context.Context, in *ProposeRequest, opts ...grpc.CallOption) (*ProposeResponse, error) {
out := new(ProposeResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ProposerService/ProposeBlock", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ProposerService service
type ProposerServiceServer interface {
ProposeBlock(context.Context, *ProposeRequest) (*ProposeResponse, error)
}
func RegisterProposerServiceServer(s *grpc.Server, srv ProposerServiceServer) {
s.RegisterService(&_ProposerService_serviceDesc, srv)
}
func _ProposerService_ProposeBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ProposeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProposerServiceServer).ProposeBlock(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.ProposerService/ProposeBlock",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProposerServiceServer).ProposeBlock(ctx, req.(*ProposeRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ProposerService_serviceDesc = grpc.ServiceDesc{
ServiceName: "ethereum.beacon.rpc.v1.ProposerService",
HandlerType: (*ProposerServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ProposeBlock",
Handler: _ProposerService_ProposeBlock_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "proto/beacon/rpc/v1/services.proto",
}
// Client API for ValidatorService service
type ValidatorServiceClient interface {
ValidatorShardID(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*ShardIDResponse, error)
ValidatorIndex(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*IndexResponse, error)
ValidatorSlotAndResponsibility(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*SlotResponsibilityResponse, error)
}
type validatorServiceClient struct {
cc *grpc.ClientConn
}
func NewValidatorServiceClient(cc *grpc.ClientConn) ValidatorServiceClient {
return &validatorServiceClient{cc}
}
func (c *validatorServiceClient) ValidatorShardID(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*ShardIDResponse, error) {
out := new(ShardIDResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorShardID", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *validatorServiceClient) ValidatorIndex(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*IndexResponse, error) {
out := new(IndexResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorIndex", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *validatorServiceClient) ValidatorSlotAndResponsibility(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*SlotResponsibilityResponse, error) {
out := new(SlotResponsibilityResponse)
err := c.cc.Invoke(ctx, "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorSlotAndResponsibility", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for ValidatorService service
type ValidatorServiceServer interface {
ValidatorShardID(context.Context, *PublicKey) (*ShardIDResponse, error)
ValidatorIndex(context.Context, *PublicKey) (*IndexResponse, error)
ValidatorSlotAndResponsibility(context.Context, *PublicKey) (*SlotResponsibilityResponse, error)
}
func RegisterValidatorServiceServer(s *grpc.Server, srv ValidatorServiceServer) {
s.RegisterService(&_ValidatorService_serviceDesc, srv)
}
func _ValidatorService_ValidatorShardID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PublicKey)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ValidatorServiceServer).ValidatorShardID(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorShardID",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ValidatorServiceServer).ValidatorShardID(ctx, req.(*PublicKey))
}
return interceptor(ctx, in, info, handler)
}
func _ValidatorService_ValidatorIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PublicKey)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ValidatorServiceServer).ValidatorIndex(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorIndex",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ValidatorServiceServer).ValidatorIndex(ctx, req.(*PublicKey))
}
return interceptor(ctx, in, info, handler)
}
func _ValidatorService_ValidatorSlotAndResponsibility_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(PublicKey)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ValidatorServiceServer).ValidatorSlotAndResponsibility(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.beacon.rpc.v1.ValidatorService/ValidatorSlotAndResponsibility",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ValidatorServiceServer).ValidatorSlotAndResponsibility(ctx, req.(*PublicKey))
}
return interceptor(ctx, in, info, handler)
}
var _ValidatorService_serviceDesc = grpc.ServiceDesc{
ServiceName: "ethereum.beacon.rpc.v1.ValidatorService",
HandlerType: (*ValidatorServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ValidatorShardID",
Handler: _ValidatorService_ValidatorShardID_Handler,
},
{
MethodName: "ValidatorIndex",
Handler: _ValidatorService_ValidatorIndex_Handler,
},
{
MethodName: "ValidatorSlotAndResponsibility",
Handler: _ValidatorService_ValidatorSlotAndResponsibility_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "proto/beacon/rpc/v1/services.proto",
}
func (m *ProposeRequest) 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 *ProposeRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.ParentHash) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.ParentHash)))
i += copy(dAtA[i:], m.ParentHash)
}
if m.SlotNumber != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintServices(dAtA, i, uint64(m.SlotNumber))
}
if len(m.RandaoRevealHash32) > 0 {
dAtA[i] = 0x1a
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.RandaoRevealHash32)))
i += copy(dAtA[i:], m.RandaoRevealHash32)
}
if len(m.AttestationBitmask) > 0 {
dAtA[i] = 0x22
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.AttestationBitmask)))
i += copy(dAtA[i:], m.AttestationBitmask)
}
if len(m.AttestationAggregateSig) > 0 {
dAtA2 := make([]byte, len(m.AttestationAggregateSig)*10)
var j1 int
for _, num := range m.AttestationAggregateSig {
for num >= 1<<7 {
dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j1++
}
dAtA2[j1] = uint8(num)
j1++
}
dAtA[i] = 0x2a
i++
i = encodeVarintServices(dAtA, i, uint64(j1))
i += copy(dAtA[i:], dAtA2[:j1])
}
if m.Timestamp != nil {
dAtA[i] = 0x32
i++
i = encodeVarintServices(dAtA, i, uint64(m.Timestamp.Size()))
n3, err := m.Timestamp.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n3
}
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.BlockHash) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.BlockHash)))
i += copy(dAtA[i:], m.BlockHash)
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *AttestRequest) 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 *AttestRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Attestation != nil {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(m.Attestation.Size()))
n4, err := m.Attestation.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n4
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (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.AttestationHash) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.AttestationHash)))
i += copy(dAtA[i:], m.AttestationHash)
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *ValidatorAssignmentRequest) 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 *ValidatorAssignmentRequest) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.AllValidators {
dAtA[i] = 0x8
i++
if m.AllValidators {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
}
if len(m.PublicKeys) > 0 {
for _, msg := range m.PublicKeys {
dAtA[i] = 0x12
i++
i = encodeVarintServices(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *ValidatorAssignmentResponse) 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 *ValidatorAssignmentResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Assignments) > 0 {
for _, msg := range m.Assignments {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *Assignment) 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 *Assignment) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.PublicKey != nil {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(m.PublicKey.Size()))
n5, err := m.PublicKey.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n5
}
if m.ShardId != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintServices(dAtA, i, uint64(m.ShardId))
}
if m.Role != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintServices(dAtA, i, uint64(m.Role))
}
if m.AssignedSlot != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintServices(dAtA, i, uint64(m.AssignedSlot))
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *PublicKey) 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 *PublicKey) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.PublicKey) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.PublicKey)))
i += copy(dAtA[i:], m.PublicKey)
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *SlotResponsibilityResponse) 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 *SlotResponsibilityResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Slot != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintServices(dAtA, i, uint64(m.Slot))
}
if m.Role != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintServices(dAtA, i, uint64(m.Role))
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *IndexResponse) 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 *IndexResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Index != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintServices(dAtA, i, uint64(m.Index))
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *ShardIDResponse) 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 *ShardIDResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.ShardId != 0 {
dAtA[i] = 0x8
i++
i = encodeVarintServices(dAtA, i, uint64(m.ShardId))
}
if m.XXX_unrecognized != nil {
i += copy(dAtA[i:], m.XXX_unrecognized)
}
return i, nil
}
func (m *CurrentAssignmentsResponse) 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 *CurrentAssignmentsResponse) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if len(m.Assignments) > 0 {
for _, msg := range m.Assignments {
dAtA[i] = 0xa
i++
i = encodeVarintServices(dAtA, i, uint64(msg.Size()))
n, err := msg.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n
}
}
if m.GenesisTimestamp != nil {
dAtA[i] = 0x12
i++
i = encodeVarintServices(dAtA, i, uint64(m.GenesisTimestamp.Size()))
n6, err := m.GenesisTimestamp.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 encodeVarintServices(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return offset + 1
}
func (m *ProposeRequest) Size() (n int) {
var l int
_ = l
l = len(m.ParentHash)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
if m.SlotNumber != 0 {
n += 1 + sovServices(uint64(m.SlotNumber))
}
l = len(m.RandaoRevealHash32)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
l = len(m.AttestationBitmask)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
if len(m.AttestationAggregateSig) > 0 {
l = 0
for _, e := range m.AttestationAggregateSig {
l += sovServices(uint64(e))
}
n += 1 + sovServices(uint64(l)) + l
}
if m.Timestamp != nil {
l = m.Timestamp.Size()
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *ProposeResponse) Size() (n int) {
var l int
_ = l
l = len(m.BlockHash)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *AttestRequest) Size() (n int) {
var l int
_ = l
if m.Attestation != nil {
l = m.Attestation.Size()
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *AttestResponse) Size() (n int) {
var l int
_ = l
l = len(m.AttestationHash)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *ValidatorAssignmentRequest) Size() (n int) {
var l int
_ = l
if m.AllValidators {
n += 2
}
if len(m.PublicKeys) > 0 {
for _, e := range m.PublicKeys {
l = e.Size()
n += 1 + l + sovServices(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *ValidatorAssignmentResponse) Size() (n int) {
var l int
_ = l
if len(m.Assignments) > 0 {
for _, e := range m.Assignments {
l = e.Size()
n += 1 + l + sovServices(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Assignment) Size() (n int) {
var l int
_ = l
if m.PublicKey != nil {
l = m.PublicKey.Size()
n += 1 + l + sovServices(uint64(l))
}
if m.ShardId != 0 {
n += 1 + sovServices(uint64(m.ShardId))
}
if m.Role != 0 {
n += 1 + sovServices(uint64(m.Role))
}
if m.AssignedSlot != 0 {
n += 1 + sovServices(uint64(m.AssignedSlot))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *PublicKey) Size() (n int) {
var l int
_ = l
l = len(m.PublicKey)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *SlotResponsibilityResponse) Size() (n int) {
var l int
_ = l
if m.Slot != 0 {
n += 1 + sovServices(uint64(m.Slot))
}
if m.Role != 0 {
n += 1 + sovServices(uint64(m.Role))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *IndexResponse) Size() (n int) {
var l int
_ = l
if m.Index != 0 {
n += 1 + sovServices(uint64(m.Index))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *ShardIDResponse) Size() (n int) {
var l int
_ = l
if m.ShardId != 0 {
n += 1 + sovServices(uint64(m.ShardId))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *CurrentAssignmentsResponse) Size() (n int) {
var l int
_ = l
if len(m.Assignments) > 0 {
for _, e := range m.Assignments {
l = e.Size()
n += 1 + l + sovServices(uint64(l))
}
}
if m.GenesisTimestamp != nil {
l = m.GenesisTimestamp.Size()
n += 1 + l + sovServices(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovServices(x uint64) (n int) {
for {
n++
x >>= 7
if x == 0 {
break
}
}
return n
}
func sozServices(x uint64) (n int) {
return sovServices(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ProposeRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ProposeRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ProposeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ParentHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ParentHash = append(m.ParentHash[:0], dAtA[iNdEx:postIndex]...)
if m.ParentHash == nil {
m.ParentHash = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SlotNumber", wireType)
}
m.SlotNumber = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.SlotNumber |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RandaoRevealHash32", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RandaoRevealHash32 = append(m.RandaoRevealHash32[:0], dAtA[iNdEx:postIndex]...)
if m.RandaoRevealHash32 == nil {
m.RandaoRevealHash32 = []byte{}
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AttestationBitmask", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AttestationBitmask = append(m.AttestationBitmask[:0], dAtA[iNdEx:postIndex]...)
if m.AttestationBitmask == nil {
m.AttestationBitmask = []byte{}
}
iNdEx = postIndex
case 5:
if wireType == 0 {
var v uint32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AttestationAggregateSig = append(m.AttestationAggregateSig, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + packedLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
for iNdEx < postIndex {
var v uint32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AttestationAggregateSig = append(m.AttestationAggregateSig, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field AttestationAggregateSig", wireType)
}
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Timestamp == nil {
m.Timestamp = &types.Timestamp{}
}
if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ProposeResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ProposeResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ProposeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.BlockHash = append(m.BlockHash[:0], dAtA[iNdEx:postIndex]...)
if m.BlockHash == nil {
m.BlockHash = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AttestRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AttestRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AttestRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Attestation", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Attestation == nil {
m.Attestation = &v1.Attestation{}
}
if err := m.Attestation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *AttestResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: AttestResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: AttestResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AttestationHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.AttestationHash = append(m.AttestationHash[:0], dAtA[iNdEx:postIndex]...)
if m.AttestationHash == nil {
m.AttestationHash = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ValidatorAssignmentRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ValidatorAssignmentRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ValidatorAssignmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AllValidators", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.AllValidators = bool(v != 0)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PublicKeys", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PublicKeys = append(m.PublicKeys, &PublicKey{})
if err := m.PublicKeys[len(m.PublicKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *ValidatorAssignmentResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ValidatorAssignmentResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ValidatorAssignmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Assignments", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Assignments = append(m.Assignments, &Assignment{})
if err := m.Assignments[len(m.Assignments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *Assignment) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Assignment: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Assignment: 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 msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.PublicKey == nil {
m.PublicKey = &PublicKey{}
}
if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ShardId", wireType)
}
m.ShardId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ShardId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
}
m.Role = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Role |= (ValidatorRole(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AssignedSlot", wireType)
}
m.AssignedSlot = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.AssignedSlot |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *PublicKey) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PublicKey: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PublicKey: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + byteLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
if m.PublicKey == nil {
m.PublicKey = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *SlotResponsibilityResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: SlotResponsibilityResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SlotResponsibilityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType)
}
m.Slot = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Slot |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
}
m.Role = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Role |= (ValidatorRole(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *IndexResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: IndexResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: IndexResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
}
m.Index = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Index |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *ShardIDResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ShardIDResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ShardIDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ShardId", wireType)
}
m.ShardId = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ShardId |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > 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 *CurrentAssignmentsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: CurrentAssignmentsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: CurrentAssignmentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Assignments", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Assignments = append(m.Assignments, &Assignment{})
if err := m.Assignments[len(m.Assignments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field GenesisTimestamp", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowServices
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthServices
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.GenesisTimestamp == nil {
m.GenesisTimestamp = &types.Timestamp{}
}
if err := m.GenesisTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipServices(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthServices
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipServices(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowServices
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowServices
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowServices
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
iNdEx += length
if length < 0 {
return 0, ErrInvalidLengthServices
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowServices
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipServices(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
}
return iNdEx, nil
case 4:
return iNdEx, nil
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
}
panic("unreachable")
}
var (
ErrInvalidLengthServices = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowServices = fmt.Errorf("proto: integer overflow")
)
func init() {
proto.RegisterFile("proto/beacon/rpc/v1/services.proto", fileDescriptor_services_3b6f14e6d00f3ce9)
}
var fileDescriptor_services_3b6f14e6d00f3ce9 = []byte{
// 946 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x51, 0x6f, 0xdb, 0x54,
0x14, 0xc6, 0x69, 0xb7, 0xb5, 0x27, 0x71, 0x9a, 0x5d, 0xaa, 0x91, 0x79, 0xa2, 0x0d, 0x9e, 0x0a,
0x61, 0x42, 0x4e, 0xeb, 0xbe, 0x0c, 0x78, 0x21, 0xd9, 0xa2, 0x75, 0xda, 0xd4, 0x56, 0x4e, 0x19,
0x12, 0x48, 0x58, 0x37, 0xf1, 0xc5, 0xb1, 0xea, 0xf8, 0x1a, 0xdf, 0x9b, 0x40, 0x1e, 0x79, 0x42,
0xe2, 0xaf, 0xec, 0x5f, 0xf0, 0x02, 0xbc, 0xf1, 0x13, 0x50, 0x7f, 0x09, 0xf2, 0xbd, 0xf6, 0x8d,
0xd3, 0xd6, 0xa4, 0x45, 0x7b, 0xb3, 0xcf, 0x39, 0xdf, 0x39, 0x9f, 0xbf, 0x7b, 0xfc, 0x5d, 0x30,
0xe3, 0x84, 0x72, 0xda, 0x19, 0x12, 0x3c, 0xa2, 0x51, 0x27, 0x89, 0x47, 0x9d, 0xd9, 0x41, 0x87,
0x91, 0x64, 0x16, 0x8c, 0x08, 0xb3, 0x44, 0x12, 0x3d, 0x20, 0x7c, 0x4c, 0x12, 0x32, 0x9d, 0x58,
0xb2, 0xcc, 0x4a, 0xe2, 0x91, 0x35, 0x3b, 0x30, 0x76, 0x97, 0xb0, 0xb1, 0x1d, 0xa7, 0x58, 0x3e,
0x8f, 0x73, 0xa0, 0xf1, 0xc8, 0xa7, 0xd4, 0x0f, 0x49, 0x47, 0xbc, 0x0d, 0xa7, 0x3f, 0x74, 0xc8,
0x24, 0xe6, 0xf3, 0x2c, 0xb9, 0x7b, 0x39, 0xc9, 0x83, 0x09, 0x61, 0x1c, 0x4f, 0x62, 0x59, 0x60,
0xbe, 0xad, 0x40, 0xfd, 0x34, 0xa1, 0x31, 0x65, 0xc4, 0x21, 0x3f, 0x4e, 0x09, 0xe3, 0x68, 0x17,
0xaa, 0x31, 0x4e, 0x48, 0xc4, 0xdd, 0x31, 0x66, 0xe3, 0xa6, 0xd6, 0xd2, 0xda, 0x35, 0x07, 0x64,
0xe8, 0x08, 0xb3, 0x71, 0x5a, 0xc0, 0x42, 0xca, 0xdd, 0x68, 0x3a, 0x19, 0x92, 0xa4, 0x59, 0x69,
0x69, 0xed, 0x75, 0x07, 0xd2, 0xd0, 0xb1, 0x88, 0xa0, 0x7d, 0xd8, 0x4e, 0x70, 0xe4, 0x61, 0xea,
0x26, 0x64, 0x46, 0x70, 0x28, 0x1a, 0x1d, 0xda, 0xcd, 0x35, 0xd1, 0x0a, 0xc9, 0x9c, 0x23, 0x52,
0x47, 0x22, 0x83, 0x3a, 0xf0, 0x3e, 0xe6, 0x3c, 0x65, 0xc6, 0x03, 0x1a, 0xb9, 0xc3, 0x80, 0x4f,
0x30, 0x3b, 0x6f, 0xae, 0x4b, 0x40, 0x21, 0xd5, 0x93, 0x19, 0xf4, 0x05, 0x3c, 0x2c, 0x02, 0xb0,
0xef, 0x27, 0xc4, 0xc7, 0x9c, 0xb8, 0x2c, 0xf0, 0x9b, 0x77, 0x5a, 0x6b, 0x6d, 0xdd, 0xf9, 0xa0,
0x50, 0xd0, 0xcd, 0xf3, 0x83, 0xc0, 0x47, 0x4f, 0x61, 0x53, 0xc9, 0xd0, 0xbc, 0xdb, 0xd2, 0xda,
0x55, 0xdb, 0xb0, 0xa4, 0x50, 0x56, 0x2e, 0x94, 0x75, 0x96, 0x57, 0x38, 0x8b, 0x62, 0x73, 0x1f,
0xb6, 0x94, 0x58, 0x2c, 0xa6, 0x11, 0x23, 0xe8, 0x43, 0x80, 0x61, 0x48, 0x47, 0xe7, 0x45, 0xb1,
0x36, 0x45, 0x24, 0xfd, 0x34, 0xf3, 0x0d, 0xe8, 0x5d, 0x41, 0x23, 0x57, 0xb7, 0x0f, 0xd5, 0x02,
0x2f, 0x01, 0xa8, 0xda, 0x8f, 0xad, 0xcb, 0xa7, 0x1f, 0xdb, 0xb1, 0x35, 0x3b, 0xb0, 0xba, 0x8b,
0x52, 0xa7, 0x88, 0x33, 0xbf, 0x84, 0x7a, 0xde, 0x37, 0x23, 0xf2, 0x29, 0x34, 0x8a, 0x8a, 0x14,
0xe8, 0x6c, 0x15, 0xe2, 0x82, 0xd4, 0xaf, 0x1a, 0x18, 0x6f, 0x70, 0x18, 0x78, 0x98, 0xd3, 0xa4,
0xcb, 0x58, 0xe0, 0x47, 0x13, 0x12, 0x29, 0x8a, 0x7b, 0x50, 0xc7, 0x61, 0xe8, 0xce, 0xf2, 0x0a,
0x26, 0xfa, 0x6c, 0x38, 0x3a, 0x0e, 0x43, 0x05, 0x63, 0xa8, 0x07, 0xd5, 0x78, 0x3a, 0x0c, 0x83,
0x91, 0x7b, 0x4e, 0xe6, 0xac, 0x59, 0x69, 0xad, 0xb5, 0xab, 0xf6, 0x47, 0xd6, 0xf5, 0x7b, 0x6c,
0x9d, 0x8a, 0xd2, 0x57, 0x64, 0xee, 0x40, 0x9c, 0x3f, 0x32, 0x73, 0x04, 0x8f, 0xae, 0x25, 0x92,
0x7d, 0xd3, 0x73, 0xa8, 0x62, 0x15, 0x4d, 0x69, 0xa4, 0x23, 0xcc, 0xb2, 0x11, 0x85, 0x06, 0x45,
0x98, 0xf9, 0x97, 0x06, 0xb0, 0xc8, 0xa1, 0xaf, 0x00, 0x16, 0xbc, 0xb3, 0x03, 0xb8, 0x01, 0xed,
0x4d, 0x45, 0x1b, 0x3d, 0x84, 0x0d, 0x36, 0xc6, 0x89, 0xe7, 0x06, 0x5e, 0xb6, 0xfd, 0xf7, 0xc4,
0xfb, 0x4b, 0x0f, 0x7d, 0x0e, 0xeb, 0x09, 0x0d, 0x89, 0x58, 0xf5, 0xba, 0xbd, 0x57, 0xd6, 0x56,
0x7d, 0xb4, 0x43, 0x43, 0xe2, 0x08, 0x08, 0x7a, 0x0c, 0xba, 0x64, 0x4d, 0x3c, 0x37, 0xfd, 0x99,
0xc4, 0xf6, 0xaf, 0x3b, 0xb5, 0x3c, 0x38, 0x08, 0x29, 0x37, 0x9f, 0xc0, 0xa6, 0xa2, 0x94, 0xee,
0xde, 0xa5, 0x2f, 0xa9, 0x15, 0x68, 0x9a, 0xe7, 0x60, 0xa4, 0x98, 0x4c, 0xcd, 0x60, 0x18, 0x84,
0x01, 0x9f, 0x2b, 0x6d, 0x11, 0xac, 0x8b, 0x29, 0x9a, 0x98, 0x22, 0x9e, 0x15, 0xfb, 0xca, 0xad,
0xd9, 0x9b, 0x7b, 0xa0, 0xbf, 0x8c, 0x3c, 0xf2, 0xb3, 0xea, 0xbf, 0x0d, 0x77, 0x82, 0x34, 0x20,
0x06, 0xe8, 0x8e, 0x7c, 0x31, 0x3f, 0x83, 0xad, 0x81, 0x90, 0xea, 0xb9, 0x2a, 0x2c, 0xaa, 0xa9,
0x2d, 0xa9, 0x69, 0xbe, 0xd5, 0xc0, 0x78, 0x36, 0x4d, 0x52, 0xe7, 0x59, 0x1c, 0x20, 0x7b, 0xb7,
0xeb, 0x81, 0x5e, 0xc0, 0x7d, 0x9f, 0x44, 0x84, 0x05, 0xcc, 0x5d, 0xd8, 0x42, 0x65, 0xa5, 0x2d,
0x34, 0x32, 0x90, 0x8a, 0x3c, 0x79, 0x0a, 0xfa, 0x92, 0x32, 0xa8, 0x0a, 0xf7, 0xbe, 0x3e, 0x7e,
0x75, 0x7c, 0xf2, 0xcd, 0x71, 0xe3, 0x3d, 0x54, 0x83, 0x8d, 0xee, 0xd9, 0x59, 0x7f, 0x70, 0xd6,
0x77, 0x1a, 0x5a, 0xfa, 0x76, 0xea, 0x9c, 0x9c, 0x9e, 0x0c, 0xfa, 0x4e, 0xa3, 0x62, 0xff, 0xbe,
0x06, 0x7a, 0x4f, 0x90, 0x1d, 0xc8, 0x5b, 0x01, 0xbd, 0x06, 0xfd, 0x19, 0x8e, 0x68, 0x14, 0x8c,
0x70, 0x78, 0x44, 0xb0, 0x87, 0x1e, 0x5c, 0xa1, 0xd2, 0x4f, 0x7d, 0xde, 0x28, 0xb5, 0x0e, 0xd9,
0xaf, 0x97, 0x3a, 0x11, 0x72, 0xe0, 0xfe, 0x6b, 0x9c, 0x7a, 0x40, 0xc1, 0x4f, 0x6e, 0xdf, 0xb1,
0x00, 0xde, 0xd7, 0xd0, 0x6f, 0x1a, 0xb4, 0xae, 0x9e, 0x4d, 0x37, 0xf2, 0x5e, 0x2c, 0x74, 0x41,
0xf6, 0xca, 0x15, 0xba, 0x62, 0x3f, 0x46, 0x29, 0xe6, 0x3f, 0x36, 0xe1, 0x17, 0x0d, 0xb6, 0xaf,
0x69, 0xc9, 0xfe, 0x17, 0x81, 0xc3, 0x5b, 0x61, 0x24, 0x83, 0x7d, 0xcd, 0x8e, 0x60, 0x4b, 0x2a,
0x44, 0x92, 0xfc, 0x14, 0xbf, 0x03, 0x90, 0x21, 0x71, 0x84, 0xa5, 0xff, 0xd3, 0xd2, 0x0d, 0x61,
0x7c, 0xbc, 0xaa, 0x4c, 0x4e, 0xb4, 0x13, 0x75, 0x19, 0xa9, 0x79, 0x2e, 0xd4, 0xb2, 0x90, 0x3c,
0xf7, 0xd2, 0x56, 0xcb, 0x57, 0xbe, 0xf1, 0xc9, 0xca, 0xba, 0x6c, 0xe6, 0x1f, 0x15, 0x68, 0x28,
0x15, 0xf2, 0xa9, 0xdf, 0x17, 0x63, 0xf2, 0xe7, 0x46, 0xab, 0x0d, 0xb5, 0x7c, 0xe8, 0x65, 0x83,
0xf8, 0x16, 0xea, 0xaa, 0xbf, 0xf0, 0x98, 0x9b, 0x74, 0x2f, 0x15, 0x7b, 0xd9, 0xa5, 0x7e, 0x82,
0x9d, 0x05, 0xf7, 0x90, 0xf2, 0x6e, 0xe4, 0x2d, 0xfb, 0xe5, 0x4d, 0x66, 0x95, 0x2e, 0x59, 0xb9,
0xfd, 0xf6, 0x6a, 0x7f, 0x5e, 0xec, 0x68, 0x7f, 0x5f, 0xec, 0x68, 0xff, 0x5c, 0xec, 0x68, 0xc3,
0xbb, 0xe2, 0x1f, 0x3c, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0xca, 0xb5, 0x33, 0x47, 0x2a, 0x0a,
0x00, 0x00,
}
Reference in New Issue View Git Blame Copy Permalink