keys.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: keys.proto

package keys

import (
	context "context"
	fmt "fmt"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	crypto "github.com/hyperledger/burrow/crypto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_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 ListRequest struct {
	KeyName              string   `protobuf:"bytes,1,opt,name=KeyName,proto3" json:"KeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListRequest proto.InternalMessageInfo

func (m *ListRequest) GetKeyName() string {
	if m != nil {
		return m.KeyName
	}
	return ""
}

func (*ListRequest) XXX_MessageName() string {
	return "keys.ListRequest"
}

type VerifyResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_VerifyResponse proto.InternalMessageInfo

func (*VerifyResponse) XXX_MessageName() string {
	return "keys.VerifyResponse"
}

type RemoveNameResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RemoveNameResponse proto.InternalMessageInfo

func (*RemoveNameResponse) XXX_MessageName() string {
	return "keys.RemoveNameResponse"
}

type AddNameResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AddNameResponse proto.InternalMessageInfo

func (*AddNameResponse) XXX_MessageName() string {
	return "keys.AddNameResponse"
}

type RemoveNameRequest struct {
	KeyName              string   `protobuf:"bytes,1,opt,name=KeyName,proto3" json:"KeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RemoveNameRequest proto.InternalMessageInfo

func (m *RemoveNameRequest) GetKeyName() string {
	if m != nil {
		return m.KeyName
	}
	return ""
}

func (*RemoveNameRequest) XXX_MessageName() string {
	return "keys.RemoveNameRequest"
}

type GenRequest struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=Passphrase,proto3" json:"Passphrase,omitempty"`
	CurveType            string   `protobuf:"bytes,2,opt,name=CurveType,proto3" json:"CurveType,omitempty"`
	KeyName              string   `protobuf:"bytes,3,opt,name=KeyName,proto3" json:"KeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GenRequest proto.InternalMessageInfo

func (m *GenRequest) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *GenRequest) GetCurveType() string {
	if m != nil {
		return m.CurveType
	}
	return ""
}

func (m *GenRequest) GetKeyName() string {
	if m != nil {
		return m.KeyName
	}
	return ""
}

func (*GenRequest) XXX_MessageName() string {
	return "keys.GenRequest"
}

type GenResponse struct {
	Address              string   `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GenResponse proto.InternalMessageInfo

func (m *GenResponse) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (*GenResponse) XXX_MessageName() string {
	return "keys.GenResponse"
}

type PubRequest struct {
	Address              string   `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PubRequest proto.InternalMessageInfo

func (m *PubRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *PubRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (*PubRequest) XXX_MessageName() string {
	return "keys.PubRequest"
}

type PubResponse struct {
	PublicKey            []byte   `protobuf:"bytes,1,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
	CurveType            string   `protobuf:"bytes,2,opt,name=CurveType,proto3" json:"CurveType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PubResponse proto.InternalMessageInfo

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

func (m *PubResponse) GetCurveType() string {
	if m != nil {
		return m.CurveType
	}
	return ""
}

func (*PubResponse) XXX_MessageName() string {
	return "keys.PubResponse"
}

type ImportJSONRequest struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=Passphrase,proto3" json:"Passphrase,omitempty"`
	JSON                 string   `protobuf:"bytes,2,opt,name=JSON,proto3" json:"JSON,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ImportJSONRequest proto.InternalMessageInfo

func (m *ImportJSONRequest) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *ImportJSONRequest) GetJSON() string {
	if m != nil {
		return m.JSON
	}
	return ""
}

func (*ImportJSONRequest) XXX_MessageName() string {
	return "keys.ImportJSONRequest"
}

type ImportResponse struct {
	Address              string   `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ImportResponse proto.InternalMessageInfo

func (m *ImportResponse) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (*ImportResponse) XXX_MessageName() string {
	return "keys.ImportResponse"
}

type ImportRequest struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=Passphrase,proto3" json:"Passphrase,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	CurveType            string   `protobuf:"bytes,3,opt,name=CurveType,proto3" json:"CurveType,omitempty"`
	KeyBytes             []byte   `protobuf:"bytes,4,opt,name=KeyBytes,proto3" json:"KeyBytes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ImportRequest proto.InternalMessageInfo

func (m *ImportRequest) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *ImportRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ImportRequest) GetCurveType() string {
	if m != nil {
		return m.CurveType
	}
	return ""
}

func (m *ImportRequest) GetKeyBytes() []byte {
	if m != nil {
		return m.KeyBytes
	}
	return nil
}

func (*ImportRequest) XXX_MessageName() string {
	return "keys.ImportRequest"
}

type ExportRequest struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=Passphrase,proto3" json:"Passphrase,omitempty"`
	Name                 string   `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	Address              string   `protobuf:"bytes,3,opt,name=Address,proto3" json:"Address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ExportRequest proto.InternalMessageInfo

func (m *ExportRequest) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *ExportRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ExportRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (*ExportRequest) XXX_MessageName() string {
	return "keys.ExportRequest"
}

type ExportResponse struct {
	Publickey            []byte   `protobuf:"bytes,1,opt,name=Publickey,proto3" json:"Publickey,omitempty"`
	Privatekey           []byte   `protobuf:"bytes,2,opt,name=Privatekey,proto3" json:"Privatekey,omitempty"`
	Address              []byte   `protobuf:"bytes,3,opt,name=Address,proto3" json:"Address,omitempty"`
	CurveType            string   `protobuf:"bytes,4,opt,name=CurveType,proto3" json:"CurveType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ExportResponse proto.InternalMessageInfo

func (m *ExportResponse) GetPublickey() []byte {
	if m != nil {
		return m.Publickey
	}
	return nil
}

func (m *ExportResponse) GetPrivatekey() []byte {
	if m != nil {
		return m.Privatekey
	}
	return nil
}

func (m *ExportResponse) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *ExportResponse) GetCurveType() string {
	if m != nil {
		return m.CurveType
	}
	return ""
}

func (*ExportResponse) XXX_MessageName() string {
	return "keys.ExportResponse"
}

type SignRequest struct {
	Passphrase           string   `protobuf:"bytes,1,opt,name=Passphrase,proto3" json:"Passphrase,omitempty"`
	Address              string   `protobuf:"bytes,2,opt,name=Address,proto3" json:"Address,omitempty"`
	Name                 string   `protobuf:"bytes,3,opt,name=Name,proto3" json:"Name,omitempty"`
	Message              []byte   `protobuf:"bytes,4,opt,name=Message,proto3" json:"Message,omitempty"`
	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_9084e97af2346a26, []int{14}
}
func (m *SignRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SignRequest.Unmarshal(m, b)
}
func (m *SignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SignRequest.Marshal(b, m, deterministic)
}
func (m *SignRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignRequest.Merge(m, src)
}
func (m *SignRequest) XXX_Size() int {
	return xxx_messageInfo_SignRequest.Size(m)
}
func (m *SignRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SignRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SignRequest proto.InternalMessageInfo

func (m *SignRequest) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

func (m *SignRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *SignRequest) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SignRequest) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (*SignRequest) XXX_MessageName() string {
	return "keys.SignRequest"
}

type SignResponse struct {
	Signature            *crypto.Signature `protobuf:"bytes,3,opt,name=Signature,proto3" json:"Signature,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_9084e97af2346a26, []int{15}
}
func (m *SignResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SignResponse.Unmarshal(m, b)
}
func (m *SignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SignResponse.Marshal(b, m, deterministic)
}
func (m *SignResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignResponse.Merge(m, src)
}
func (m *SignResponse) XXX_Size() int {
	return xxx_messageInfo_SignResponse.Size(m)
}
func (m *SignResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SignResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SignResponse proto.InternalMessageInfo

func (m *SignResponse) GetSignature() *crypto.Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (*SignResponse) XXX_MessageName() string {
	return "keys.SignResponse"
}

type VerifyRequest struct {
	PublicKey            []byte            `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
	Message              []byte            `protobuf:"bytes,3,opt,name=Message,proto3" json:"Message,omitempty"`
	Signature            *crypto.Signature `protobuf:"bytes,5,opt,name=Signature,proto3" json:"Signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_VerifyRequest proto.InternalMessageInfo

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

func (m *VerifyRequest) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *VerifyRequest) GetSignature() *crypto.Signature {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (*VerifyRequest) XXX_MessageName() string {
	return "keys.VerifyRequest"
}

type HashRequest struct {
	Hashtype             string   `protobuf:"bytes,1,opt,name=Hashtype,proto3" json:"Hashtype,omitempty"`
	Message              []byte   `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HashRequest proto.InternalMessageInfo

func (m *HashRequest) GetHashtype() string {
	if m != nil {
		return m.Hashtype
	}
	return ""
}

func (m *HashRequest) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (*HashRequest) XXX_MessageName() string {
	return "keys.HashRequest"
}

type HashResponse struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=Hash,proto3" json:"Hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HashResponse proto.InternalMessageInfo

func (m *HashResponse) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (*HashResponse) XXX_MessageName() string {
	return "keys.HashResponse"
}

type KeyID struct {
	Address              string   `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
	KeyName              []string `protobuf:"bytes,2,rep,name=KeyName,proto3" json:"KeyName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_KeyID proto.InternalMessageInfo

func (m *KeyID) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *KeyID) GetKeyName() []string {
	if m != nil {
		return m.KeyName
	}
	return nil
}

func (*KeyID) XXX_MessageName() string {
	return "keys.KeyID"
}

type ListResponse struct {
	Key                  []*KeyID `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListResponse proto.InternalMessageInfo

func (m *ListResponse) GetKey() []*KeyID {
	if m != nil {
		return m.Key
	}
	return nil
}

func (*ListResponse) XXX_MessageName() string {
	return "keys.ListResponse"
}

type AddNameRequest struct {
	Keyname              string   `protobuf:"bytes,1,opt,name=Keyname,proto3" json:"Keyname,omitempty"`
	Address              string   `protobuf:"bytes,2,opt,name=Address,proto3" json:"Address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AddNameRequest proto.InternalMessageInfo

func (m *AddNameRequest) GetKeyname() string {
	if m != nil {
		return m.Keyname
	}
	return ""
}

func (m *AddNameRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (*AddNameRequest) XXX_MessageName() string {
	return "keys.AddNameRequest"
}
func init() {
	proto.RegisterType((*ListRequest)(nil), "keys.ListRequest")
	golang_proto.RegisterType((*ListRequest)(nil), "keys.ListRequest")
	proto.RegisterType((*VerifyResponse)(nil), "keys.VerifyResponse")
	golang_proto.RegisterType((*VerifyResponse)(nil), "keys.VerifyResponse")
	proto.RegisterType((*RemoveNameResponse)(nil), "keys.RemoveNameResponse")
	golang_proto.RegisterType((*RemoveNameResponse)(nil), "keys.RemoveNameResponse")
	proto.RegisterType((*AddNameResponse)(nil), "keys.AddNameResponse")
	golang_proto.RegisterType((*AddNameResponse)(nil), "keys.AddNameResponse")
	proto.RegisterType((*RemoveNameRequest)(nil), "keys.RemoveNameRequest")
	golang_proto.RegisterType((*RemoveNameRequest)(nil), "keys.RemoveNameRequest")
	proto.RegisterType((*GenRequest)(nil), "keys.GenRequest")
	golang_proto.RegisterType((*GenRequest)(nil), "keys.GenRequest")
	proto.RegisterType((*GenResponse)(nil), "keys.GenResponse")
	golang_proto.RegisterType((*GenResponse)(nil), "keys.GenResponse")
	proto.RegisterType((*PubRequest)(nil), "keys.PubRequest")
	golang_proto.RegisterType((*PubRequest)(nil), "keys.PubRequest")
	proto.RegisterType((*PubResponse)(nil), "keys.PubResponse")
	golang_proto.RegisterType((*PubResponse)(nil), "keys.PubResponse")
	proto.RegisterType((*ImportJSONRequest)(nil), "keys.ImportJSONRequest")
	golang_proto.RegisterType((*ImportJSONRequest)(nil), "keys.ImportJSONRequest")
	proto.RegisterType((*ImportResponse)(nil), "keys.ImportResponse")
	golang_proto.RegisterType((*ImportResponse)(nil), "keys.ImportResponse")
	proto.RegisterType((*ImportRequest)(nil), "keys.ImportRequest")
	golang_proto.RegisterType((*ImportRequest)(nil), "keys.ImportRequest")
	proto.RegisterType((*ExportRequest)(nil), "keys.ExportRequest")
	golang_proto.RegisterType((*ExportRequest)(nil), "keys.ExportRequest")
	proto.RegisterType((*ExportResponse)(nil), "keys.ExportResponse")
	golang_proto.RegisterType((*ExportResponse)(nil), "keys.ExportResponse")
	proto.RegisterType((*SignRequest)(nil), "keys.SignRequest")
	golang_proto.RegisterType((*SignRequest)(nil), "keys.SignRequest")
	proto.RegisterType((*SignResponse)(nil), "keys.SignResponse")
	golang_proto.RegisterType((*SignResponse)(nil), "keys.SignResponse")
	proto.RegisterType((*VerifyRequest)(nil), "keys.VerifyRequest")
	golang_proto.RegisterType((*VerifyRequest)(nil), "keys.VerifyRequest")
	proto.RegisterType((*HashRequest)(nil), "keys.HashRequest")
	golang_proto.RegisterType((*HashRequest)(nil), "keys.HashRequest")
	proto.RegisterType((*HashResponse)(nil), "keys.HashResponse")
	golang_proto.RegisterType((*HashResponse)(nil), "keys.HashResponse")
	proto.RegisterType((*KeyID)(nil), "keys.KeyID")
	golang_proto.RegisterType((*KeyID)(nil), "keys.KeyID")
	proto.RegisterType((*ListResponse)(nil), "keys.ListResponse")
	golang_proto.RegisterType((*ListResponse)(nil), "keys.ListResponse")
	proto.RegisterType((*AddNameRequest)(nil), "keys.AddNameRequest")
	golang_proto.RegisterType((*AddNameRequest)(nil), "keys.AddNameRequest")
}

func init() { proto.RegisterFile("keys.proto", fileDescriptor_9084e97af2346a26) }
func init() { golang_proto.RegisterFile("keys.proto", fileDescriptor_9084e97af2346a26) }

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

// KeysClient is the client API for Keys service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KeysClient interface {
	GenerateKey(ctx context.Context, in *GenRequest, opts ...grpc.CallOption) (*GenResponse, error)
	PublicKey(ctx context.Context, in *PubRequest, opts ...grpc.CallOption) (*PubResponse, error)
	Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
	Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error)
	Import(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*ImportResponse, error)
	ImportJSON(ctx context.Context, in *ImportJSONRequest, opts ...grpc.CallOption) (*ImportResponse, error)
	Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (*ExportResponse, error)
	Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error)
	RemoveName(ctx context.Context, in *RemoveNameRequest, opts ...grpc.CallOption) (*RemoveNameResponse, error)
	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
	AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*AddNameResponse, error)
}

type keysClient struct {
	cc *grpc.ClientConn
}

func NewKeysClient(cc *grpc.ClientConn) KeysClient {
	return &keysClient{cc}
}

func (c *keysClient) GenerateKey(ctx context.Context, in *GenRequest, opts ...grpc.CallOption) (*GenResponse, error) {
	out := new(GenResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/GenerateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) PublicKey(ctx context.Context, in *PubRequest, opts ...grpc.CallOption) (*PubResponse, error) {
	out := new(PubResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/PublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
	out := new(SignResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/Sign", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) {
	out := new(VerifyResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/Verify", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) Import(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*ImportResponse, error) {
	out := new(ImportResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/Import", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) ImportJSON(ctx context.Context, in *ImportJSONRequest, opts ...grpc.CallOption) (*ImportResponse, error) {
	out := new(ImportResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/ImportJSON", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (*ExportResponse, error) {
	out := new(ExportResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/Export", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) {
	out := new(HashResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/Hash", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) RemoveName(ctx context.Context, in *RemoveNameRequest, opts ...grpc.CallOption) (*RemoveNameResponse, error) {
	out := new(RemoveNameResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/RemoveName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
	out := new(ListResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keysClient) AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*AddNameResponse, error) {
	out := new(AddNameResponse)
	err := c.cc.Invoke(ctx, "/keys.Keys/AddName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// KeysServer is the server API for Keys service.
type KeysServer interface {
	GenerateKey(context.Context, *GenRequest) (*GenResponse, error)
	PublicKey(context.Context, *PubRequest) (*PubResponse, error)
	Sign(context.Context, *SignRequest) (*SignResponse, error)
	Verify(context.Context, *VerifyRequest) (*VerifyResponse, error)
	Import(context.Context, *ImportRequest) (*ImportResponse, error)
	ImportJSON(context.Context, *ImportJSONRequest) (*ImportResponse, error)
	Export(context.Context, *ExportRequest) (*ExportResponse, error)
	Hash(context.Context, *HashRequest) (*HashResponse, error)
	RemoveName(context.Context, *RemoveNameRequest) (*RemoveNameResponse, error)
	List(context.Context, *ListRequest) (*ListResponse, error)
	AddName(context.Context, *AddNameRequest) (*AddNameResponse, error)
}

// UnimplementedKeysServer can be embedded to have forward compatible implementations.
type UnimplementedKeysServer struct {
}

func (*UnimplementedKeysServer) GenerateKey(ctx context.Context, req *GenRequest) (*GenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateKey not implemented")
}
func (*UnimplementedKeysServer) PublicKey(ctx context.Context, req *PubRequest) (*PubResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicKey not implemented")
}
func (*UnimplementedKeysServer) Sign(ctx context.Context, req *SignRequest) (*SignResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
}
func (*UnimplementedKeysServer) Verify(ctx context.Context, req *VerifyRequest) (*VerifyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Verify not implemented")
}
func (*UnimplementedKeysServer) Import(ctx context.Context, req *ImportRequest) (*ImportResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Import not implemented")
}
func (*UnimplementedKeysServer) ImportJSON(ctx context.Context, req *ImportJSONRequest) (*ImportResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportJSON not implemented")
}
func (*UnimplementedKeysServer) Export(ctx context.Context, req *ExportRequest) (*ExportResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Export not implemented")
}
func (*UnimplementedKeysServer) Hash(ctx context.Context, req *HashRequest) (*HashResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Hash not implemented")
}
func (*UnimplementedKeysServer) RemoveName(ctx context.Context, req *RemoveNameRequest) (*RemoveNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveName not implemented")
}
func (*UnimplementedKeysServer) List(ctx context.Context, req *ListRequest) (*ListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (*UnimplementedKeysServer) AddName(ctx context.Context, req *AddNameRequest) (*AddNameResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddName not implemented")
}

func RegisterKeysServer(s *grpc.Server, srv KeysServer) {
	s.RegisterService(&_Keys_serviceDesc, srv)
}

func _Keys_GenerateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).GenerateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/GenerateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).GenerateKey(ctx, req.(*GenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_PublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PubRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).PublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/PublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).PublicKey(ctx, req.(*PubRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_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.(KeysServer).Sign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/Sign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).Sign(ctx, req.(*SignRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_Verify_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).Verify(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/Verify",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).Verify(ctx, req.(*VerifyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_Import_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).Import(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/Import",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).Import(ctx, req.(*ImportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_ImportJSON_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportJSONRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).ImportJSON(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/ImportJSON",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).ImportJSON(ctx, req.(*ImportJSONRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_Export_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).Export(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/Export",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).Export(ctx, req.(*ExportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_Hash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HashRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).Hash(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/Hash",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).Hash(ctx, req.(*HashRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_RemoveName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).RemoveName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/RemoveName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).RemoveName(ctx, req.(*RemoveNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).List(ctx, req.(*ListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Keys_AddName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddNameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeysServer).AddName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/keys.Keys/AddName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeysServer).AddName(ctx, req.(*AddNameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Keys_serviceDesc = grpc.ServiceDesc{
	ServiceName: "keys.Keys",
	HandlerType: (*KeysServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenerateKey",
			Handler:    _Keys_GenerateKey_Handler,
		},
		{
			MethodName: "PublicKey",
			Handler:    _Keys_PublicKey_Handler,
		},
		{
			MethodName: "Sign",
			Handler:    _Keys_Sign_Handler,
		},
		{
			MethodName: "Verify",
			Handler:    _Keys_Verify_Handler,
		},
		{
			MethodName: "Import",
			Handler:    _Keys_Import_Handler,
		},
		{
			MethodName: "ImportJSON",
			Handler:    _Keys_ImportJSON_Handler,
		},
		{
			MethodName: "Export",
			Handler:    _Keys_Export_Handler,
		},
		{
			MethodName: "Hash",
			Handler:    _Keys_Hash_Handler,
		},
		{
			MethodName: "RemoveName",
			Handler:    _Keys_RemoveName_Handler,
		},
		{
			MethodName: "List",
			Handler:    _Keys_List_Handler,
		},
		{
			MethodName: "AddName",
			Handler:    _Keys_AddName_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "keys.proto",
}

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

func (m *VerifyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RemoveNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AddNameResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *GenRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Passphrase)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.CurveType)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.KeyName)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *PubRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ImportJSONRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Passphrase)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.JSON)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ImportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Passphrase)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.CurveType)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.KeyBytes)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExportRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Passphrase)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExportResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Publickey)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Privatekey)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.CurveType)
	if l > 0 {
		n += 1 + l + sovKeys(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.Passphrase)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *HashRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hashtype)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *KeyID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if len(m.KeyName) > 0 {
		for _, s := range m.KeyName {
			l = len(s)
			n += 1 + l + sovKeys(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *AddNameRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Keyname)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovKeys(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovKeys(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozKeys(x uint64) (n int) {
	return sovKeys(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}