mirror/prysm-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/prysm-pulse.git synced 2024-12-31 23:41:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5727d4eb8a
prysm-pulse/proto/validator/accounts/v2/keymanager.pb.go
Ivan Martinez afc3b3168a
Add Back Accounts Backup Validator RPC Functionality (#8367) 
* Add Back Accounts Backup Validator RPC Functionality

This reverts commit a39db494eb.

* Fix
2021-01-29 18:30:44 -06:00

1505 lines
40 KiB
Go
Executable File
Generated
Raw Blame History

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: proto/validator/accounts/v2/keymanager.proto
package ethereum_validator_accounts_v2
import (
context "context"
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
v1alpha1 "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
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.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type SignResponse_Status int32
const (
SignResponse_UNKNOWN SignResponse_Status = 0
SignResponse_SUCCEEDED SignResponse_Status = 1
SignResponse_DENIED SignResponse_Status = 2
SignResponse_FAILED SignResponse_Status = 3
)
var SignResponse_Status_name = map[int32]string{
0: "UNKNOWN",
1: "SUCCEEDED",
2: "DENIED",
3: "FAILED",
}
var SignResponse_Status_value = map[string]int32{
"UNKNOWN": 0,
"SUCCEEDED": 1,
"DENIED": 2,
"FAILED": 3,
}
func (x SignResponse_Status) String() string {
return proto.EnumName(SignResponse_Status_name, int32(x))
}
func (SignResponse_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_795e98bd0a473d79, []int{2, 0}
}
type ListPublicKeysResponse struct {
ValidatingPublicKeys [][]byte `protobuf:"bytes,2,rep,name=validating_public_keys,json=validatingPublicKeys,proto3" json:"validating_public_keys,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ListPublicKeysResponse) Reset() { *m = ListPublicKeysResponse{} }
func (m *ListPublicKeysResponse) String() string { return proto.CompactTextString(m) }
func (*ListPublicKeysResponse) ProtoMessage() {}
func (*ListPublicKeysResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_795e98bd0a473d79, []int{0}
}
func (m *ListPublicKeysResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ListPublicKeysResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ListPublicKeysResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *ListPublicKeysResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ListPublicKeysResponse.Merge(m, src)
}
func (m *ListPublicKeysResponse) XXX_Size() int {
return m.Size()
}
func (m *ListPublicKeysResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ListPublicKeysResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ListPublicKeysResponse proto.InternalMessageInfo
func (m *ListPublicKeysResponse) GetValidatingPublicKeys() [][]byte {
if m != nil {
return m.ValidatingPublicKeys
}
return nil
}
type SignRequest struct {
PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
SigningRoot []byte `protobuf:"bytes,2,opt,name=signing_root,json=signingRoot,proto3" json:"signing_root,omitempty"`
SignatureDomain []byte `protobuf:"bytes,3,opt,name=signature_domain,json=signatureDomain,proto3" json:"signature_domain,omitempty"`
// Types that are valid to be assigned to Object:
// *SignRequest_Block
// *SignRequest_AttestationData
// *SignRequest_AggregateAttestationAndProof
// *SignRequest_Exit
// *SignRequest_Slot
// *SignRequest_Epoch
Object isSignRequest_Object `protobuf_oneof:"object"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SignRequest) Reset() { *m = SignRequest{} }
func (m *SignRequest) String() string { return proto.CompactTextString(m) }
func (*SignRequest) ProtoMessage() {}
func (*SignRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_795e98bd0a473d79, []int{1}
}
func (m *SignRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SignRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *SignRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SignRequest.Merge(m, src)
}
func (m *SignRequest) XXX_Size() int {
return m.Size()
}
func (m *SignRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SignRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SignRequest proto.InternalMessageInfo
type isSignRequest_Object interface {
isSignRequest_Object()
MarshalTo([]byte) (int, error)
Size() int
}
type SignRequest_Block struct {
Block *v1alpha1.BeaconBlock `protobuf:"bytes,101,opt,name=block,proto3,oneof" json:"block,omitempty"`
}
type SignRequest_AttestationData struct {
AttestationData *v1alpha1.AttestationData `protobuf:"bytes,102,opt,name=attestation_data,json=attestationData,proto3,oneof" json:"attestation_data,omitempty"`
}
type SignRequest_AggregateAttestationAndProof struct {
AggregateAttestationAndProof *v1alpha1.AggregateAttestationAndProof `protobuf:"bytes,103,opt,name=aggregate_attestation_and_proof,json=aggregateAttestationAndProof,proto3,oneof" json:"aggregate_attestation_and_proof,omitempty"`
}
type SignRequest_Exit struct {
Exit *v1alpha1.VoluntaryExit `protobuf:"bytes,104,opt,name=exit,proto3,oneof" json:"exit,omitempty"`
}
type SignRequest_Slot struct {
Slot uint64 `protobuf:"varint,105,opt,name=slot,proto3,oneof" json:"slot,omitempty"`
}
type SignRequest_Epoch struct {
Epoch uint64 `protobuf:"varint,106,opt,name=epoch,proto3,oneof" json:"epoch,omitempty"`
}
func (*SignRequest_Block) isSignRequest_Object() {}
func (*SignRequest_AttestationData) isSignRequest_Object() {}
func (*SignRequest_AggregateAttestationAndProof) isSignRequest_Object() {}
func (*SignRequest_Exit) isSignRequest_Object() {}
func (*SignRequest_Slot) isSignRequest_Object() {}
func (*SignRequest_Epoch) isSignRequest_Object() {}
func (m *SignRequest) GetObject() isSignRequest_Object {
if m != nil {
return m.Object
}
return nil
}
func (m *SignRequest) GetPublicKey() []byte {
if m != nil {
return m.PublicKey
}
return nil
}
func (m *SignRequest) GetSigningRoot() []byte {
if m != nil {
return m.SigningRoot
}
return nil
}
func (m *SignRequest) GetSignatureDomain() []byte {
if m != nil {
return m.SignatureDomain
}
return nil
}
func (m *SignRequest) GetBlock() *v1alpha1.BeaconBlock {
if x, ok := m.GetObject().(*SignRequest_Block); ok {
return x.Block
}
return nil
}
func (m *SignRequest) GetAttestationData() *v1alpha1.AttestationData {
if x, ok := m.GetObject().(*SignRequest_AttestationData); ok {
return x.AttestationData
}
return nil
}
func (m *SignRequest) GetAggregateAttestationAndProof() *v1alpha1.AggregateAttestationAndProof {
if x, ok := m.GetObject().(*SignRequest_AggregateAttestationAndProof); ok {
return x.AggregateAttestationAndProof
}
return nil
}
func (m *SignRequest) GetExit() *v1alpha1.VoluntaryExit {
if x, ok := m.GetObject().(*SignRequest_Exit); ok {
return x.Exit
}
return nil
}
func (m *SignRequest) GetSlot() uint64 {
if x, ok := m.GetObject().(*SignRequest_Slot); ok {
return x.Slot
}
return 0
}
func (m *SignRequest) GetEpoch() uint64 {
if x, ok := m.GetObject().(*SignRequest_Epoch); ok {
return x.Epoch
}
return 0
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*SignRequest) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*SignRequest_Block)(nil),
(*SignRequest_AttestationData)(nil),
(*SignRequest_AggregateAttestationAndProof)(nil),
(*SignRequest_Exit)(nil),
(*SignRequest_Slot)(nil),
(*SignRequest_Epoch)(nil),
}
}
type SignResponse struct {
Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
Status SignResponse_Status `protobuf:"varint,2,opt,name=status,proto3,enum=ethereum.validator.accounts.v2.SignResponse_Status" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SignResponse) Reset() { *m = SignResponse{} }
func (m *SignResponse) String() string { return proto.CompactTextString(m) }
func (*SignResponse) ProtoMessage() {}
func (*SignResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_795e98bd0a473d79, []int{2}
}
func (m *SignResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SignResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *SignResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SignResponse.Merge(m, src)
}
func (m *SignResponse) XXX_Size() int {
return m.Size()
}
func (m *SignResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SignResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SignResponse proto.InternalMessageInfo
func (m *SignResponse) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func (m *SignResponse) GetStatus() SignResponse_Status {
if m != nil {
return m.Status
}
return SignResponse_UNKNOWN
}
func init() {
proto.RegisterEnum("ethereum.validator.accounts.v2.SignResponse_Status", SignResponse_Status_name, SignResponse_Status_value)
proto.RegisterType((*ListPublicKeysResponse)(nil), "ethereum.validator.accounts.v2.ListPublicKeysResponse")
proto.RegisterType((*SignRequest)(nil), "ethereum.validator.accounts.v2.SignRequest")
proto.RegisterType((*SignResponse)(nil), "ethereum.validator.accounts.v2.SignResponse")
}
func init() {
proto.RegisterFile("proto/validator/accounts/v2/keymanager.proto", fileDescriptor_795e98bd0a473d79)
}
var fileDescriptor_795e98bd0a473d79 = []byte{
// 671 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6a, 0xdb, 0x4c,
0x10, 0xb5, 0x6c, 0xc7, 0xdf, 0x97, 0xb5, 0xdb, 0x98, 0x25, 0x18, 0xe1, 0xba, 0x8e, 0x2b, 0x42,
0x71, 0x69, 0x90, 0x88, 0x53, 0x7a, 0x11, 0x7a, 0x13, 0xc7, 0x2a, 0x0e, 0x09, 0x6e, 0x90, 0x49,
0x7a, 0x29, 0xd6, 0xf2, 0x44, 0x56, 0x22, 0xef, 0xaa, 0xd2, 0xca, 0xc4, 0xd0, 0xab, 0xf6, 0x05,
0x0a, 0x7d, 0x88, 0x3e, 0x42, 0x5f, 0xa1, 0x97, 0x85, 0xbe, 0x40, 0x09, 0x7d, 0x8d, 0x42, 0xd9,
0x95, 0xfc, 0x13, 0x70, 0xfa, 0x73, 0xe7, 0x39, 0x73, 0xce, 0xcc, 0xf8, 0xcc, 0x8e, 0xd0, 0x4e,
0x10, 0x32, 0xce, 0x8c, 0x09, 0xf1, 0xbd, 0x21, 0xe1, 0x2c, 0x34, 0x88, 0xe3, 0xb0, 0x98, 0xf2,
0xc8, 0x98, 0xb4, 0x8c, 0x2b, 0x98, 0x8e, 0x09, 0x25, 0x2e, 0x84, 0xba, 0xa4, 0xe1, 0x3a, 0xf0,
0x11, 0x84, 0x10, 0x8f, 0xf5, 0xb9, 0x40, 0x9f, 0x09, 0xf4, 0x49, 0xab, 0x2a, 0xf2, 0xc6, 0x64,
0x97, 0xf8, 0xc1, 0x88, 0xec, 0x1a, 0x84, 0x73, 0x88, 0x38, 0xe1, 0x1e, 0xa3, 0x89, 0xbe, 0xba,
0x75, 0x2b, 0x3f, 0x00, 0xe2, 0x30, 0x6a, 0x0f, 0x7c, 0xe6, 0x5c, 0xa5, 0x84, 0x9a, 0xcb, 0x98,
0xeb, 0x83, 0x41, 0x02, 0xcf, 0x20, 0x94, 0xb2, 0x44, 0x1d, 0xa5, 0xd9, 0x07, 0x69, 0x56, 0x46,
0x83, 0xf8, 0xc2, 0x80, 0x71, 0xc0, 0xa7, 0x49, 0x52, 0xeb, 0xa1, 0xca, 0x89, 0x17, 0xf1, 0xd3,
0x78, 0xe0, 0x7b, 0xce, 0x31, 0x4c, 0x23, 0x0b, 0xa2, 0x80, 0xd1, 0x08, 0xf0, 0x33, 0x54, 0x49,
0xc7, 0xf5, 0xa8, 0x6b, 0x07, 0x92, 0x60, 0x5f, 0xc1, 0x34, 0x52, 0xb3, 0x8d, 0x5c, 0xb3, 0x64,
0x6d, 0x2e, 0xb2, 0x0b, 0xb5, 0xf6, 0x33, 0x87, 0x8a, 0x7d, 0xcf, 0xa5, 0x16, 0xbc, 0x89, 0x21,
0xe2, 0xf8, 0x21, 0x42, 0x0b, 0xa9, 0xaa, 0x34, 0x94, 0x66, 0xc9, 0x5a, 0x0f, 0x66, 0x7c, 0xfc,
0x08, 0x95, 0x22, 0xcf, 0xa5, 0xa2, 0x43, 0xc8, 0x18, 0x57, 0xb3, 0x92, 0x50, 0x4c, 0x31, 0x8b,
0x31, 0x8e, 0x9f, 0xa0, 0xb2, 0x08, 0x09, 0x8f, 0x43, 0xb0, 0x87, 0x6c, 0x4c, 0x3c, 0xaa, 0xe6,
0x24, 0x6d, 0x63, 0x8e, 0x77, 0x24, 0x8c, 0xf7, 0xd1, 0x9a, 0xb4, 0x45, 0x85, 0x86, 0xd2, 0x2c,
0xb6, 0x34, 0x7d, 0x6e, 0x3c, 0xf0, 0x91, 0x3e, 0x73, 0x50, 0x6f, 0x4b, 0x07, 0xdb, 0x82, 0xd9,
0xcd, 0x58, 0x89, 0x04, 0xf7, 0x51, 0x79, 0xc9, 0x79, 0x7b, 0x48, 0x38, 0x51, 0x2f, 0x64, 0x99,
0xc7, 0x77, 0x94, 0x39, 0x58, 0xd0, 0x3b, 0x84, 0x93, 0x6e, 0xc6, 0xda, 0x20, 0xb7, 0x21, 0xfc,
0x16, 0x6d, 0x11, 0xd7, 0x0d, 0xc1, 0x25, 0x1c, 0xec, 0xe5, 0xf2, 0x84, 0x0e, 0xed, 0x20, 0x64,
0xec, 0x42, 0x75, 0x65, 0x8f, 0xbd, 0xbb, 0x7a, 0xcc, 0xd4, 0x4b, 0xcd, 0x0e, 0xe8, 0xf0, 0x54,
0x48, 0xbb, 0x19, 0xab, 0x46, 0x7e, 0x93, 0xc7, 0xfb, 0x28, 0x0f, 0xd7, 0x1e, 0x57, 0x47, 0xb2,
0xc5, 0xf6, 0x1d, 0x2d, 0xce, 0x99, 0x1f, 0x53, 0x4e, 0xc2, 0xa9, 0x79, 0xed, 0xf1, 0x6e, 0xc6,
0x92, 0x1a, 0xbc, 0x89, 0xf2, 0x91, 0xcf, 0xb8, 0xea, 0x35, 0x94, 0x66, 0x5e, 0xa0, 0x22, 0xc2,
0x15, 0xb4, 0x06, 0x01, 0x73, 0x46, 0xea, 0x65, 0x0a, 0x27, 0x61, 0xfb, 0x7f, 0x54, 0x60, 0x83,
0x4b, 0x70, 0xb8, 0xf6, 0x59, 0x41, 0xa5, 0x64, 0xff, 0xe9, 0x33, 0xaa, 0xa1, 0xf5, 0xf9, 0x9a,
0x66, 0xfb, 0x9f, 0x03, 0xf8, 0x18, 0x15, 0xc4, 0xd4, 0x71, 0x24, 0x37, 0x7f, 0x7f, 0xd9, 0x87,
0x95, 0xb7, 0xa2, 0x2f, 0xd7, 0xd6, 0xfb, 0x52, 0x6a, 0xa5, 0x25, 0xb4, 0x17, 0xa8, 0x90, 0x20,
0xb8, 0x88, 0xfe, 0x3b, 0xeb, 0x1d, 0xf7, 0x5e, 0xbd, 0xee, 0x95, 0x33, 0xf8, 0x1e, 0x5a, 0xef,
0x9f, 0x1d, 0x1e, 0x9a, 0x66, 0xc7, 0xec, 0x94, 0x15, 0x8c, 0x50, 0xa1, 0x63, 0xf6, 0x8e, 0xcc,
0x4e, 0x39, 0x2b, 0x7e, 0xbf, 0x3c, 0x38, 0x3a, 0x31, 0x3b, 0xe5, 0x5c, 0xeb, 0x53, 0x16, 0x95,
0x2c, 0x18, 0x33, 0x0e, 0xa2, 0x07, 0x84, 0xf8, 0x83, 0x82, 0x54, 0x71, 0x1b, 0xe7, 0x2b, 0xde,
0x39, 0xae, 0xe8, 0xc9, 0x55, 0xe9, 0xb3, 0xab, 0xd2, 0x4d, 0x71, 0x55, 0xd5, 0xe7, 0x7f, 0xfa,
0x03, 0xab, 0xaf, 0x4d, 0xdb, 0x7e, 0xf7, 0xed, 0xc7, 0xc7, 0x6c, 0x1d, 0xd7, 0x6e, 0x7d, 0x4a,
0x42, 0x39, 0xcf, 0x1c, 0xc2, 0xef, 0x15, 0x94, 0x17, 0xd3, 0xe1, 0xa7, 0x7f, 0xe7, 0x93, 0xbc,
0xc1, 0xea, 0xce, 0xbf, 0x98, 0xaa, 0x35, 0xe4, 0x24, 0x55, 0x4d, 0x5d, 0x35, 0x89, 0xd8, 0x5c,
0xbb, 0xf4, 0xe5, 0xa6, 0xae, 0x7c, 0xbd, 0xa9, 0x2b, 0xdf, 0x6f, 0xea, 0xca, 0xa0, 0x20, 0x1d,
0xd8, 0xfb, 0x15, 0x00, 0x00, 0xff, 0xff, 0x8e, 0x70, 0x82, 0xe4, 0x14, 0x05, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// RemoteSignerClient is the client API for RemoteSigner service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RemoteSignerClient interface {
ListValidatingPublicKeys(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*ListPublicKeysResponse, error)
Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
}
type remoteSignerClient struct {
cc *grpc.ClientConn
}
func NewRemoteSignerClient(cc *grpc.ClientConn) RemoteSignerClient {
return &remoteSignerClient{cc}
}
func (c *remoteSignerClient) ListValidatingPublicKeys(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*ListPublicKeysResponse, error) {
out := new(ListPublicKeysResponse)
err := c.cc.Invoke(ctx, "/ethereum.validator.accounts.v2.RemoteSigner/ListValidatingPublicKeys", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *remoteSignerClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
out := new(SignResponse)
err := c.cc.Invoke(ctx, "/ethereum.validator.accounts.v2.RemoteSigner/Sign", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RemoteSignerServer is the server API for RemoteSigner service.
type RemoteSignerServer interface {
ListValidatingPublicKeys(context.Context, *types.Empty) (*ListPublicKeysResponse, error)
Sign(context.Context, *SignRequest) (*SignResponse, error)
}
// UnimplementedRemoteSignerServer can be embedded to have forward compatible implementations.
type UnimplementedRemoteSignerServer struct {
}
func (*UnimplementedRemoteSignerServer) ListValidatingPublicKeys(ctx context.Context, req *types.Empty) (*ListPublicKeysResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListValidatingPublicKeys not implemented")
}
func (*UnimplementedRemoteSignerServer) Sign(ctx context.Context, req *SignRequest) (*SignResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
}
func RegisterRemoteSignerServer(s *grpc.Server, srv RemoteSignerServer) {
s.RegisterService(&_RemoteSigner_serviceDesc, srv)
}
func _RemoteSigner_ListValidatingPublicKeys_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.(RemoteSignerServer).ListValidatingPublicKeys(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.validator.accounts.v2.RemoteSigner/ListValidatingPublicKeys",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RemoteSignerServer).ListValidatingPublicKeys(ctx, req.(*types.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _RemoteSigner_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SignRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RemoteSignerServer).Sign(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/ethereum.validator.accounts.v2.RemoteSigner/Sign",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RemoteSignerServer).Sign(ctx, req.(*SignRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RemoteSigner_serviceDesc = grpc.ServiceDesc{
ServiceName: "ethereum.validator.accounts.v2.RemoteSigner",
HandlerType: (*RemoteSignerServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ListValidatingPublicKeys",
Handler: _RemoteSigner_ListValidatingPublicKeys_Handler,
},
{
MethodName: "Sign",
Handler: _RemoteSigner_Sign_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "proto/validator/accounts/v2/keymanager.proto",
}
func (m *ListPublicKeysResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ListPublicKeysResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *ListPublicKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.ValidatingPublicKeys) > 0 {
for iNdEx := len(m.ValidatingPublicKeys) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.ValidatingPublicKeys[iNdEx])
copy(dAtA[i:], m.ValidatingPublicKeys[iNdEx])
i = encodeVarintKeymanager(dAtA, i, uint64(len(m.ValidatingPublicKeys[iNdEx])))
i--
dAtA[i] = 0x12
}
}
return len(dAtA) - i, nil
}
func (m *SignRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SignRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Object != nil {
{
size := m.Object.Size()
i -= size
if _, err := m.Object.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
}
}
if len(m.SignatureDomain) > 0 {
i -= len(m.SignatureDomain)
copy(dAtA[i:], m.SignatureDomain)
i = encodeVarintKeymanager(dAtA, i, uint64(len(m.SignatureDomain)))
i--
dAtA[i] = 0x1a
}
if len(m.SigningRoot) > 0 {
i -= len(m.SigningRoot)
copy(dAtA[i:], m.SigningRoot)
i = encodeVarintKeymanager(dAtA, i, uint64(len(m.SigningRoot)))
i--
dAtA[i] = 0x12
}
if len(m.PublicKey) > 0 {
i -= len(m.PublicKey)
copy(dAtA[i:], m.PublicKey)
i = encodeVarintKeymanager(dAtA, i, uint64(len(m.PublicKey)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *SignRequest_Block) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Block != nil {
{
size, err := m.Block.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintKeymanager(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xaa
}
return len(dAtA) - i, nil
}
func (m *SignRequest_AttestationData) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_AttestationData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.AttestationData != nil {
{
size, err := m.AttestationData.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintKeymanager(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xb2
}
return len(dAtA) - i, nil
}
func (m *SignRequest_AggregateAttestationAndProof) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_AggregateAttestationAndProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.AggregateAttestationAndProof != nil {
{
size, err := m.AggregateAttestationAndProof.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintKeymanager(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xba
}
return len(dAtA) - i, nil
}
func (m *SignRequest_Exit) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_Exit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Exit != nil {
{
size, err := m.Exit.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintKeymanager(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xc2
}
return len(dAtA) - i, nil
}
func (m *SignRequest_Slot) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_Slot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
i = encodeVarintKeymanager(dAtA, i, uint64(m.Slot))
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xc8
return len(dAtA) - i, nil
}
func (m *SignRequest_Epoch) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignRequest_Epoch) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
i = encodeVarintKeymanager(dAtA, i, uint64(m.Epoch))
i--
dAtA[i] = 0x6
i--
dAtA[i] = 0xd0
return len(dAtA) - i, nil
}
func (m *SignResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *SignResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SignResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Status != 0 {
i = encodeVarintKeymanager(dAtA, i, uint64(m.Status))
i--
dAtA[i] = 0x10
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintKeymanager(dAtA, i, uint64(len(m.Signature)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintKeymanager(dAtA []byte, offset int, v uint64) int {
offset -= sovKeymanager(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *ListPublicKeysResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.ValidatingPublicKeys) > 0 {
for _, b := range m.ValidatingPublicKeys {
l = len(b)
n += 1 + l + sovKeymanager(uint64(l))
}
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *SignRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.PublicKey)
if l > 0 {
n += 1 + l + sovKeymanager(uint64(l))
}
l = len(m.SigningRoot)
if l > 0 {
n += 1 + l + sovKeymanager(uint64(l))
}
l = len(m.SignatureDomain)
if l > 0 {
n += 1 + l + sovKeymanager(uint64(l))
}
if m.Object != nil {
n += m.Object.Size()
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *SignRequest_Block) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Block != nil {
l = m.Block.Size()
n += 2 + l + sovKeymanager(uint64(l))
}
return n
}
func (m *SignRequest_AttestationData) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.AttestationData != nil {
l = m.AttestationData.Size()
n += 2 + l + sovKeymanager(uint64(l))
}
return n
}
func (m *SignRequest_AggregateAttestationAndProof) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.AggregateAttestationAndProof != nil {
l = m.AggregateAttestationAndProof.Size()
n += 2 + l + sovKeymanager(uint64(l))
}
return n
}
func (m *SignRequest_Exit) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Exit != nil {
l = m.Exit.Size()
n += 2 + l + sovKeymanager(uint64(l))
}
return n
}
func (m *SignRequest_Slot) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 2 + sovKeymanager(uint64(m.Slot))
return n
}
func (m *SignRequest_Epoch) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 2 + sovKeymanager(uint64(m.Epoch))
return n
}
func (m *SignResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Signature)
if l > 0 {
n += 1 + l + sovKeymanager(uint64(l))
}
if m.Status != 0 {
n += 1 + sovKeymanager(uint64(m.Status))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovKeymanager(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozKeymanager(x uint64) (n int) {
return sovKeymanager(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ListPublicKeysResponse) 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 ErrIntOverflowKeymanager
}
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: ListPublicKeysResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ListPublicKeysResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidatingPublicKeys", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ValidatingPublicKeys = append(m.ValidatingPublicKeys, make([]byte, postIndex-iNdEx))
copy(m.ValidatingPublicKeys[len(m.ValidatingPublicKeys)-1], dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipKeymanager(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthKeymanager
}
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 *SignRequest) 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 ErrIntOverflowKeymanager
}
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: SignRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SignRequest: 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 ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
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 SigningRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SigningRoot = append(m.SigningRoot[:0], dAtA[iNdEx:postIndex]...)
if m.SigningRoot == nil {
m.SigningRoot = []byte{}
}
iNdEx = postIndex
case 3:
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 ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SignatureDomain = append(m.SignatureDomain[:0], dAtA[iNdEx:postIndex]...)
if m.SignatureDomain == nil {
m.SignatureDomain = []byte{}
}
iNdEx = postIndex
case 101:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &v1alpha1.BeaconBlock{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Object = &SignRequest_Block{v}
iNdEx = postIndex
case 102:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AttestationData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &v1alpha1.AttestationData{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Object = &SignRequest_AttestationData{v}
iNdEx = postIndex
case 103:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AggregateAttestationAndProof", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &v1alpha1.AggregateAttestationAndProof{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Object = &SignRequest_AggregateAttestationAndProof{v}
iNdEx = postIndex
case 104:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Exit", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &v1alpha1.VoluntaryExit{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
m.Object = &SignRequest_Exit{v}
iNdEx = postIndex
case 105:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Slot", wireType)
}
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Object = &SignRequest_Slot{v}
case 106:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
}
var v uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Object = &SignRequest_Epoch{v}
default:
iNdEx = preIndex
skippy, err := skipKeymanager(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthKeymanager
}
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 *SignResponse) 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 ErrIntOverflowKeymanager
}
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: SignResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SignResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKeymanager
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKeymanager
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
}
iNdEx = postIndex
case 2:
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 ErrIntOverflowKeymanager
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Status |= SignResponse_Status(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipKeymanager(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthKeymanager
}
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 skipKeymanager(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowKeymanager
}
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, ErrIntOverflowKeymanager
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowKeymanager
}
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, ErrInvalidLengthKeymanager
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupKeymanager
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthKeymanager
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthKeymanager = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowKeymanager = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupKeymanager = fmt.Errorf("proto: unexpected end of group")
)
Reference in New Issue View Git Blame Copy Permalink