// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: frost.proto

package frost

import (
	common "github.com/lightsparkdev/spark/proto/common"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// The role of the participant in the signing.
type SigningRole int32

const (
	SigningRole_STATECHAIN SigningRole = 0
	SigningRole_USER       SigningRole = 1
)

// Enum value maps for SigningRole.
var (
	SigningRole_name = map[int32]string{
		0: "STATECHAIN",
		1: "USER",
	}
	SigningRole_value = map[string]int32{
		"STATECHAIN": 0,
		"USER":       1,
	}
)

func (x SigningRole) Enum() *SigningRole {
	p := new(SigningRole)
	*p = x
	return p
}

func (x SigningRole) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (SigningRole) Descriptor() protoreflect.EnumDescriptor {
	return file_frost_proto_enumTypes[0].Descriptor()
}

func (SigningRole) Type() protoreflect.EnumType {
	return &file_frost_proto_enumTypes[0]
}

func (x SigningRole) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use SigningRole.Descriptor instead.
func (SigningRole) EnumDescriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{0}
}

type EchoRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EchoRequest) Reset() {
	*x = EchoRequest{}
	mi := &file_frost_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EchoRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EchoRequest) ProtoMessage() {}

func (x *EchoRequest) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EchoRequest.ProtoReflect.Descriptor instead.
func (*EchoRequest) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{0}
}

func (x *EchoRequest) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type EchoResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *EchoResponse) Reset() {
	*x = EchoResponse{}
	mi := &file_frost_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *EchoResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*EchoResponse) ProtoMessage() {}

func (x *EchoResponse) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use EchoResponse.ProtoReflect.Descriptor instead.
func (*EchoResponse) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{1}
}

func (x *EchoResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

// Distributed Key Generation Round 1 Request
//
// This request is sent to the server to start the Distributed Key Generation
// protocol. This will be a batch request, so the server will generate the
// keys for all participants in the batch.
type DkgRound1Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An uuid to identify the request.
	RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Identifier of the participant, this will be used as the index of the Shamir secret share. The
	// value should be not be 0. This is a 32-byte hex string.
	Identifier string `protobuf:"bytes,2,opt,name=identifier,proto3" json:"identifier,omitempty"`
	// The maximum number of signers, this is the size of the threshold signature scheme.
	MaxSigners uint64 `protobuf:"varint,3,opt,name=max_signers,json=maxSigners,proto3" json:"max_signers,omitempty"`
	// The minimum number of signers, this is the threshold for the threshold signature scheme.
	MinSigners uint64 `protobuf:"varint,4,opt,name=min_signers,json=minSigners,proto3" json:"min_signers,omitempty"`
	// The number of keys to generate.
	KeyCount      uint64 `protobuf:"varint,5,opt,name=key_count,json=keyCount,proto3" json:"key_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DkgRound1Request) Reset() {
	*x = DkgRound1Request{}
	mi := &file_frost_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound1Request) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound1Request) ProtoMessage() {}

func (x *DkgRound1Request) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound1Request.ProtoReflect.Descriptor instead.
func (*DkgRound1Request) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{2}
}

func (x *DkgRound1Request) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *DkgRound1Request) GetIdentifier() string {
	if x != nil {
		return x.Identifier
	}
	return ""
}

func (x *DkgRound1Request) GetMaxSigners() uint64 {
	if x != nil {
		return x.MaxSigners
	}
	return 0
}

func (x *DkgRound1Request) GetMinSigners() uint64 {
	if x != nil {
		return x.MinSigners
	}
	return 0
}

func (x *DkgRound1Request) GetKeyCount() uint64 {
	if x != nil {
		return x.KeyCount
	}
	return 0
}

// Distributed Key Generation Round 1 Response
//
// This response is sent from the server to the client after the Distributed Key Generation
// protocol has been completed.
type DkgRound1Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The packages for the participants. This will be sent to all participants and will be used for
	// the next round.
	Round1Packages [][]byte `protobuf:"bytes,1,rep,name=round1_packages,json=round1Packages,proto3" json:"round1_packages,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *DkgRound1Response) Reset() {
	*x = DkgRound1Response{}
	mi := &file_frost_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound1Response) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound1Response) ProtoMessage() {}

func (x *DkgRound1Response) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound1Response.ProtoReflect.Descriptor instead.
func (*DkgRound1Response) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{3}
}

func (x *DkgRound1Response) GetRound1Packages() [][]byte {
	if x != nil {
		return x.Round1Packages
	}
	return nil
}

// Distributed Key Generation Round 2 Request
//
// This request is sent to the server for the round 2 of DKG protocol.
// This will be a batch request.
type DkgRound2Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An uuid to identify the request.
	RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// A map of all participants' identifiers to their serialized round1 packages.
	Round1PackagesMaps []*common.PackageMap `protobuf:"bytes,2,rep,name=round1_packages_maps,json=round1PackagesMaps,proto3" json:"round1_packages_maps,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *DkgRound2Request) Reset() {
	*x = DkgRound2Request{}
	mi := &file_frost_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound2Request) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound2Request) ProtoMessage() {}

func (x *DkgRound2Request) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound2Request.ProtoReflect.Descriptor instead.
func (*DkgRound2Request) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{4}
}

func (x *DkgRound2Request) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *DkgRound2Request) GetRound1PackagesMaps() []*common.PackageMap {
	if x != nil {
		return x.Round1PackagesMaps
	}
	return nil
}

// Distributed Key Generation Round 2 Response
//
// This response is sent from the server to the client after the Distributed Key Generation
// protocol has been completed.
type DkgRound2Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The serialized round2 packages.
	Round2Packages []*common.PackageMap `protobuf:"bytes,1,rep,name=round2_packages,json=round2Packages,proto3" json:"round2_packages,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *DkgRound2Response) Reset() {
	*x = DkgRound2Response{}
	mi := &file_frost_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound2Response) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound2Response) ProtoMessage() {}

func (x *DkgRound2Response) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound2Response.ProtoReflect.Descriptor instead.
func (*DkgRound2Response) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{5}
}

func (x *DkgRound2Response) GetRound2Packages() []*common.PackageMap {
	if x != nil {
		return x.Round2Packages
	}
	return nil
}

// Distributed Key Generation Round 3 Request
//
// This request is sent to the server for the round 3 of DKG protocol.
type DkgRound3Request struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An uuid to identify the request.
	RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// A map of all participants' identifiers to their serialized round1 packages.
	Round1PackagesMaps []*common.PackageMap `protobuf:"bytes,2,rep,name=round1_packages_maps,json=round1PackagesMaps,proto3" json:"round1_packages_maps,omitempty"`
	// A map of all participants' identifiers to their serialized round2 packages.
	Round2PackagesMaps []*common.PackageMap `protobuf:"bytes,3,rep,name=round2_packages_maps,json=round2PackagesMaps,proto3" json:"round2_packages_maps,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *DkgRound3Request) Reset() {
	*x = DkgRound3Request{}
	mi := &file_frost_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound3Request) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound3Request) ProtoMessage() {}

func (x *DkgRound3Request) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound3Request.ProtoReflect.Descriptor instead.
func (*DkgRound3Request) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{6}
}

func (x *DkgRound3Request) GetRequestId() string {
	if x != nil {
		return x.RequestId
	}
	return ""
}

func (x *DkgRound3Request) GetRound1PackagesMaps() []*common.PackageMap {
	if x != nil {
		return x.Round1PackagesMaps
	}
	return nil
}

func (x *DkgRound3Request) GetRound2PackagesMaps() []*common.PackageMap {
	if x != nil {
		return x.Round2PackagesMaps
	}
	return nil
}

// A key package for frost signing.
type KeyPackage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The identifier of the participant.
	Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	// The secret share for the participant.
	SecretShare []byte `protobuf:"bytes,2,opt,name=secret_share,json=secretShare,proto3" json:"secret_share,omitempty"`
	// The public shares for each participant.
	PublicShares map[string][]byte `protobuf:"bytes,3,rep,name=public_shares,json=publicShares,proto3" json:"public_shares,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The public key for the group.
	PublicKey []byte `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// The minimum number of signers for the threshold signature scheme.
	MinSigners    uint32 `protobuf:"varint,5,opt,name=min_signers,json=minSigners,proto3" json:"min_signers,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KeyPackage) Reset() {
	*x = KeyPackage{}
	mi := &file_frost_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KeyPackage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KeyPackage) ProtoMessage() {}

func (x *KeyPackage) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KeyPackage.ProtoReflect.Descriptor instead.
func (*KeyPackage) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{7}
}

func (x *KeyPackage) GetIdentifier() string {
	if x != nil {
		return x.Identifier
	}
	return ""
}

func (x *KeyPackage) GetSecretShare() []byte {
	if x != nil {
		return x.SecretShare
	}
	return nil
}

func (x *KeyPackage) GetPublicShares() map[string][]byte {
	if x != nil {
		return x.PublicShares
	}
	return nil
}

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

func (x *KeyPackage) GetMinSigners() uint32 {
	if x != nil {
		return x.MinSigners
	}
	return 0
}

// Distributed Key Generation Round 3 Response
//
// This response is sent from the server to the client after the Distributed Key Generation
// protocol has been completed.
type DkgRound3Response struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The key packages for the participants.
	KeyPackages   []*KeyPackage `protobuf:"bytes,1,rep,name=key_packages,json=keyPackages,proto3" json:"key_packages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DkgRound3Response) Reset() {
	*x = DkgRound3Response{}
	mi := &file_frost_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DkgRound3Response) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DkgRound3Response) ProtoMessage() {}

func (x *DkgRound3Response) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DkgRound3Response.ProtoReflect.Descriptor instead.
func (*DkgRound3Response) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{8}
}

func (x *DkgRound3Response) GetKeyPackages() []*KeyPackage {
	if x != nil {
		return x.KeyPackages
	}
	return nil
}

// A nonce for frost signing.
// It's a pair of private keys in secp256k1 sha256 field.
type SigningNonce struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The private key for hiding. 32 bytes.
	Hiding []byte `protobuf:"bytes,1,opt,name=hiding,proto3" json:"hiding,omitempty"`
	// The private key for binding. 32 bytes.
	Binding       []byte `protobuf:"bytes,2,opt,name=binding,proto3" json:"binding,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SigningNonce) Reset() {
	*x = SigningNonce{}
	mi := &file_frost_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SigningNonce) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SigningNonce) ProtoMessage() {}

func (x *SigningNonce) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SigningNonce.ProtoReflect.Descriptor instead.
func (*SigningNonce) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{9}
}

func (x *SigningNonce) GetHiding() []byte {
	if x != nil {
		return x.Hiding
	}
	return nil
}

func (x *SigningNonce) GetBinding() []byte {
	if x != nil {
		return x.Binding
	}
	return nil
}

type FrostNonceRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The key packages for the signing, used as entropy for the nonce.
	KeyPackages   []*KeyPackage `protobuf:"bytes,1,rep,name=key_packages,json=keyPackages,proto3" json:"key_packages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FrostNonceRequest) Reset() {
	*x = FrostNonceRequest{}
	mi := &file_frost_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FrostNonceRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FrostNonceRequest) ProtoMessage() {}

func (x *FrostNonceRequest) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FrostNonceRequest.ProtoReflect.Descriptor instead.
func (*FrostNonceRequest) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{10}
}

func (x *FrostNonceRequest) GetKeyPackages() []*KeyPackage {
	if x != nil {
		return x.KeyPackages
	}
	return nil
}

type SigningNonceResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The nonces for the signing.
	Nonces *SigningNonce `protobuf:"bytes,1,opt,name=nonces,proto3" json:"nonces,omitempty"`
	// The commitments for the signing.
	Commitments   *common.SigningCommitment `protobuf:"bytes,2,opt,name=commitments,proto3" json:"commitments,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SigningNonceResult) Reset() {
	*x = SigningNonceResult{}
	mi := &file_frost_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SigningNonceResult) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SigningNonceResult) ProtoMessage() {}

func (x *SigningNonceResult) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SigningNonceResult.ProtoReflect.Descriptor instead.
func (*SigningNonceResult) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{11}
}

func (x *SigningNonceResult) GetNonces() *SigningNonce {
	if x != nil {
		return x.Nonces
	}
	return nil
}

func (x *SigningNonceResult) GetCommitments() *common.SigningCommitment {
	if x != nil {
		return x.Commitments
	}
	return nil
}

type FrostNonceResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Results       []*SigningNonceResult  `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FrostNonceResponse) Reset() {
	*x = FrostNonceResponse{}
	mi := &file_frost_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FrostNonceResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FrostNonceResponse) ProtoMessage() {}

func (x *FrostNonceResponse) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FrostNonceResponse.ProtoReflect.Descriptor instead.
func (*FrostNonceResponse) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{12}
}

func (x *FrostNonceResponse) GetResults() []*SigningNonceResult {
	if x != nil {
		return x.Results
	}
	return nil
}

type FrostSigningJob struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique identifier for the signing job.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// The message to sign.
	Message []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// The secret package from DKG round 3.
	KeyPackage *KeyPackage `protobuf:"bytes,3,opt,name=key_package,json=keyPackage,proto3" json:"key_package,omitempty"`
	// The verifying key. This should be the total public key for both user and StatechainEntity.
	VerifyingKey []byte `protobuf:"bytes,4,opt,name=verifying_key,json=verifyingKey,proto3" json:"verifying_key,omitempty"`
	// The nonce for current participant.
	Nonce *SigningNonce `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
	// The commitments for all participants of the statechain.
	Commitments map[string]*common.SigningCommitment `protobuf:"bytes,6,rep,name=commitments,proto3" json:"commitments,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The commitments for all participants of the user.
	UserCommitments *common.SigningCommitment `protobuf:"bytes,7,opt,name=user_commitments,json=userCommitments,proto3" json:"user_commitments,omitempty"`
	// Adaptor public key for adaptor signature
	AdaptorPublicKey []byte `protobuf:"bytes,8,opt,name=adaptor_public_key,json=adaptorPublicKey,proto3" json:"adaptor_public_key,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *FrostSigningJob) Reset() {
	*x = FrostSigningJob{}
	mi := &file_frost_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FrostSigningJob) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FrostSigningJob) ProtoMessage() {}

func (x *FrostSigningJob) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FrostSigningJob.ProtoReflect.Descriptor instead.
func (*FrostSigningJob) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{13}
}

func (x *FrostSigningJob) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

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

func (x *FrostSigningJob) GetKeyPackage() *KeyPackage {
	if x != nil {
		return x.KeyPackage
	}
	return nil
}

func (x *FrostSigningJob) GetVerifyingKey() []byte {
	if x != nil {
		return x.VerifyingKey
	}
	return nil
}

func (x *FrostSigningJob) GetNonce() *SigningNonce {
	if x != nil {
		return x.Nonce
	}
	return nil
}

func (x *FrostSigningJob) GetCommitments() map[string]*common.SigningCommitment {
	if x != nil {
		return x.Commitments
	}
	return nil
}

func (x *FrostSigningJob) GetUserCommitments() *common.SigningCommitment {
	if x != nil {
		return x.UserCommitments
	}
	return nil
}

func (x *FrostSigningJob) GetAdaptorPublicKey() []byte {
	if x != nil {
		return x.AdaptorPublicKey
	}
	return nil
}

// Signing request
//
// This request is sent to the server for the signing.
type SignFrostRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The signing jobs.
	SigningJobs []*FrostSigningJob `protobuf:"bytes,1,rep,name=signing_jobs,json=signingJobs,proto3" json:"signing_jobs,omitempty"`
	// The role of the participant in the signing.
	Role          SigningRole `protobuf:"varint,2,opt,name=role,proto3,enum=frost.SigningRole" json:"role,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SignFrostRequest) Reset() {
	*x = SignFrostRequest{}
	mi := &file_frost_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SignFrostRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SignFrostRequest) ProtoMessage() {}

func (x *SignFrostRequest) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SignFrostRequest.ProtoReflect.Descriptor instead.
func (*SignFrostRequest) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{14}
}

func (x *SignFrostRequest) GetSigningJobs() []*FrostSigningJob {
	if x != nil {
		return x.SigningJobs
	}
	return nil
}

func (x *SignFrostRequest) GetRole() SigningRole {
	if x != nil {
		return x.Role
	}
	return SigningRole_STATECHAIN
}

// Signing response
//
// This response is sent from the server to the client after the signing has been completed.
type SignFrostResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The signature shares.
	Results       map[string]*common.SigningResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SignFrostResponse) Reset() {
	*x = SignFrostResponse{}
	mi := &file_frost_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SignFrostResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SignFrostResponse) ProtoMessage() {}

func (x *SignFrostResponse) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SignFrostResponse.ProtoReflect.Descriptor instead.
func (*SignFrostResponse) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{15}
}

func (x *SignFrostResponse) GetResults() map[string]*common.SigningResult {
	if x != nil {
		return x.Results
	}
	return nil
}

// Aggregate frost request
//
// This request is sent to the server for the aggregate signing.
type AggregateFrostRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The message to sign.
	Message []byte `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// The signature shares for each participant of the statechain.
	SignatureShares map[string][]byte `protobuf:"bytes,2,rep,name=signature_shares,json=signatureShares,proto3" json:"signature_shares,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The public shares for each participant of the statechain.
	PublicShares map[string][]byte `protobuf:"bytes,3,rep,name=public_shares,json=publicShares,proto3" json:"public_shares,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The verifying key. This should be the total public key for both user and StatechainEntity.
	VerifyingKey []byte `protobuf:"bytes,4,opt,name=verifying_key,json=verifyingKey,proto3" json:"verifying_key,omitempty"`
	// The commitments for all participants of the statechain.
	Commitments map[string]*common.SigningCommitment `protobuf:"bytes,5,rep,name=commitments,proto3" json:"commitments,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The commitments for all participants of the user.
	UserCommitments *common.SigningCommitment `protobuf:"bytes,6,opt,name=user_commitments,json=userCommitments,proto3" json:"user_commitments,omitempty"`
	// The user's public key.
	UserPublicKey []byte `protobuf:"bytes,7,opt,name=user_public_key,json=userPublicKey,proto3" json:"user_public_key,omitempty"`
	// The user's signature share.
	UserSignatureShare []byte `protobuf:"bytes,8,opt,name=user_signature_share,json=userSignatureShare,proto3" json:"user_signature_share,omitempty"`
	// Adaptor public key for adaptor signature
	AdaptorPublicKey []byte `protobuf:"bytes,9,opt,name=adaptor_public_key,json=adaptorPublicKey,proto3" json:"adaptor_public_key,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AggregateFrostRequest) Reset() {
	*x = AggregateFrostRequest{}
	mi := &file_frost_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AggregateFrostRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AggregateFrostRequest) ProtoMessage() {}

func (x *AggregateFrostRequest) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AggregateFrostRequest.ProtoReflect.Descriptor instead.
func (*AggregateFrostRequest) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{16}
}

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

func (x *AggregateFrostRequest) GetSignatureShares() map[string][]byte {
	if x != nil {
		return x.SignatureShares
	}
	return nil
}

func (x *AggregateFrostRequest) GetPublicShares() map[string][]byte {
	if x != nil {
		return x.PublicShares
	}
	return nil
}

func (x *AggregateFrostRequest) GetVerifyingKey() []byte {
	if x != nil {
		return x.VerifyingKey
	}
	return nil
}

func (x *AggregateFrostRequest) GetCommitments() map[string]*common.SigningCommitment {
	if x != nil {
		return x.Commitments
	}
	return nil
}

func (x *AggregateFrostRequest) GetUserCommitments() *common.SigningCommitment {
	if x != nil {
		return x.UserCommitments
	}
	return nil
}

func (x *AggregateFrostRequest) GetUserPublicKey() []byte {
	if x != nil {
		return x.UserPublicKey
	}
	return nil
}

func (x *AggregateFrostRequest) GetUserSignatureShare() []byte {
	if x != nil {
		return x.UserSignatureShare
	}
	return nil
}

func (x *AggregateFrostRequest) GetAdaptorPublicKey() []byte {
	if x != nil {
		return x.AdaptorPublicKey
	}
	return nil
}

// Aggregate frost response
//
// This response is sent from the server to the client after the aggregate signing has been completed.
type AggregateFrostResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The signature.
	Signature     []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AggregateFrostResponse) Reset() {
	*x = AggregateFrostResponse{}
	mi := &file_frost_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AggregateFrostResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AggregateFrostResponse) ProtoMessage() {}

func (x *AggregateFrostResponse) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AggregateFrostResponse.ProtoReflect.Descriptor instead.
func (*AggregateFrostResponse) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{17}
}

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

type ValidateSignatureShareRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The identifier of the participant.
	Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	// The role of the participant in the signing.
	Role SigningRole `protobuf:"varint,2,opt,name=role,proto3,enum=frost.SigningRole" json:"role,omitempty"`
	// The message to sign.
	Message []byte `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	// The signature share to validate.
	SignatureShare []byte `protobuf:"bytes,4,opt,name=signature_share,json=signatureShare,proto3" json:"signature_share,omitempty"`
	// The public share for the participant.
	PublicShare []byte `protobuf:"bytes,5,opt,name=public_share,json=publicShare,proto3" json:"public_share,omitempty"`
	// The verifying key. This should be the total public key for both user and StatechainEntity.
	VerifyingKey []byte `protobuf:"bytes,6,opt,name=verifying_key,json=verifyingKey,proto3" json:"verifying_key,omitempty"`
	// The commitments for all participants of the statechain.
	Commitments map[string]*common.SigningCommitment `protobuf:"bytes,7,rep,name=commitments,proto3" json:"commitments,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The commitments for all participants of the user.
	UserCommitments *common.SigningCommitment `protobuf:"bytes,8,opt,name=user_commitments,json=userCommitments,proto3" json:"user_commitments,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *ValidateSignatureShareRequest) Reset() {
	*x = ValidateSignatureShareRequest{}
	mi := &file_frost_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ValidateSignatureShareRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ValidateSignatureShareRequest) ProtoMessage() {}

func (x *ValidateSignatureShareRequest) ProtoReflect() protoreflect.Message {
	mi := &file_frost_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ValidateSignatureShareRequest.ProtoReflect.Descriptor instead.
func (*ValidateSignatureShareRequest) Descriptor() ([]byte, []int) {
	return file_frost_proto_rawDescGZIP(), []int{18}
}

func (x *ValidateSignatureShareRequest) GetIdentifier() string {
	if x != nil {
		return x.Identifier
	}
	return ""
}

func (x *ValidateSignatureShareRequest) GetRole() SigningRole {
	if x != nil {
		return x.Role
	}
	return SigningRole_STATECHAIN
}

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

func (x *ValidateSignatureShareRequest) GetSignatureShare() []byte {
	if x != nil {
		return x.SignatureShare
	}
	return nil
}

func (x *ValidateSignatureShareRequest) GetPublicShare() []byte {
	if x != nil {
		return x.PublicShare
	}
	return nil
}

func (x *ValidateSignatureShareRequest) GetVerifyingKey() []byte {
	if x != nil {
		return x.VerifyingKey
	}
	return nil
}

func (x *ValidateSignatureShareRequest) GetCommitments() map[string]*common.SigningCommitment {
	if x != nil {
		return x.Commitments
	}
	return nil
}

func (x *ValidateSignatureShareRequest) GetUserCommitments() *common.SigningCommitment {
	if x != nil {
		return x.UserCommitments
	}
	return nil
}

var File_frost_proto protoreflect.FileDescriptor

const file_frost_proto_rawDesc = "" +
	"\n" +
	"\vfrost.proto\x12\x05frost\x1a\x1bgoogle/protobuf/empty.proto\x1a\fcommon.proto\"'\n" +
	"\vEchoRequest\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\"(\n" +
	"\fEchoResponse\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\"\xb0\x01\n" +
	"\x10DkgRound1Request\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12\x1e\n" +
	"\n" +
	"identifier\x18\x02 \x01(\tR\n" +
	"identifier\x12\x1f\n" +
	"\vmax_signers\x18\x03 \x01(\x04R\n" +
	"maxSigners\x12\x1f\n" +
	"\vmin_signers\x18\x04 \x01(\x04R\n" +
	"minSigners\x12\x1b\n" +
	"\tkey_count\x18\x05 \x01(\x04R\bkeyCount\"<\n" +
	"\x11DkgRound1Response\x12'\n" +
	"\x0fround1_packages\x18\x01 \x03(\fR\x0eround1Packages\"w\n" +
	"\x10DkgRound2Request\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12D\n" +
	"\x14round1_packages_maps\x18\x02 \x03(\v2\x12.common.PackageMapR\x12round1PackagesMaps\"P\n" +
	"\x11DkgRound2Response\x12;\n" +
	"\x0fround2_packages\x18\x01 \x03(\v2\x12.common.PackageMapR\x0eround2Packages\"\xbd\x01\n" +
	"\x10DkgRound3Request\x12\x1d\n" +
	"\n" +
	"request_id\x18\x01 \x01(\tR\trequestId\x12D\n" +
	"\x14round1_packages_maps\x18\x02 \x03(\v2\x12.common.PackageMapR\x12round1PackagesMaps\x12D\n" +
	"\x14round2_packages_maps\x18\x03 \x03(\v2\x12.common.PackageMapR\x12round2PackagesMaps\"\x9a\x02\n" +
	"\n" +
	"KeyPackage\x12\x1e\n" +
	"\n" +
	"identifier\x18\x01 \x01(\tR\n" +
	"identifier\x12!\n" +
	"\fsecret_share\x18\x02 \x01(\fR\vsecretShare\x12H\n" +
	"\rpublic_shares\x18\x03 \x03(\v2#.frost.KeyPackage.PublicSharesEntryR\fpublicShares\x12\x1d\n" +
	"\n" +
	"public_key\x18\x04 \x01(\fR\tpublicKey\x12\x1f\n" +
	"\vmin_signers\x18\x05 \x01(\rR\n" +
	"minSigners\x1a?\n" +
	"\x11PublicSharesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\"I\n" +
	"\x11DkgRound3Response\x124\n" +
	"\fkey_packages\x18\x01 \x03(\v2\x11.frost.KeyPackageR\vkeyPackages\"@\n" +
	"\fSigningNonce\x12\x16\n" +
	"\x06hiding\x18\x01 \x01(\fR\x06hiding\x12\x18\n" +
	"\abinding\x18\x02 \x01(\fR\abinding\"I\n" +
	"\x11FrostNonceRequest\x124\n" +
	"\fkey_packages\x18\x01 \x03(\v2\x11.frost.KeyPackageR\vkeyPackages\"~\n" +
	"\x12SigningNonceResult\x12+\n" +
	"\x06nonces\x18\x01 \x01(\v2\x13.frost.SigningNonceR\x06nonces\x12;\n" +
	"\vcommitments\x18\x02 \x01(\v2\x19.common.SigningCommitmentR\vcommitments\"I\n" +
	"\x12FrostNonceResponse\x123\n" +
	"\aresults\x18\x01 \x03(\v2\x19.frost.SigningNonceResultR\aresults\"\xe0\x03\n" +
	"\x0fFrostSigningJob\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x18\n" +
	"\amessage\x18\x02 \x01(\fR\amessage\x122\n" +
	"\vkey_package\x18\x03 \x01(\v2\x11.frost.KeyPackageR\n" +
	"keyPackage\x12#\n" +
	"\rverifying_key\x18\x04 \x01(\fR\fverifyingKey\x12)\n" +
	"\x05nonce\x18\x05 \x01(\v2\x13.frost.SigningNonceR\x05nonce\x12I\n" +
	"\vcommitments\x18\x06 \x03(\v2'.frost.FrostSigningJob.CommitmentsEntryR\vcommitments\x12D\n" +
	"\x10user_commitments\x18\a \x01(\v2\x19.common.SigningCommitmentR\x0fuserCommitments\x12,\n" +
	"\x12adaptor_public_key\x18\b \x01(\fR\x10adaptorPublicKey\x1aY\n" +
	"\x10CommitmentsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12/\n" +
	"\x05value\x18\x02 \x01(\v2\x19.common.SigningCommitmentR\x05value:\x028\x01\"u\n" +
	"\x10SignFrostRequest\x129\n" +
	"\fsigning_jobs\x18\x01 \x03(\v2\x16.frost.FrostSigningJobR\vsigningJobs\x12&\n" +
	"\x04role\x18\x02 \x01(\x0e2\x12.frost.SigningRoleR\x04role\"\xa7\x01\n" +
	"\x11SignFrostResponse\x12?\n" +
	"\aresults\x18\x01 \x03(\v2%.frost.SignFrostResponse.ResultsEntryR\aresults\x1aQ\n" +
	"\fResultsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12+\n" +
	"\x05value\x18\x02 \x01(\v2\x15.common.SigningResultR\x05value:\x028\x01\"\x88\x06\n" +
	"\x15AggregateFrostRequest\x12\x18\n" +
	"\amessage\x18\x01 \x01(\fR\amessage\x12\\\n" +
	"\x10signature_shares\x18\x02 \x03(\v21.frost.AggregateFrostRequest.SignatureSharesEntryR\x0fsignatureShares\x12S\n" +
	"\rpublic_shares\x18\x03 \x03(\v2..frost.AggregateFrostRequest.PublicSharesEntryR\fpublicShares\x12#\n" +
	"\rverifying_key\x18\x04 \x01(\fR\fverifyingKey\x12O\n" +
	"\vcommitments\x18\x05 \x03(\v2-.frost.AggregateFrostRequest.CommitmentsEntryR\vcommitments\x12D\n" +
	"\x10user_commitments\x18\x06 \x01(\v2\x19.common.SigningCommitmentR\x0fuserCommitments\x12&\n" +
	"\x0fuser_public_key\x18\a \x01(\fR\ruserPublicKey\x120\n" +
	"\x14user_signature_share\x18\b \x01(\fR\x12userSignatureShare\x12,\n" +
	"\x12adaptor_public_key\x18\t \x01(\fR\x10adaptorPublicKey\x1aB\n" +
	"\x14SignatureSharesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\x1a?\n" +
	"\x11PublicSharesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\x1aY\n" +
	"\x10CommitmentsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12/\n" +
	"\x05value\x18\x02 \x01(\v2\x19.common.SigningCommitmentR\x05value:\x028\x01\"6\n" +
	"\x16AggregateFrostResponse\x12\x1c\n" +
	"\tsignature\x18\x01 \x01(\fR\tsignature\"\xec\x03\n" +
	"\x1dValidateSignatureShareRequest\x12\x1e\n" +
	"\n" +
	"identifier\x18\x01 \x01(\tR\n" +
	"identifier\x12&\n" +
	"\x04role\x18\x02 \x01(\x0e2\x12.frost.SigningRoleR\x04role\x12\x18\n" +
	"\amessage\x18\x03 \x01(\fR\amessage\x12'\n" +
	"\x0fsignature_share\x18\x04 \x01(\fR\x0esignatureShare\x12!\n" +
	"\fpublic_share\x18\x05 \x01(\fR\vpublicShare\x12#\n" +
	"\rverifying_key\x18\x06 \x01(\fR\fverifyingKey\x12W\n" +
	"\vcommitments\x18\a \x03(\v25.frost.ValidateSignatureShareRequest.CommitmentsEntryR\vcommitments\x12D\n" +
	"\x10user_commitments\x18\b \x01(\v2\x19.common.SigningCommitmentR\x0fuserCommitments\x1aY\n" +
	"\x10CommitmentsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12/\n" +
	"\x05value\x18\x02 \x01(\v2\x19.common.SigningCommitmentR\x05value:\x028\x01*'\n" +
	"\vSigningRole\x12\x0e\n" +
	"\n" +
	"STATECHAIN\x10\x00\x12\b\n" +
	"\x04USER\x10\x012\xc1\x04\n" +
	"\fFrostService\x121\n" +
	"\x04echo\x12\x12.frost.EchoRequest\x1a\x13.frost.EchoResponse\"\x00\x12A\n" +
	"\n" +
	"dkg_round1\x12\x17.frost.DkgRound1Request\x1a\x18.frost.DkgRound1Response\"\x00\x12A\n" +
	"\n" +
	"dkg_round2\x12\x17.frost.DkgRound2Request\x1a\x18.frost.DkgRound2Response\"\x00\x12A\n" +
	"\n" +
	"dkg_round3\x12\x17.frost.DkgRound3Request\x1a\x18.frost.DkgRound3Response\"\x00\x12D\n" +
	"\vfrost_nonce\x12\x18.frost.FrostNonceRequest\x1a\x19.frost.FrostNonceResponse\"\x00\x12A\n" +
	"\n" +
	"sign_frost\x12\x17.frost.SignFrostRequest\x1a\x18.frost.SignFrostResponse\"\x00\x12P\n" +
	"\x0faggregate_frost\x12\x1c.frost.AggregateFrostRequest\x1a\x1d.frost.AggregateFrostResponse\"\x00\x12Z\n" +
	"\x18validate_signature_share\x12$.frost.ValidateSignatureShareRequest\x1a\x16.google.protobuf.Empty\"\x00B,Z*github.com/lightsparkdev/spark/proto/frostb\x06proto3"

var (
	file_frost_proto_rawDescOnce sync.Once
	file_frost_proto_rawDescData []byte
)

func file_frost_proto_rawDescGZIP() []byte {
	file_frost_proto_rawDescOnce.Do(func() {
		file_frost_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_frost_proto_rawDesc), len(file_frost_proto_rawDesc)))
	})
	return file_frost_proto_rawDescData
}

var file_frost_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_frost_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
var file_frost_proto_goTypes = []any{
	(SigningRole)(0),                      // 0: frost.SigningRole
	(*EchoRequest)(nil),                   // 1: frost.EchoRequest
	(*EchoResponse)(nil),                  // 2: frost.EchoResponse
	(*DkgRound1Request)(nil),              // 3: frost.DkgRound1Request
	(*DkgRound1Response)(nil),             // 4: frost.DkgRound1Response
	(*DkgRound2Request)(nil),              // 5: frost.DkgRound2Request
	(*DkgRound2Response)(nil),             // 6: frost.DkgRound2Response
	(*DkgRound3Request)(nil),              // 7: frost.DkgRound3Request
	(*KeyPackage)(nil),                    // 8: frost.KeyPackage
	(*DkgRound3Response)(nil),             // 9: frost.DkgRound3Response
	(*SigningNonce)(nil),                  // 10: frost.SigningNonce
	(*FrostNonceRequest)(nil),             // 11: frost.FrostNonceRequest
	(*SigningNonceResult)(nil),            // 12: frost.SigningNonceResult
	(*FrostNonceResponse)(nil),            // 13: frost.FrostNonceResponse
	(*FrostSigningJob)(nil),               // 14: frost.FrostSigningJob
	(*SignFrostRequest)(nil),              // 15: frost.SignFrostRequest
	(*SignFrostResponse)(nil),             // 16: frost.SignFrostResponse
	(*AggregateFrostRequest)(nil),         // 17: frost.AggregateFrostRequest
	(*AggregateFrostResponse)(nil),        // 18: frost.AggregateFrostResponse
	(*ValidateSignatureShareRequest)(nil), // 19: frost.ValidateSignatureShareRequest
	nil,                                   // 20: frost.KeyPackage.PublicSharesEntry
	nil,                                   // 21: frost.FrostSigningJob.CommitmentsEntry
	nil,                                   // 22: frost.SignFrostResponse.ResultsEntry
	nil,                                   // 23: frost.AggregateFrostRequest.SignatureSharesEntry
	nil,                                   // 24: frost.AggregateFrostRequest.PublicSharesEntry
	nil,                                   // 25: frost.AggregateFrostRequest.CommitmentsEntry
	nil,                                   // 26: frost.ValidateSignatureShareRequest.CommitmentsEntry
	(*common.PackageMap)(nil),             // 27: common.PackageMap
	(*common.SigningCommitment)(nil),      // 28: common.SigningCommitment
	(*common.SigningResult)(nil),          // 29: common.SigningResult
	(*emptypb.Empty)(nil),                 // 30: google.protobuf.Empty
}
var file_frost_proto_depIdxs = []int32{
	27, // 0: frost.DkgRound2Request.round1_packages_maps:type_name -> common.PackageMap
	27, // 1: frost.DkgRound2Response.round2_packages:type_name -> common.PackageMap
	27, // 2: frost.DkgRound3Request.round1_packages_maps:type_name -> common.PackageMap
	27, // 3: frost.DkgRound3Request.round2_packages_maps:type_name -> common.PackageMap
	20, // 4: frost.KeyPackage.public_shares:type_name -> frost.KeyPackage.PublicSharesEntry
	8,  // 5: frost.DkgRound3Response.key_packages:type_name -> frost.KeyPackage
	8,  // 6: frost.FrostNonceRequest.key_packages:type_name -> frost.KeyPackage
	10, // 7: frost.SigningNonceResult.nonces:type_name -> frost.SigningNonce
	28, // 8: frost.SigningNonceResult.commitments:type_name -> common.SigningCommitment
	12, // 9: frost.FrostNonceResponse.results:type_name -> frost.SigningNonceResult
	8,  // 10: frost.FrostSigningJob.key_package:type_name -> frost.KeyPackage
	10, // 11: frost.FrostSigningJob.nonce:type_name -> frost.SigningNonce
	21, // 12: frost.FrostSigningJob.commitments:type_name -> frost.FrostSigningJob.CommitmentsEntry
	28, // 13: frost.FrostSigningJob.user_commitments:type_name -> common.SigningCommitment
	14, // 14: frost.SignFrostRequest.signing_jobs:type_name -> frost.FrostSigningJob
	0,  // 15: frost.SignFrostRequest.role:type_name -> frost.SigningRole
	22, // 16: frost.SignFrostResponse.results:type_name -> frost.SignFrostResponse.ResultsEntry
	23, // 17: frost.AggregateFrostRequest.signature_shares:type_name -> frost.AggregateFrostRequest.SignatureSharesEntry
	24, // 18: frost.AggregateFrostRequest.public_shares:type_name -> frost.AggregateFrostRequest.PublicSharesEntry
	25, // 19: frost.AggregateFrostRequest.commitments:type_name -> frost.AggregateFrostRequest.CommitmentsEntry
	28, // 20: frost.AggregateFrostRequest.user_commitments:type_name -> common.SigningCommitment
	0,  // 21: frost.ValidateSignatureShareRequest.role:type_name -> frost.SigningRole
	26, // 22: frost.ValidateSignatureShareRequest.commitments:type_name -> frost.ValidateSignatureShareRequest.CommitmentsEntry
	28, // 23: frost.ValidateSignatureShareRequest.user_commitments:type_name -> common.SigningCommitment
	28, // 24: frost.FrostSigningJob.CommitmentsEntry.value:type_name -> common.SigningCommitment
	29, // 25: frost.SignFrostResponse.ResultsEntry.value:type_name -> common.SigningResult
	28, // 26: frost.AggregateFrostRequest.CommitmentsEntry.value:type_name -> common.SigningCommitment
	28, // 27: frost.ValidateSignatureShareRequest.CommitmentsEntry.value:type_name -> common.SigningCommitment
	1,  // 28: frost.FrostService.echo:input_type -> frost.EchoRequest
	3,  // 29: frost.FrostService.dkg_round1:input_type -> frost.DkgRound1Request
	5,  // 30: frost.FrostService.dkg_round2:input_type -> frost.DkgRound2Request
	7,  // 31: frost.FrostService.dkg_round3:input_type -> frost.DkgRound3Request
	11, // 32: frost.FrostService.frost_nonce:input_type -> frost.FrostNonceRequest
	15, // 33: frost.FrostService.sign_frost:input_type -> frost.SignFrostRequest
	17, // 34: frost.FrostService.aggregate_frost:input_type -> frost.AggregateFrostRequest
	19, // 35: frost.FrostService.validate_signature_share:input_type -> frost.ValidateSignatureShareRequest
	2,  // 36: frost.FrostService.echo:output_type -> frost.EchoResponse
	4,  // 37: frost.FrostService.dkg_round1:output_type -> frost.DkgRound1Response
	6,  // 38: frost.FrostService.dkg_round2:output_type -> frost.DkgRound2Response
	9,  // 39: frost.FrostService.dkg_round3:output_type -> frost.DkgRound3Response
	13, // 40: frost.FrostService.frost_nonce:output_type -> frost.FrostNonceResponse
	16, // 41: frost.FrostService.sign_frost:output_type -> frost.SignFrostResponse
	18, // 42: frost.FrostService.aggregate_frost:output_type -> frost.AggregateFrostResponse
	30, // 43: frost.FrostService.validate_signature_share:output_type -> google.protobuf.Empty
	36, // [36:44] is the sub-list for method output_type
	28, // [28:36] is the sub-list for method input_type
	28, // [28:28] is the sub-list for extension type_name
	28, // [28:28] is the sub-list for extension extendee
	0,  // [0:28] is the sub-list for field type_name
}

func init() { file_frost_proto_init() }
func file_frost_proto_init() {
	if File_frost_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_frost_proto_rawDesc), len(file_frost_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   26,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_frost_proto_goTypes,
		DependencyIndexes: file_frost_proto_depIdxs,
		EnumInfos:         file_frost_proto_enumTypes,
		MessageInfos:      file_frost_proto_msgTypes,
	}.Build()
	File_frost_proto = out.File
	file_frost_proto_goTypes = nil
	file_frost_proto_depIdxs = nil
}
