api.pb.go

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

package drand

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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

// PublicRandRequest requests a public random value that has been generated in a
// unbiasable way and verifiable.
type PublicRandRequest struct {
	// round uniquely identifies a beacon. If round == 0 (or unspecified), then
	// the response will contain the last.
	Round                uint64   `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PublicRandRequest proto.InternalMessageInfo

func (m *PublicRandRequest) GetRound() uint64 {
	if m != nil {
		return m.Round
	}
	return 0
}

// PublicRandResponse holds a signature which is the random value. It can be
// verified thanks to the distributed public key of the nodes that have ran the
// DKG protocol and is unbiasable. The randomness can be verified using the BLS
// verification routine with the message "round || previous_rand".
type PublicRandResponse struct {
	Round             uint64 `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"`
	Signature         []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	PreviousRound     uint64 `protobuf:"varint,3,opt,name=previous_round,json=previousRound,proto3" json:"previous_round,omitempty"`
	PreviousSignature []byte `protobuf:"bytes,4,opt,name=previous_signature,json=previousSignature,proto3" json:"previous_signature,omitempty"`
	// randomness is simply there to demonstrate - it is the hash of the
	// signature. It should be computed locally.
	Randomness           []byte   `protobuf:"bytes,5,opt,name=randomness,proto3" json:"randomness,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PublicRandResponse proto.InternalMessageInfo

func (m *PublicRandResponse) GetRound() uint64 {
	if m != nil {
		return m.Round
	}
	return 0
}

func (m *PublicRandResponse) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *PublicRandResponse) GetPreviousRound() uint64 {
	if m != nil {
		return m.PreviousRound
	}
	return 0
}

func (m *PublicRandResponse) GetPreviousSignature() []byte {
	if m != nil {
		return m.PreviousSignature
	}
	return nil
}

func (m *PublicRandResponse) GetRandomness() []byte {
	if m != nil {
		return m.Randomness
	}
	return nil
}

// PrivateRandRequest is the message to send when requesting a private random
// value.
type PrivateRandRequest struct {
	// Request must contains a public key towards which to encrypt the private
	// randomness.
	Request              *ECIES   `protobuf:"bytes,2,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PrivateRandRequest proto.InternalMessageInfo

func (m *PrivateRandRequest) GetRequest() *ECIES {
	if m != nil {
		return m.Request
	}
	return nil
}

type PrivateRandResponse struct {
	// Response contains the private randomness encrypted towards the client's
	// request key.
	Response             *ECIES   `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PrivateRandResponse proto.InternalMessageInfo

func (m *PrivateRandResponse) GetResponse() *ECIES {
	if m != nil {
		return m.Response
	}
	return nil
}

type ECIES struct {
	Ephemeral            []byte   `protobuf:"bytes,1,opt,name=ephemeral,proto3" json:"ephemeral,omitempty"`
	Ciphertext           []byte   `protobuf:"bytes,2,opt,name=ciphertext,proto3" json:"ciphertext,omitempty"`
	Nonce                []byte   `protobuf:"bytes,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ECIES proto.InternalMessageInfo

func (m *ECIES) GetEphemeral() []byte {
	if m != nil {
		return m.Ephemeral
	}
	return nil
}

func (m *ECIES) GetCiphertext() []byte {
	if m != nil {
		return m.Ciphertext
	}
	return nil
}

func (m *ECIES) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

// DistKeyRequest requests the distributed public key used during the randomness generation process
type DistKeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DistKeyRequest proto.InternalMessageInfo

type DistKeyResponse struct {
	Key                  []byte   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DistKeyResponse proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_HomeRequest proto.InternalMessageInfo

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

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

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

var xxx_messageInfo_HomeResponse proto.InternalMessageInfo

func (m *HomeResponse) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

// Node represents the information about a drand's node
type Node struct {
	Address              string   `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	Key                  string   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	TLS                  bool     `protobuf:"varint,3,opt,name=TLS,proto3" json:"TLS,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Node proto.InternalMessageInfo

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

func (m *Node) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Node) GetTLS() bool {
	if m != nil {
		return m.TLS
	}
	return false
}

func init() {
	proto.RegisterType((*PublicRandRequest)(nil), "drand.PublicRandRequest")
	proto.RegisterType((*PublicRandResponse)(nil), "drand.PublicRandResponse")
	proto.RegisterType((*PrivateRandRequest)(nil), "drand.PrivateRandRequest")
	proto.RegisterType((*PrivateRandResponse)(nil), "drand.PrivateRandResponse")
	proto.RegisterType((*ECIES)(nil), "drand.ECIES")
	proto.RegisterType((*DistKeyRequest)(nil), "drand.DistKeyRequest")
	proto.RegisterType((*DistKeyResponse)(nil), "drand.DistKeyResponse")
	proto.RegisterType((*HomeRequest)(nil), "drand.HomeRequest")
	proto.RegisterType((*HomeResponse)(nil), "drand.HomeResponse")
	proto.RegisterType((*Node)(nil), "drand.Node")
}

func init() {
	proto.RegisterFile("drand/api.proto", fileDescriptor_c0cff3fc81cf7d79)
}

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

// PublicClient is the client API for Public service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PublicClient interface {
	// PublicRand is the method that returns the publicly verifiable randomness
	// generated by the drand network.
	PublicRand(ctx context.Context, in *PublicRandRequest, opts ...grpc.CallOption) (*PublicRandResponse, error)
	PublicRandStream(ctx context.Context, in *PublicRandRequest, opts ...grpc.CallOption) (Public_PublicRandStreamClient, error)
	// PrivateRand is the method that returns the private randomness generated
	// by the drand node only.
	PrivateRand(ctx context.Context, in *PrivateRandRequest, opts ...grpc.CallOption) (*PrivateRandResponse, error)
	// Group is the method that returns the group descrition that the drand
	// endpoint belongs to
	Group(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupPacket, error)
	// DistKey returns the distributed key from which drand node endpoint get a share
	DistKey(ctx context.Context, in *DistKeyRequest, opts ...grpc.CallOption) (*DistKeyResponse, error)
	// Home is a simple endpoint
	Home(ctx context.Context, in *HomeRequest, opts ...grpc.CallOption) (*HomeResponse, error)
}

type publicClient struct {
	cc grpc.ClientConnInterface
}

func NewPublicClient(cc grpc.ClientConnInterface) PublicClient {
	return &publicClient{cc}
}

func (c *publicClient) PublicRand(ctx context.Context, in *PublicRandRequest, opts ...grpc.CallOption) (*PublicRandResponse, error) {
	out := new(PublicRandResponse)
	err := c.cc.Invoke(ctx, "/drand.Public/PublicRand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *publicClient) PublicRandStream(ctx context.Context, in *PublicRandRequest, opts ...grpc.CallOption) (Public_PublicRandStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Public_serviceDesc.Streams[0], "/drand.Public/PublicRandStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &publicPublicRandStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Public_PublicRandStreamClient interface {
	Recv() (*PublicRandResponse, error)
	grpc.ClientStream
}

type publicPublicRandStreamClient struct {
	grpc.ClientStream
}

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

func (c *publicClient) PrivateRand(ctx context.Context, in *PrivateRandRequest, opts ...grpc.CallOption) (*PrivateRandResponse, error) {
	out := new(PrivateRandResponse)
	err := c.cc.Invoke(ctx, "/drand.Public/PrivateRand", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *publicClient) DistKey(ctx context.Context, in *DistKeyRequest, opts ...grpc.CallOption) (*DistKeyResponse, error) {
	out := new(DistKeyResponse)
	err := c.cc.Invoke(ctx, "/drand.Public/DistKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *publicClient) Home(ctx context.Context, in *HomeRequest, opts ...grpc.CallOption) (*HomeResponse, error) {
	out := new(HomeResponse)
	err := c.cc.Invoke(ctx, "/drand.Public/Home", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PublicServer is the server API for Public service.
type PublicServer interface {
	// PublicRand is the method that returns the publicly verifiable randomness
	// generated by the drand network.
	PublicRand(context.Context, *PublicRandRequest) (*PublicRandResponse, error)
	PublicRandStream(*PublicRandRequest, Public_PublicRandStreamServer) error
	// PrivateRand is the method that returns the private randomness generated
	// by the drand node only.
	PrivateRand(context.Context, *PrivateRandRequest) (*PrivateRandResponse, error)
	// Group is the method that returns the group descrition that the drand
	// endpoint belongs to
	Group(context.Context, *GroupRequest) (*GroupPacket, error)
	// DistKey returns the distributed key from which drand node endpoint get a share
	DistKey(context.Context, *DistKeyRequest) (*DistKeyResponse, error)
	// Home is a simple endpoint
	Home(context.Context, *HomeRequest) (*HomeResponse, error)
}

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

func (*UnimplementedPublicServer) PublicRand(ctx context.Context, req *PublicRandRequest) (*PublicRandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublicRand not implemented")
}
func (*UnimplementedPublicServer) PublicRandStream(req *PublicRandRequest, srv Public_PublicRandStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method PublicRandStream not implemented")
}
func (*UnimplementedPublicServer) PrivateRand(ctx context.Context, req *PrivateRandRequest) (*PrivateRandResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrivateRand not implemented")
}
func (*UnimplementedPublicServer) Group(ctx context.Context, req *GroupRequest) (*GroupPacket, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Group not implemented")
}
func (*UnimplementedPublicServer) DistKey(ctx context.Context, req *DistKeyRequest) (*DistKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DistKey not implemented")
}
func (*UnimplementedPublicServer) Home(ctx context.Context, req *HomeRequest) (*HomeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Home not implemented")
}

func RegisterPublicServer(s *grpc.Server, srv PublicServer) {
	s.RegisterService(&_Public_serviceDesc, srv)
}

func _Public_PublicRand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicRandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PublicServer).PublicRand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Public/PublicRand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PublicServer).PublicRand(ctx, req.(*PublicRandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Public_PublicRandStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(PublicRandRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(PublicServer).PublicRandStream(m, &publicPublicRandStreamServer{stream})
}

type Public_PublicRandStreamServer interface {
	Send(*PublicRandResponse) error
	grpc.ServerStream
}

type publicPublicRandStreamServer struct {
	grpc.ServerStream
}

func (x *publicPublicRandStreamServer) Send(m *PublicRandResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Public_PrivateRand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivateRandRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PublicServer).PrivateRand(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Public/PrivateRand",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PublicServer).PrivateRand(ctx, req.(*PrivateRandRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Public_Group_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.(PublicServer).Group(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Public/Group",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PublicServer).Group(ctx, req.(*GroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Public_DistKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DistKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PublicServer).DistKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Public/DistKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PublicServer).DistKey(ctx, req.(*DistKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Public_Home_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HomeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PublicServer).Home(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/drand.Public/Home",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PublicServer).Home(ctx, req.(*HomeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Public_serviceDesc = grpc.ServiceDesc{
	ServiceName: "drand.Public",
	HandlerType: (*PublicServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PublicRand",
			Handler:    _Public_PublicRand_Handler,
		},
		{
			MethodName: "PrivateRand",
			Handler:    _Public_PrivateRand_Handler,
		},
		{
			MethodName: "Group",
			Handler:    _Public_Group_Handler,
		},
		{
			MethodName: "DistKey",
			Handler:    _Public_DistKey_Handler,
		},
		{
			MethodName: "Home",
			Handler:    _Public_Home_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "PublicRandStream",
			Handler:       _Public_PublicRandStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "drand/api.proto",
}