control.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: drand/control.proto

package drand

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

// SetupInfoPacket contains all information necessary to run an "automatic"
// setup phase where the designated leader acts as a coordinator as to what is
// the group file and when does the chain starts.
type SetupInfoPacket struct {
	Leader bool `protobuf:"varint,1,opt,name=leader,proto3" json:"leader,omitempty"`
	// LeaderAddress is only used by non-leader
	LeaderAddress string `protobuf:"bytes,2,opt,name=leader_address,json=leaderAddress,proto3" json:"leader_address,omitempty"`
	// LeaderTls is only used by non-leader
	LeaderTls bool   `protobuf:"varint,3,opt,name=leader_tls,json=leaderTls,proto3" json:"leader_tls,omitempty"`
	Nodes     uint32 `protobuf:"varint,4,opt,name=nodes,proto3" json:"nodes,omitempty"`
	Threshold uint32 `protobuf:"varint,5,opt,name=threshold,proto3" json:"threshold,omitempty"`
	// timeout of the dkg
	// timeout as parsed by Golang's time.ParseDuration method.
	Timeout              string   `protobuf:"bytes,6,opt,name=timeout,proto3" json:"timeout,omitempty"`
	Secret               string   `protobuf:"bytes,7,opt,name=secret,proto3" json:"secret,omitempty"`
	BeaconOffset         uint32   `protobuf:"varint,8,opt,name=beaconOffset,proto3" json:"beaconOffset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetupInfoPacket) Reset()         { *m = SetupInfoPacket{} }
func (m *SetupInfoPacket) String() string { return proto.CompactTextString(m) }
func (*SetupInfoPacket) ProtoMessage()    {}
func (*SetupInfoPacket) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{0}
}

func (m *SetupInfoPacket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetupInfoPacket.Unmarshal(m, b)
}
func (m *SetupInfoPacket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetupInfoPacket.Marshal(b, m, deterministic)
}
func (m *SetupInfoPacket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetupInfoPacket.Merge(m, src)
}
func (m *SetupInfoPacket) XXX_Size() int {
	return xxx_messageInfo_SetupInfoPacket.Size(m)
}
func (m *SetupInfoPacket) XXX_DiscardUnknown() {
	xxx_messageInfo_SetupInfoPacket.DiscardUnknown(m)
}

var xxx_messageInfo_SetupInfoPacket proto.InternalMessageInfo

func (m *SetupInfoPacket) GetLeader() bool {
	if m != nil {
		return m.Leader
	}
	return false
}

func (m *SetupInfoPacket) GetLeaderAddress() string {
	if m != nil {
		return m.LeaderAddress
	}
	return ""
}

func (m *SetupInfoPacket) GetLeaderTls() bool {
	if m != nil {
		return m.LeaderTls
	}
	return false
}

func (m *SetupInfoPacket) GetNodes() uint32 {
	if m != nil {
		return m.Nodes
	}
	return 0
}

func (m *SetupInfoPacket) GetThreshold() uint32 {
	if m != nil {
		return m.Threshold
	}
	return 0
}

func (m *SetupInfoPacket) GetTimeout() string {
	if m != nil {
		return m.Timeout
	}
	return ""
}

func (m *SetupInfoPacket) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

func (m *SetupInfoPacket) GetBeaconOffset() uint32 {
	if m != nil {
		return m.BeaconOffset
	}
	return 0
}

type InitDKGPacket struct {
	Info    *SetupInfoPacket `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	Entropy *EntropyInfo     `protobuf:"bytes,2,opt,name=entropy,proto3" json:"entropy,omitempty"`
	// the period time of the beacon;
	// used only in a fresh dkg
	BeaconPeriod         uint32   `protobuf:"varint,3,opt,name=beacon_period,json=beaconPeriod,proto3" json:"beacon_period,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *InitDKGPacket) Reset()         { *m = InitDKGPacket{} }
func (m *InitDKGPacket) String() string { return proto.CompactTextString(m) }
func (*InitDKGPacket) ProtoMessage()    {}
func (*InitDKGPacket) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{1}
}

func (m *InitDKGPacket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InitDKGPacket.Unmarshal(m, b)
}
func (m *InitDKGPacket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InitDKGPacket.Marshal(b, m, deterministic)
}
func (m *InitDKGPacket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InitDKGPacket.Merge(m, src)
}
func (m *InitDKGPacket) XXX_Size() int {
	return xxx_messageInfo_InitDKGPacket.Size(m)
}
func (m *InitDKGPacket) XXX_DiscardUnknown() {
	xxx_messageInfo_InitDKGPacket.DiscardUnknown(m)
}

var xxx_messageInfo_InitDKGPacket proto.InternalMessageInfo

func (m *InitDKGPacket) GetInfo() *SetupInfoPacket {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *InitDKGPacket) GetEntropy() *EntropyInfo {
	if m != nil {
		return m.Entropy
	}
	return nil
}

func (m *InitDKGPacket) GetBeaconPeriod() uint32 {
	if m != nil {
		return m.BeaconPeriod
	}
	return 0
}

// EntropyInfo contains information about external entropy sources
// can be optional
type EntropyInfo struct {
	Script string `protobuf:"bytes,1,opt,name=script,proto3" json:"script,omitempty"`
	// do we only take this entropy source or mix it with /dev/urandom
	UserOnly             bool     `protobuf:"varint,10,opt,name=userOnly,proto3" json:"userOnly,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EntropyInfo) Reset()         { *m = EntropyInfo{} }
func (m *EntropyInfo) String() string { return proto.CompactTextString(m) }
func (*EntropyInfo) ProtoMessage()    {}
func (*EntropyInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{2}
}

func (m *EntropyInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_EntropyInfo.Unmarshal(m, b)
}
func (m *EntropyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_EntropyInfo.Marshal(b, m, deterministic)
}
func (m *EntropyInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EntropyInfo.Merge(m, src)
}
func (m *EntropyInfo) XXX_Size() int {
	return xxx_messageInfo_EntropyInfo.Size(m)
}
func (m *EntropyInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_EntropyInfo.DiscardUnknown(m)
}

var xxx_messageInfo_EntropyInfo proto.InternalMessageInfo

func (m *EntropyInfo) GetScript() string {
	if m != nil {
		return m.Script
	}
	return ""
}

func (m *EntropyInfo) GetUserOnly() bool {
	if m != nil {
		return m.UserOnly
	}
	return false
}

// ReshareRequest contains references to the old and new group to perform the
// resharing protocol.
type InitResharePacket struct {
	// Old group that needs to issue the shares for the new group
	// NOTE: It can be empty / nil. In that case, the drand node will try to
	// load the group he belongs to at the moment, if any, and use it as the old
	// group.
	Old                  *GroupInfo       `protobuf:"bytes,1,opt,name=old,proto3" json:"old,omitempty"`
	Info                 *SetupInfoPacket `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *InitResharePacket) Reset()         { *m = InitResharePacket{} }
func (m *InitResharePacket) String() string { return proto.CompactTextString(m) }
func (*InitResharePacket) ProtoMessage()    {}
func (*InitResharePacket) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{3}
}

func (m *InitResharePacket) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InitResharePacket.Unmarshal(m, b)
}
func (m *InitResharePacket) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InitResharePacket.Marshal(b, m, deterministic)
}
func (m *InitResharePacket) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InitResharePacket.Merge(m, src)
}
func (m *InitResharePacket) XXX_Size() int {
	return xxx_messageInfo_InitResharePacket.Size(m)
}
func (m *InitResharePacket) XXX_DiscardUnknown() {
	xxx_messageInfo_InitResharePacket.DiscardUnknown(m)
}

var xxx_messageInfo_InitResharePacket proto.InternalMessageInfo

func (m *InitResharePacket) GetOld() *GroupInfo {
	if m != nil {
		return m.Old
	}
	return nil
}

func (m *InitResharePacket) GetInfo() *SetupInfoPacket {
	if m != nil {
		return m.Info
	}
	return nil
}

type GroupInfo struct {
	// Types that are valid to be assigned to Location:
	//	*GroupInfo_Path
	//	*GroupInfo_Url
	Location             isGroupInfo_Location `protobuf_oneof:"location"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *GroupInfo) Reset()         { *m = GroupInfo{} }
func (m *GroupInfo) String() string { return proto.CompactTextString(m) }
func (*GroupInfo) ProtoMessage()    {}
func (*GroupInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{4}
}

func (m *GroupInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupInfo.Unmarshal(m, b)
}
func (m *GroupInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupInfo.Marshal(b, m, deterministic)
}
func (m *GroupInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupInfo.Merge(m, src)
}
func (m *GroupInfo) XXX_Size() int {
	return xxx_messageInfo_GroupInfo.Size(m)
}
func (m *GroupInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupInfo.DiscardUnknown(m)
}

var xxx_messageInfo_GroupInfo proto.InternalMessageInfo

type isGroupInfo_Location interface {
	isGroupInfo_Location()
}

type GroupInfo_Path struct {
	Path string `protobuf:"bytes,1,opt,name=path,proto3,oneof"`
}

type GroupInfo_Url struct {
	Url string `protobuf:"bytes,2,opt,name=url,proto3,oneof"`
}

func (*GroupInfo_Path) isGroupInfo_Location() {}

func (*GroupInfo_Url) isGroupInfo_Location() {}

func (m *GroupInfo) GetLocation() isGroupInfo_Location {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *GroupInfo) GetPath() string {
	if x, ok := m.GetLocation().(*GroupInfo_Path); ok {
		return x.Path
	}
	return ""
}

func (m *GroupInfo) GetUrl() string {
	if x, ok := m.GetLocation().(*GroupInfo_Url); ok {
		return x.Url
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GroupInfo) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GroupInfo_Path)(nil),
		(*GroupInfo_Url)(nil),
	}
}

// ShareRequest requests the private share of a drand node
type ShareRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShareRequest) Reset()         { *m = ShareRequest{} }
func (m *ShareRequest) String() string { return proto.CompactTextString(m) }
func (*ShareRequest) ProtoMessage()    {}
func (*ShareRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{5}
}

func (m *ShareRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShareRequest.Unmarshal(m, b)
}
func (m *ShareRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShareRequest.Marshal(b, m, deterministic)
}
func (m *ShareRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShareRequest.Merge(m, src)
}
func (m *ShareRequest) XXX_Size() int {
	return xxx_messageInfo_ShareRequest.Size(m)
}
func (m *ShareRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ShareRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ShareRequest proto.InternalMessageInfo

// ShareResponse holds the private share of a drand node
type ShareResponse struct {
	Index                uint32   `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Share                []byte   `protobuf:"bytes,3,opt,name=share,proto3" json:"share,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ShareResponse) Reset()         { *m = ShareResponse{} }
func (m *ShareResponse) String() string { return proto.CompactTextString(m) }
func (*ShareResponse) ProtoMessage()    {}
func (*ShareResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{6}
}

func (m *ShareResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShareResponse.Unmarshal(m, b)
}
func (m *ShareResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShareResponse.Marshal(b, m, deterministic)
}
func (m *ShareResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShareResponse.Merge(m, src)
}
func (m *ShareResponse) XXX_Size() int {
	return xxx_messageInfo_ShareResponse.Size(m)
}
func (m *ShareResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShareResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShareResponse proto.InternalMessageInfo

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

func (m *ShareResponse) GetShare() []byte {
	if m != nil {
		return m.Share
	}
	return nil
}

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

func (m *Ping) Reset()         { *m = Ping{} }
func (m *Ping) String() string { return proto.CompactTextString(m) }
func (*Ping) ProtoMessage()    {}
func (*Ping) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{7}
}

func (m *Ping) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Ping.Unmarshal(m, b)
}
func (m *Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Ping.Marshal(b, m, deterministic)
}
func (m *Ping) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Ping.Merge(m, src)
}
func (m *Ping) XXX_Size() int {
	return xxx_messageInfo_Ping.Size(m)
}
func (m *Ping) XXX_DiscardUnknown() {
	xxx_messageInfo_Ping.DiscardUnknown(m)
}

var xxx_messageInfo_Ping proto.InternalMessageInfo

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

func (m *Pong) Reset()         { *m = Pong{} }
func (m *Pong) String() string { return proto.CompactTextString(m) }
func (*Pong) ProtoMessage()    {}
func (*Pong) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{8}
}

func (m *Pong) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Pong.Unmarshal(m, b)
}
func (m *Pong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Pong.Marshal(b, m, deterministic)
}
func (m *Pong) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pong.Merge(m, src)
}
func (m *Pong) XXX_Size() int {
	return xxx_messageInfo_Pong.Size(m)
}
func (m *Pong) XXX_DiscardUnknown() {
	xxx_messageInfo_Pong.DiscardUnknown(m)
}

var xxx_messageInfo_Pong proto.InternalMessageInfo

// PublicKeyRequest requests the public key of a drand node
type PublicKeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublicKeyRequest) Reset()         { *m = PublicKeyRequest{} }
func (m *PublicKeyRequest) String() string { return proto.CompactTextString(m) }
func (*PublicKeyRequest) ProtoMessage()    {}
func (*PublicKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{9}
}

func (m *PublicKeyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublicKeyRequest.Unmarshal(m, b)
}
func (m *PublicKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublicKeyRequest.Marshal(b, m, deterministic)
}
func (m *PublicKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublicKeyRequest.Merge(m, src)
}
func (m *PublicKeyRequest) XXX_Size() int {
	return xxx_messageInfo_PublicKeyRequest.Size(m)
}
func (m *PublicKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PublicKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PublicKeyRequest proto.InternalMessageInfo

// PublicKeyResponse holds the public key of a drand node
type PublicKeyResponse struct {
	PubKey               []byte   `protobuf:"bytes,2,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublicKeyResponse) Reset()         { *m = PublicKeyResponse{} }
func (m *PublicKeyResponse) String() string { return proto.CompactTextString(m) }
func (*PublicKeyResponse) ProtoMessage()    {}
func (*PublicKeyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{10}
}

func (m *PublicKeyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublicKeyResponse.Unmarshal(m, b)
}
func (m *PublicKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublicKeyResponse.Marshal(b, m, deterministic)
}
func (m *PublicKeyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublicKeyResponse.Merge(m, src)
}
func (m *PublicKeyResponse) XXX_Size() int {
	return xxx_messageInfo_PublicKeyResponse.Size(m)
}
func (m *PublicKeyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PublicKeyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PublicKeyResponse proto.InternalMessageInfo

func (m *PublicKeyResponse) GetPubKey() []byte {
	if m != nil {
		return m.PubKey
	}
	return nil
}

// PrivateKeyRequest requests the private key of a drand node
type PrivateKeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivateKeyRequest) Reset()         { *m = PrivateKeyRequest{} }
func (m *PrivateKeyRequest) String() string { return proto.CompactTextString(m) }
func (*PrivateKeyRequest) ProtoMessage()    {}
func (*PrivateKeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{11}
}

func (m *PrivateKeyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrivateKeyRequest.Unmarshal(m, b)
}
func (m *PrivateKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrivateKeyRequest.Marshal(b, m, deterministic)
}
func (m *PrivateKeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrivateKeyRequest.Merge(m, src)
}
func (m *PrivateKeyRequest) XXX_Size() int {
	return xxx_messageInfo_PrivateKeyRequest.Size(m)
}
func (m *PrivateKeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PrivateKeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PrivateKeyRequest proto.InternalMessageInfo

// PrivateKeyResponse holds the private key of a drand node
type PrivateKeyResponse struct {
	PriKey               []byte   `protobuf:"bytes,2,opt,name=priKey,proto3" json:"priKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivateKeyResponse) Reset()         { *m = PrivateKeyResponse{} }
func (m *PrivateKeyResponse) String() string { return proto.CompactTextString(m) }
func (*PrivateKeyResponse) ProtoMessage()    {}
func (*PrivateKeyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{12}
}

func (m *PrivateKeyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrivateKeyResponse.Unmarshal(m, b)
}
func (m *PrivateKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrivateKeyResponse.Marshal(b, m, deterministic)
}
func (m *PrivateKeyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrivateKeyResponse.Merge(m, src)
}
func (m *PrivateKeyResponse) XXX_Size() int {
	return xxx_messageInfo_PrivateKeyResponse.Size(m)
}
func (m *PrivateKeyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PrivateKeyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PrivateKeyResponse proto.InternalMessageInfo

func (m *PrivateKeyResponse) GetPriKey() []byte {
	if m != nil {
		return m.PriKey
	}
	return nil
}

// CokeyRequest requests the collective key of a drand node
type CokeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CokeyRequest) Reset()         { *m = CokeyRequest{} }
func (m *CokeyRequest) String() string { return proto.CompactTextString(m) }
func (*CokeyRequest) ProtoMessage()    {}
func (*CokeyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{13}
}

func (m *CokeyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CokeyRequest.Unmarshal(m, b)
}
func (m *CokeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CokeyRequest.Marshal(b, m, deterministic)
}
func (m *CokeyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CokeyRequest.Merge(m, src)
}
func (m *CokeyRequest) XXX_Size() int {
	return xxx_messageInfo_CokeyRequest.Size(m)
}
func (m *CokeyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CokeyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CokeyRequest proto.InternalMessageInfo

// CokeyResponse holds the collective key of a drand node
type CokeyResponse struct {
	CoKey                []byte   `protobuf:"bytes,2,opt,name=coKey,proto3" json:"coKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CokeyResponse) Reset()         { *m = CokeyResponse{} }
func (m *CokeyResponse) String() string { return proto.CompactTextString(m) }
func (*CokeyResponse) ProtoMessage()    {}
func (*CokeyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{14}
}

func (m *CokeyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CokeyResponse.Unmarshal(m, b)
}
func (m *CokeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CokeyResponse.Marshal(b, m, deterministic)
}
func (m *CokeyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CokeyResponse.Merge(m, src)
}
func (m *CokeyResponse) XXX_Size() int {
	return xxx_messageInfo_CokeyResponse.Size(m)
}
func (m *CokeyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CokeyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CokeyResponse proto.InternalMessageInfo

func (m *CokeyResponse) GetCoKey() []byte {
	if m != nil {
		return m.CoKey
	}
	return nil
}

type GroupTOMLResponse struct {
	// TOML-encoded group file
	GroupToml            string   `protobuf:"bytes,1,opt,name=group_toml,json=groupToml,proto3" json:"group_toml,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GroupTOMLResponse) Reset()         { *m = GroupTOMLResponse{} }
func (m *GroupTOMLResponse) String() string { return proto.CompactTextString(m) }
func (*GroupTOMLResponse) ProtoMessage()    {}
func (*GroupTOMLResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{15}
}

func (m *GroupTOMLResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupTOMLResponse.Unmarshal(m, b)
}
func (m *GroupTOMLResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupTOMLResponse.Marshal(b, m, deterministic)
}
func (m *GroupTOMLResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupTOMLResponse.Merge(m, src)
}
func (m *GroupTOMLResponse) XXX_Size() int {
	return xxx_messageInfo_GroupTOMLResponse.Size(m)
}
func (m *GroupTOMLResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupTOMLResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GroupTOMLResponse proto.InternalMessageInfo

func (m *GroupTOMLResponse) GetGroupToml() string {
	if m != nil {
		return m.GroupToml
	}
	return ""
}

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

func (m *ShutdownRequest) Reset()         { *m = ShutdownRequest{} }
func (m *ShutdownRequest) String() string { return proto.CompactTextString(m) }
func (*ShutdownRequest) ProtoMessage()    {}
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{16}
}

func (m *ShutdownRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownRequest.Unmarshal(m, b)
}
func (m *ShutdownRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownRequest.Marshal(b, m, deterministic)
}
func (m *ShutdownRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownRequest.Merge(m, src)
}
func (m *ShutdownRequest) XXX_Size() int {
	return xxx_messageInfo_ShutdownRequest.Size(m)
}
func (m *ShutdownRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownRequest proto.InternalMessageInfo

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

func (m *ShutdownResponse) Reset()         { *m = ShutdownResponse{} }
func (m *ShutdownResponse) String() string { return proto.CompactTextString(m) }
func (*ShutdownResponse) ProtoMessage()    {}
func (*ShutdownResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_2dd5961950a69ad7, []int{17}
}

func (m *ShutdownResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ShutdownResponse.Unmarshal(m, b)
}
func (m *ShutdownResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ShutdownResponse.Marshal(b, m, deterministic)
}
func (m *ShutdownResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ShutdownResponse.Merge(m, src)
}
func (m *ShutdownResponse) XXX_Size() int {
	return xxx_messageInfo_ShutdownResponse.Size(m)
}
func (m *ShutdownResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ShutdownResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ShutdownResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*SetupInfoPacket)(nil), "drand.SetupInfoPacket")
	proto.RegisterType((*InitDKGPacket)(nil), "drand.InitDKGPacket")
	proto.RegisterType((*EntropyInfo)(nil), "drand.EntropyInfo")
	proto.RegisterType((*InitResharePacket)(nil), "drand.InitResharePacket")
	proto.RegisterType((*GroupInfo)(nil), "drand.GroupInfo")
	proto.RegisterType((*ShareRequest)(nil), "drand.ShareRequest")
	proto.RegisterType((*ShareResponse)(nil), "drand.ShareResponse")
	proto.RegisterType((*Ping)(nil), "drand.Ping")
	proto.RegisterType((*Pong)(nil), "drand.Pong")
	proto.RegisterType((*PublicKeyRequest)(nil), "drand.PublicKeyRequest")
	proto.RegisterType((*PublicKeyResponse)(nil), "drand.PublicKeyResponse")
	proto.RegisterType((*PrivateKeyRequest)(nil), "drand.PrivateKeyRequest")
	proto.RegisterType((*PrivateKeyResponse)(nil), "drand.PrivateKeyResponse")
	proto.RegisterType((*CokeyRequest)(nil), "drand.CokeyRequest")
	proto.RegisterType((*CokeyResponse)(nil), "drand.CokeyResponse")
	proto.RegisterType((*GroupTOMLResponse)(nil), "drand.GroupTOMLResponse")
	proto.RegisterType((*ShutdownRequest)(nil), "drand.ShutdownRequest")
	proto.RegisterType((*ShutdownResponse)(nil), "drand.ShutdownResponse")
}

func init() {
	proto.RegisterFile("drand/control.proto", fileDescriptor_2dd5961950a69ad7)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// 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.SupportPackageIsVersion6

// ControlClient is the client API for Control service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ControlClient interface {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(ctx context.Context, in *InitDKGPacket, opts ...grpc.CallOption) (*GroupPacket, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(ctx context.Context, in *InitResharePacket, opts ...grpc.CallOption) (*GroupPacket, error)
	// Share returns the current private share used by the node
	Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	CollectiveKey(ctx context.Context, in *CokeyRequest, opts ...grpc.CallOption) (*CokeyResponse, error)
	// GroupFile returns the TOML-encoded group file
	// similar to public.Group method but needed for ease of use of the
	// control functionalities
	GroupFile(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupPacket, error)
	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
}

type controlClient struct {
	cc grpc.ClientConnInterface
}

func NewControlClient(cc grpc.ClientConnInterface) ControlClient {
	return &controlClient{cc}
}

func (c *controlClient) PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error) {
	out := new(Pong)
	err := c.cc.Invoke(ctx, "/drand.Control/PingPong", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitDKG(ctx context.Context, in *InitDKGPacket, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/InitDKG", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitReshare(ctx context.Context, in *InitResharePacket, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/InitReshare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error) {
	out := new(ShareResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/Share", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error) {
	out := new(PublicKeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/PublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error) {
	out := new(PrivateKeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/PrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) CollectiveKey(ctx context.Context, in *CokeyRequest, opts ...grpc.CallOption) (*CokeyResponse, error) {
	out := new(CokeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/CollectiveKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) GroupFile(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupPacket, error) {
	out := new(GroupPacket)
	err := c.cc.Invoke(ctx, "/drand.Control/GroupFile", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error) {
	out := new(ShutdownResponse)
	err := c.cc.Invoke(ctx, "/drand.Control/Shutdown", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ControlServer is the server API for Control service.
type ControlServer interface {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(context.Context, *Ping) (*Pong, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(context.Context, *InitDKGPacket) (*GroupPacket, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(context.Context, *InitResharePacket) (*GroupPacket, error)
	// Share returns the current private share used by the node
	Share(context.Context, *ShareRequest) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(context.Context, *PublicKeyRequest) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(context.Context, *PrivateKeyRequest) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	CollectiveKey(context.Context, *CokeyRequest) (*CokeyResponse, error)
	// GroupFile returns the TOML-encoded group file
	// similar to public.Group method but needed for ease of use of the
	// control functionalities
	GroupFile(context.Context, *GroupRequest) (*GroupPacket, error)
	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
}

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

func (*UnimplementedControlServer) PingPong(ctx context.Context, req *Ping) (*Pong, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PingPong not implemented")
}
func (*UnimplementedControlServer) InitDKG(ctx context.Context, req *InitDKGPacket) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitDKG not implemented")
}
func (*UnimplementedControlServer) InitReshare(ctx context.Context, req *InitResharePacket) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InitReshare not implemented")
}
func (*UnimplementedControlServer) Share(ctx context.Context, req *ShareRequest) (*ShareResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Share not implemented")
}
func (*UnimplementedControlServer) PublicKey(ctx context.Context, req *PublicKeyRequest) (*PublicKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicKey not implemented")
}
func (*UnimplementedControlServer) PrivateKey(ctx context.Context, req *PrivateKeyRequest) (*PrivateKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrivateKey not implemented")
}
func (*UnimplementedControlServer) CollectiveKey(ctx context.Context, req *CokeyRequest) (*CokeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectiveKey not implemented")
}
func (*UnimplementedControlServer) GroupFile(ctx context.Context, req *GroupRequest) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GroupFile not implemented")
}
func (*UnimplementedControlServer) Shutdown(ctx context.Context, req *ShutdownRequest) (*ShutdownResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Shutdown not implemented")
}

func RegisterControlServer(s *grpc.Server, srv ControlServer) {
	s.RegisterService(&_Control_serviceDesc, srv)
}

func _Control_PingPong_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Ping)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PingPong(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PingPong",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PingPong(ctx, req.(*Ping))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitDKG_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitDKGPacket)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitDKG(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/InitDKG",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitDKG(ctx, req.(*InitDKGPacket))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitReshare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InitResharePacket)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitReshare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/InitReshare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitReshare(ctx, req.(*InitResharePacket))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Share_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Share(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/Share",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Share(ctx, req.(*ShareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PublicKey(ctx, req.(*PublicKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/PrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PrivateKey(ctx, req.(*PrivateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_CollectiveKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CokeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).CollectiveKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/CollectiveKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).CollectiveKey(ctx, req.(*CokeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_GroupFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).GroupFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/GroupFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).GroupFile(ctx, req.(*GroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Shutdown_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShutdownRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Shutdown(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Control/Shutdown",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Shutdown(ctx, req.(*ShutdownRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Control_serviceDesc = grpc.ServiceDesc{
	ServiceName: "drand.Control",
	HandlerType: (*ControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PingPong",
			Handler:    _Control_PingPong_Handler,
		},
		{
			MethodName: "InitDKG",
			Handler:    _Control_InitDKG_Handler,
		},
		{
			MethodName: "InitReshare",
			Handler:    _Control_InitReshare_Handler,
		},
		{
			MethodName: "Share",
			Handler:    _Control_Share_Handler,
		},
		{
			MethodName: "PublicKey",
			Handler:    _Control_PublicKey_Handler,
		},
		{
			MethodName: "PrivateKey",
			Handler:    _Control_PrivateKey_Handler,
		},
		{
			MethodName: "CollectiveKey",
			Handler:    _Control_CollectiveKey_Handler,
		},
		{
			MethodName: "GroupFile",
			Handler:    _Control_GroupFile_Handler,
		},
		{
			MethodName: "Shutdown",
			Handler:    _Control_Shutdown_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "drand/control.proto",
}