// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v3.21.12
// source: signrpc/signer.proto

package signrpc

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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)
)

type SignMethod int32

const (
	// Specifies that a SegWit v0 (p2wkh, np2wkh, p2wsh) input script should be
	// signed.
	SignMethod_SIGN_METHOD_WITNESS_V0 SignMethod = 0
	// Specifies that a SegWit v1 (p2tr) input should be signed by using the
	// BIP0086 method (commit to internal key only).
	SignMethod_SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086 SignMethod = 1
	// Specifies that a SegWit v1 (p2tr) input should be signed by using a given
	// taproot hash to commit to in addition to the internal key.
	SignMethod_SIGN_METHOD_TAPROOT_KEY_SPEND SignMethod = 2
	// Specifies that a SegWit v1 (p2tr) input should be spent using the script
	// path and that a specific leaf script should be signed for.
	SignMethod_SIGN_METHOD_TAPROOT_SCRIPT_SPEND SignMethod = 3
)

// Enum value maps for SignMethod.
var (
	SignMethod_name = map[int32]string{
		0: "SIGN_METHOD_WITNESS_V0",
		1: "SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086",
		2: "SIGN_METHOD_TAPROOT_KEY_SPEND",
		3: "SIGN_METHOD_TAPROOT_SCRIPT_SPEND",
	}
	SignMethod_value = map[string]int32{
		"SIGN_METHOD_WITNESS_V0":                0,
		"SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086": 1,
		"SIGN_METHOD_TAPROOT_KEY_SPEND":         2,
		"SIGN_METHOD_TAPROOT_SCRIPT_SPEND":      3,
	}
)

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

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

func (SignMethod) Descriptor() protoreflect.EnumDescriptor {
	return file_signrpc_signer_proto_enumTypes[0].Descriptor()
}

func (SignMethod) Type() protoreflect.EnumType {
	return &file_signrpc_signer_proto_enumTypes[0]
}

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

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

type MuSig2Version int32

const (
	// The default value on the RPC is zero for enums so we need to represent an
	// invalid/undefined version by default to make sure clients upgrade their
	// software to set the version explicitly.
	MuSig2Version_MUSIG2_VERSION_UNDEFINED MuSig2Version = 0
	// The version of MuSig2 that lnd 0.15.x shipped with, which corresponds to the
	// version v0.4.0 of the MuSig2 BIP draft.
	MuSig2Version_MUSIG2_VERSION_V040 MuSig2Version = 1
	// The current version of MuSig2 which corresponds to the version v1.0.0rc2 of
	// the MuSig2 BIP draft.
	MuSig2Version_MUSIG2_VERSION_V100RC2 MuSig2Version = 2
)

// Enum value maps for MuSig2Version.
var (
	MuSig2Version_name = map[int32]string{
		0: "MUSIG2_VERSION_UNDEFINED",
		1: "MUSIG2_VERSION_V040",
		2: "MUSIG2_VERSION_V100RC2",
	}
	MuSig2Version_value = map[string]int32{
		"MUSIG2_VERSION_UNDEFINED": 0,
		"MUSIG2_VERSION_V040":      1,
		"MUSIG2_VERSION_V100RC2":   2,
	}
)

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

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

func (MuSig2Version) Descriptor() protoreflect.EnumDescriptor {
	return file_signrpc_signer_proto_enumTypes[1].Descriptor()
}

func (MuSig2Version) Type() protoreflect.EnumType {
	return &file_signrpc_signer_proto_enumTypes[1]
}

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

// Deprecated: Use MuSig2Version.Descriptor instead.
func (MuSig2Version) EnumDescriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{1}
}

type KeyLocator struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The family of key being identified.
	KeyFamily int32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"`
	// The precise index of the key being identified.
	KeyIndex      int32 `protobuf:"varint,2,opt,name=key_index,json=keyIndex,proto3" json:"key_index,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyLocator) ProtoMessage() {}

func (x *KeyLocator) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 KeyLocator.ProtoReflect.Descriptor instead.
func (*KeyLocator) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{0}
}

func (x *KeyLocator) GetKeyFamily() int32 {
	if x != nil {
		return x.KeyFamily
	}
	return 0
}

func (x *KeyLocator) GetKeyIndex() int32 {
	if x != nil {
		return x.KeyIndex
	}
	return 0
}

type KeyDescriptor struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The raw bytes of the public key in the key pair being identified. Either
	// this or the KeyLocator must be specified.
	RawKeyBytes []byte `protobuf:"bytes,1,opt,name=raw_key_bytes,json=rawKeyBytes,proto3" json:"raw_key_bytes,omitempty"`
	// The key locator that identifies which private key to use for signing.
	// Either this or the raw bytes of the target public key must be specified.
	KeyLoc        *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyDescriptor) ProtoMessage() {}

func (x *KeyDescriptor) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 KeyDescriptor.ProtoReflect.Descriptor instead.
func (*KeyDescriptor) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{1}
}

func (x *KeyDescriptor) GetRawKeyBytes() []byte {
	if x != nil {
		return x.RawKeyBytes
	}
	return nil
}

func (x *KeyDescriptor) GetKeyLoc() *KeyLocator {
	if x != nil {
		return x.KeyLoc
	}
	return nil
}

type TxOut struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The value of the output being spent.
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// The script of the output being spent.
	PkScript      []byte `protobuf:"bytes,2,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TxOut) ProtoMessage() {}

func (x *TxOut) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 TxOut.ProtoReflect.Descriptor instead.
func (*TxOut) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{2}
}

func (x *TxOut) GetValue() int64 {
	if x != nil {
		return x.Value
	}
	return 0
}

func (x *TxOut) GetPkScript() []byte {
	if x != nil {
		return x.PkScript
	}
	return nil
}

type SignDescriptor struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A descriptor that precisely describes *which* key to use for signing. This
	// may provide the raw public key directly, or require the Signer to re-derive
	// the key according to the populated derivation path.
	//
	// Note that if the key descriptor was obtained through walletrpc.DeriveKey,
	// then the key locator MUST always be provided, since the derived keys are not
	// persisted unlike with DeriveNextKey.
	KeyDesc *KeyDescriptor `protobuf:"bytes,1,opt,name=key_desc,json=keyDesc,proto3" json:"key_desc,omitempty"`
	// A scalar value that will be added to the private key corresponding to the
	// above public key to obtain the private key to be used to sign this input.
	// This value is typically derived via the following computation:
	//
	// derivedKey = privkey + sha256(perCommitmentPoint || pubKey) mod N
	SingleTweak []byte `protobuf:"bytes,2,opt,name=single_tweak,json=singleTweak,proto3" json:"single_tweak,omitempty"`
	// A private key that will be used in combination with its corresponding
	// private key to derive the private key that is to be used to sign the target
	// input. Within the Lightning protocol, this value is typically the
	// commitment secret from a previously revoked commitment transaction. This
	// value is in combination with two hash values, and the original private key
	// to derive the private key to be used when signing.
	//
	// k = (privKey*sha256(pubKey || tweakPub) +
	// tweakPriv*sha256(tweakPub || pubKey)) mod N
	DoubleTweak []byte `protobuf:"bytes,3,opt,name=double_tweak,json=doubleTweak,proto3" json:"double_tweak,omitempty"`
	// The 32 byte input to the taproot tweak derivation that is used to derive
	// the output key from an internal key: outputKey = internalKey +
	// tagged_hash("tapTweak", internalKey || tapTweak).
	//
	// When doing a BIP 86 spend, this field can be an empty byte slice.
	//
	// When doing a normal key path spend, with the output key committing to an
	// actual script root, then this field should be: the tapscript root hash.
	TapTweak []byte `protobuf:"bytes,10,opt,name=tap_tweak,json=tapTweak,proto3" json:"tap_tweak,omitempty"`
	// The full script required to properly redeem the output. This field will
	// only be populated if a p2tr, p2wsh or a p2sh output is being signed. If a
	// taproot script path spend is being attempted, then this should be the raw
	// leaf script.
	WitnessScript []byte `protobuf:"bytes,4,opt,name=witness_script,json=witnessScript,proto3" json:"witness_script,omitempty"`
	// A description of the output being spent. The value and script MUST be
	// provided.
	Output *TxOut `protobuf:"bytes,5,opt,name=output,proto3" json:"output,omitempty"`
	// The target sighash type that should be used when generating the final
	// sighash, and signature.
	Sighash uint32 `protobuf:"varint,7,opt,name=sighash,proto3" json:"sighash,omitempty"`
	// The target input within the transaction that should be signed.
	InputIndex int32 `protobuf:"varint,8,opt,name=input_index,json=inputIndex,proto3" json:"input_index,omitempty"`
	// The sign method specifies how the input should be signed. Depending on the
	// method, either the tap_tweak, witness_script or both need to be specified.
	// Defaults to SegWit v0 signing to be backward compatible with older RPC
	// clients.
	SignMethod    SignMethod `protobuf:"varint,9,opt,name=sign_method,json=signMethod,proto3,enum=signrpc.SignMethod" json:"sign_method,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignDescriptor) ProtoMessage() {}

func (x *SignDescriptor) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SignDescriptor.ProtoReflect.Descriptor instead.
func (*SignDescriptor) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{3}
}

func (x *SignDescriptor) GetKeyDesc() *KeyDescriptor {
	if x != nil {
		return x.KeyDesc
	}
	return nil
}

func (x *SignDescriptor) GetSingleTweak() []byte {
	if x != nil {
		return x.SingleTweak
	}
	return nil
}

func (x *SignDescriptor) GetDoubleTweak() []byte {
	if x != nil {
		return x.DoubleTweak
	}
	return nil
}

func (x *SignDescriptor) GetTapTweak() []byte {
	if x != nil {
		return x.TapTweak
	}
	return nil
}

func (x *SignDescriptor) GetWitnessScript() []byte {
	if x != nil {
		return x.WitnessScript
	}
	return nil
}

func (x *SignDescriptor) GetOutput() *TxOut {
	if x != nil {
		return x.Output
	}
	return nil
}

func (x *SignDescriptor) GetSighash() uint32 {
	if x != nil {
		return x.Sighash
	}
	return 0
}

func (x *SignDescriptor) GetInputIndex() int32 {
	if x != nil {
		return x.InputIndex
	}
	return 0
}

func (x *SignDescriptor) GetSignMethod() SignMethod {
	if x != nil {
		return x.SignMethod
	}
	return SignMethod_SIGN_METHOD_WITNESS_V0
}

type SignReq struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The raw bytes of the transaction to be signed.
	RawTxBytes []byte `protobuf:"bytes,1,opt,name=raw_tx_bytes,json=rawTxBytes,proto3" json:"raw_tx_bytes,omitempty"`
	// A set of sign descriptors, for each input to be signed.
	SignDescs []*SignDescriptor `protobuf:"bytes,2,rep,name=sign_descs,json=signDescs,proto3" json:"sign_descs,omitempty"`
	// The full list of UTXO information for each of the inputs being spent. This
	// is required when spending one or more taproot (SegWit v1) outputs.
	PrevOutputs   []*TxOut `protobuf:"bytes,3,rep,name=prev_outputs,json=prevOutputs,proto3" json:"prev_outputs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignReq) ProtoMessage() {}

func (x *SignReq) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SignReq.ProtoReflect.Descriptor instead.
func (*SignReq) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{4}
}

func (x *SignReq) GetRawTxBytes() []byte {
	if x != nil {
		return x.RawTxBytes
	}
	return nil
}

func (x *SignReq) GetSignDescs() []*SignDescriptor {
	if x != nil {
		return x.SignDescs
	}
	return nil
}

func (x *SignReq) GetPrevOutputs() []*TxOut {
	if x != nil {
		return x.PrevOutputs
	}
	return nil
}

type SignResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A set of signatures realized in a fixed 64-byte format ordered in ascending
	// input order.
	RawSigs       [][]byte `protobuf:"bytes,1,rep,name=raw_sigs,json=rawSigs,proto3" json:"raw_sigs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignResp) ProtoMessage() {}

func (x *SignResp) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SignResp.ProtoReflect.Descriptor instead.
func (*SignResp) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{5}
}

func (x *SignResp) GetRawSigs() [][]byte {
	if x != nil {
		return x.RawSigs
	}
	return nil
}

type InputScript struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The serializes witness stack for the specified input.
	Witness [][]byte `protobuf:"bytes,1,rep,name=witness,proto3" json:"witness,omitempty"`
	// The optional sig script for the specified witness that will only be set if
	// the input specified is a nested p2sh witness program.
	SigScript     []byte `protobuf:"bytes,2,opt,name=sig_script,json=sigScript,proto3" json:"sig_script,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InputScript) ProtoMessage() {}

func (x *InputScript) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 InputScript.ProtoReflect.Descriptor instead.
func (*InputScript) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{6}
}

func (x *InputScript) GetWitness() [][]byte {
	if x != nil {
		return x.Witness
	}
	return nil
}

func (x *InputScript) GetSigScript() []byte {
	if x != nil {
		return x.SigScript
	}
	return nil
}

type InputScriptResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The set of fully valid input scripts requested.
	InputScripts  []*InputScript `protobuf:"bytes,1,rep,name=input_scripts,json=inputScripts,proto3" json:"input_scripts,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InputScriptResp) ProtoMessage() {}

func (x *InputScriptResp) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 InputScriptResp.ProtoReflect.Descriptor instead.
func (*InputScriptResp) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{7}
}

func (x *InputScriptResp) GetInputScripts() []*InputScript {
	if x != nil {
		return x.InputScripts
	}
	return nil
}

type SignMessageReq struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The message to be signed. When using REST, this field must be encoded as
	// base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The key locator that identifies which key to use for signing.
	KeyLoc *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	// Double-SHA256 hash instead of just the default single round.
	DoubleHash bool `protobuf:"varint,3,opt,name=double_hash,json=doubleHash,proto3" json:"double_hash,omitempty"`
	// Use the compact (pubkey recoverable) format instead of the raw lnwire
	// format. This option cannot be used with Schnorr signatures.
	CompactSig bool `protobuf:"varint,4,opt,name=compact_sig,json=compactSig,proto3" json:"compact_sig,omitempty"`
	// Use Schnorr signature. This option cannot be used with compact format.
	SchnorrSig bool `protobuf:"varint,5,opt,name=schnorr_sig,json=schnorrSig,proto3" json:"schnorr_sig,omitempty"`
	// The optional Taproot tweak bytes to apply to the private key before creating
	// a Schnorr signature. The private key is tweaked as described in BIP-341:
	// privKey + h_tapTweak(internalKey || tapTweak)
	SchnorrSigTapTweak []byte `protobuf:"bytes,6,opt,name=schnorr_sig_tap_tweak,json=schnorrSigTapTweak,proto3" json:"schnorr_sig_tap_tweak,omitempty"`
	// An optional tag that can be provided when taking a tagged hash of a
	// message. This option can only be used when schnorr_sig is true.
	Tag           []byte `protobuf:"bytes,7,opt,name=tag,proto3" json:"tag,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignMessageReq) ProtoMessage() {}

func (x *SignMessageReq) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SignMessageReq.ProtoReflect.Descriptor instead.
func (*SignMessageReq) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{8}
}

func (x *SignMessageReq) GetMsg() []byte {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *SignMessageReq) GetKeyLoc() *KeyLocator {
	if x != nil {
		return x.KeyLoc
	}
	return nil
}

func (x *SignMessageReq) GetDoubleHash() bool {
	if x != nil {
		return x.DoubleHash
	}
	return false
}

func (x *SignMessageReq) GetCompactSig() bool {
	if x != nil {
		return x.CompactSig
	}
	return false
}

func (x *SignMessageReq) GetSchnorrSig() bool {
	if x != nil {
		return x.SchnorrSig
	}
	return false
}

func (x *SignMessageReq) GetSchnorrSigTapTweak() []byte {
	if x != nil {
		return x.SchnorrSigTapTweak
	}
	return nil
}

func (x *SignMessageReq) GetTag() []byte {
	if x != nil {
		return x.Tag
	}
	return nil
}

type SignMessageResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The signature for the given message in the fixed-size LN wire format.
	Signature     []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SignMessageResp) ProtoMessage() {}

func (x *SignMessageResp) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SignMessageResp.ProtoReflect.Descriptor instead.
func (*SignMessageResp) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{9}
}

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

type VerifyMessageReq struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The message over which the signature is to be verified. When using
	// REST, this field must be encoded as base64.
	Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"`
	// The fixed-size LN wire encoded signature to be verified over the given
	// message. When using REST, this field must be encoded as base64.
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// The public key the signature has to be valid for. When using REST, this
	// field must be encoded as base64. If the is_schnorr_sig option is true, then
	// the public key is expected to be in the 32-byte x-only serialization
	// according to BIP-340.
	Pubkey []byte `protobuf:"bytes,3,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	// Specifies if the signature is a Schnorr signature.
	IsSchnorrSig bool `protobuf:"varint,4,opt,name=is_schnorr_sig,json=isSchnorrSig,proto3" json:"is_schnorr_sig,omitempty"`
	// An optional tag that can be provided when taking a tagged hash of a
	// message. This option can only be used when is_schnorr_sig is true.
	Tag           []byte `protobuf:"bytes,5,opt,name=tag,proto3" json:"tag,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*VerifyMessageReq) ProtoMessage() {}

func (x *VerifyMessageReq) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 VerifyMessageReq.ProtoReflect.Descriptor instead.
func (*VerifyMessageReq) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{10}
}

func (x *VerifyMessageReq) GetMsg() []byte {
	if x != nil {
		return x.Msg
	}
	return nil
}

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

func (x *VerifyMessageReq) GetPubkey() []byte {
	if x != nil {
		return x.Pubkey
	}
	return nil
}

func (x *VerifyMessageReq) GetIsSchnorrSig() bool {
	if x != nil {
		return x.IsSchnorrSig
	}
	return false
}

func (x *VerifyMessageReq) GetTag() []byte {
	if x != nil {
		return x.Tag
	}
	return nil
}

type VerifyMessageResp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Whether the signature was valid over the given message.
	Valid         bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*VerifyMessageResp) ProtoMessage() {}

func (x *VerifyMessageResp) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 VerifyMessageResp.ProtoReflect.Descriptor instead.
func (*VerifyMessageResp) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{11}
}

func (x *VerifyMessageResp) GetValid() bool {
	if x != nil {
		return x.Valid
	}
	return false
}

type SharedKeyRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ephemeral public key to use for the DH key derivation.
	EphemeralPubkey []byte `protobuf:"bytes,1,opt,name=ephemeral_pubkey,json=ephemeralPubkey,proto3" json:"ephemeral_pubkey,omitempty"`
	// Deprecated. The optional key locator of the local key that should be used.
	// If this parameter is not set then the node's identity private key will be
	// used.
	//
	// Deprecated: Marked as deprecated in signrpc/signer.proto.
	KeyLoc *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	// A key descriptor describes the key used for performing ECDH. Either a key
	// locator or a raw public key is expected, if neither is supplied, defaults to
	// the node's identity private key.
	KeyDesc       *KeyDescriptor `protobuf:"bytes,3,opt,name=key_desc,json=keyDesc,proto3" json:"key_desc,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SharedKeyRequest) ProtoMessage() {}

func (x *SharedKeyRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SharedKeyRequest.ProtoReflect.Descriptor instead.
func (*SharedKeyRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{12}
}

func (x *SharedKeyRequest) GetEphemeralPubkey() []byte {
	if x != nil {
		return x.EphemeralPubkey
	}
	return nil
}

// Deprecated: Marked as deprecated in signrpc/signer.proto.
func (x *SharedKeyRequest) GetKeyLoc() *KeyLocator {
	if x != nil {
		return x.KeyLoc
	}
	return nil
}

func (x *SharedKeyRequest) GetKeyDesc() *KeyDescriptor {
	if x != nil {
		return x.KeyDesc
	}
	return nil
}

type SharedKeyResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The shared public key, hashed with sha256.
	SharedKey     []byte `protobuf:"bytes,1,opt,name=shared_key,json=sharedKey,proto3" json:"shared_key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SharedKeyResponse) ProtoMessage() {}

func (x *SharedKeyResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 SharedKeyResponse.ProtoReflect.Descriptor instead.
func (*SharedKeyResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{13}
}

func (x *SharedKeyResponse) GetSharedKey() []byte {
	if x != nil {
		return x.SharedKey
	}
	return nil
}

type TweakDesc struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Tweak is the 32-byte value that will modify the public key.
	Tweak []byte `protobuf:"bytes,1,opt,name=tweak,proto3" json:"tweak,omitempty"`
	// Specifies if the target key should be converted to an x-only public key
	// before tweaking. If true, then the public key will be mapped to an x-only
	// key before the tweaking operation is applied.
	IsXOnly       bool `protobuf:"varint,2,opt,name=is_x_only,json=isXOnly,proto3" json:"is_x_only,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TweakDesc) ProtoMessage() {}

func (x *TweakDesc) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 TweakDesc.ProtoReflect.Descriptor instead.
func (*TweakDesc) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{14}
}

func (x *TweakDesc) GetTweak() []byte {
	if x != nil {
		return x.Tweak
	}
	return nil
}

func (x *TweakDesc) GetIsXOnly() bool {
	if x != nil {
		return x.IsXOnly
	}
	return false
}

type TaprootTweakDesc struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The root hash of the tapscript tree if a script path is committed to. If
	// the MuSig2 key put on chain doesn't also commit to a script path (BIP-0086
	// key spend only), then this needs to be empty and the key_spend_only field
	// below must be set to true. This is required because gRPC cannot
	// differentiate between a zero-size byte slice and a nil byte slice (both
	// would be serialized the same way). So the extra boolean is required.
	ScriptRoot []byte `protobuf:"bytes,1,opt,name=script_root,json=scriptRoot,proto3" json:"script_root,omitempty"`
	// Indicates that the above script_root is expected to be empty because this
	// is a BIP-0086 key spend only commitment where only the internal key is
	// committed to instead of also including a script root hash.
	KeySpendOnly  bool `protobuf:"varint,2,opt,name=key_spend_only,json=keySpendOnly,proto3" json:"key_spend_only,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TaprootTweakDesc) ProtoMessage() {}

func (x *TaprootTweakDesc) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 TaprootTweakDesc.ProtoReflect.Descriptor instead.
func (*TaprootTweakDesc) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{15}
}

func (x *TaprootTweakDesc) GetScriptRoot() []byte {
	if x != nil {
		return x.ScriptRoot
	}
	return nil
}

func (x *TaprootTweakDesc) GetKeySpendOnly() bool {
	if x != nil {
		return x.KeySpendOnly
	}
	return false
}

type MuSig2CombineKeysRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of all public keys (serialized in 32-byte x-only format for v0.4.0
	// and 33-byte compressed format for v1.0.0rc2!) participating in the signing
	// session. The list will always be sorted lexicographically internally. This
	// must include the local key which is described by the above key_loc.
	AllSignerPubkeys [][]byte `protobuf:"bytes,1,rep,name=all_signer_pubkeys,json=allSignerPubkeys,proto3" json:"all_signer_pubkeys,omitempty"`
	// A series of optional generic tweaks to be applied to the aggregated
	// public key.
	Tweaks []*TweakDesc `protobuf:"bytes,2,rep,name=tweaks,proto3" json:"tweaks,omitempty"`
	// An optional taproot specific tweak that must be specified if the MuSig2
	// combined key will be used as the main taproot key of a taproot output
	// on-chain.
	TaprootTweak *TaprootTweakDesc `protobuf:"bytes,3,opt,name=taproot_tweak,json=taprootTweak,proto3" json:"taproot_tweak,omitempty"`
	// The mandatory version of the MuSig2 BIP draft to use. This is necessary to
	// differentiate between the changes that were made to the BIP while this
	// experimental RPC was already released. Some of those changes affect how the
	// combined key and nonces are created.
	Version       MuSig2Version `protobuf:"varint,4,opt,name=version,proto3,enum=signrpc.MuSig2Version" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuSig2CombineKeysRequest) ProtoMessage() {}

func (x *MuSig2CombineKeysRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 MuSig2CombineKeysRequest.ProtoReflect.Descriptor instead.
func (*MuSig2CombineKeysRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{16}
}

func (x *MuSig2CombineKeysRequest) GetAllSignerPubkeys() [][]byte {
	if x != nil {
		return x.AllSignerPubkeys
	}
	return nil
}

func (x *MuSig2CombineKeysRequest) GetTweaks() []*TweakDesc {
	if x != nil {
		return x.Tweaks
	}
	return nil
}

func (x *MuSig2CombineKeysRequest) GetTaprootTweak() *TaprootTweakDesc {
	if x != nil {
		return x.TaprootTweak
	}
	return nil
}

func (x *MuSig2CombineKeysRequest) GetVersion() MuSig2Version {
	if x != nil {
		return x.Version
	}
	return MuSig2Version_MUSIG2_VERSION_UNDEFINED
}

type MuSig2CombineKeysResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The combined public key (in the 32-byte x-only format) with all tweaks
	// applied to it. If a taproot tweak is specified, this corresponds to the
	// taproot key that can be put into the on-chain output.
	CombinedKey []byte `protobuf:"bytes,1,opt,name=combined_key,json=combinedKey,proto3" json:"combined_key,omitempty"`
	// The raw combined public key (in the 32-byte x-only format) before any tweaks
	// are applied to it. If a taproot tweak is specified, this corresponds to the
	// internal key that needs to be put into the witness if the script spend path
	// is used.
	TaprootInternalKey []byte `protobuf:"bytes,2,opt,name=taproot_internal_key,json=taprootInternalKey,proto3" json:"taproot_internal_key,omitempty"`
	// The version of the MuSig2 BIP that was used to combine the keys.
	Version       MuSig2Version `protobuf:"varint,4,opt,name=version,proto3,enum=signrpc.MuSig2Version" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MuSig2CombineKeysResponse) ProtoMessage() {}

func (x *MuSig2CombineKeysResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 MuSig2CombineKeysResponse.ProtoReflect.Descriptor instead.
func (*MuSig2CombineKeysResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{17}
}

func (x *MuSig2CombineKeysResponse) GetCombinedKey() []byte {
	if x != nil {
		return x.CombinedKey
	}
	return nil
}

func (x *MuSig2CombineKeysResponse) GetTaprootInternalKey() []byte {
	if x != nil {
		return x.TaprootInternalKey
	}
	return nil
}

func (x *MuSig2CombineKeysResponse) GetVersion() MuSig2Version {
	if x != nil {
		return x.Version
	}
	return MuSig2Version_MUSIG2_VERSION_UNDEFINED
}

type MuSig2SessionRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The key locator that identifies which key to use for signing.
	KeyLoc *KeyLocator `protobuf:"bytes,1,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	// A list of all public keys (serialized in 32-byte x-only format for v0.4.0
	// and 33-byte compressed format for v1.0.0rc2!) participating in the signing
	// session. The list will always be sorted lexicographically internally. This
	// must include the local key which is described by the above key_loc.
	AllSignerPubkeys [][]byte `protobuf:"bytes,2,rep,name=all_signer_pubkeys,json=allSignerPubkeys,proto3" json:"all_signer_pubkeys,omitempty"`
	// An optional list of all public nonces of other signing participants that
	// might already be known.
	OtherSignerPublicNonces [][]byte `protobuf:"bytes,3,rep,name=other_signer_public_nonces,json=otherSignerPublicNonces,proto3" json:"other_signer_public_nonces,omitempty"`
	// A series of optional generic tweaks to be applied to the aggregated
	// public key.
	Tweaks []*TweakDesc `protobuf:"bytes,4,rep,name=tweaks,proto3" json:"tweaks,omitempty"`
	// An optional taproot specific tweak that must be specified if the MuSig2
	// combined key will be used as the main taproot key of a taproot output
	// on-chain.
	TaprootTweak *TaprootTweakDesc `protobuf:"bytes,5,opt,name=taproot_tweak,json=taprootTweak,proto3" json:"taproot_tweak,omitempty"`
	// The mandatory version of the MuSig2 BIP draft to use. This is necessary to
	// differentiate between the changes that were made to the BIP while this
	// experimental RPC was already released. Some of those changes affect how the
	// combined key and nonces are created.
	Version MuSig2Version `protobuf:"varint,6,opt,name=version,proto3,enum=signrpc.MuSig2Version" json:"version,omitempty"`
	// A set of pre generated secret local nonces to use in the musig2 session.
	// This field is optional. This can be useful for protocols that need to send
	// nonces ahead of time before the set of signer keys are known. This value
	// MUST be 97 bytes and be the concatenation of two CSPRNG generated 32 byte
	// values and local public key used for signing as specified in the key_loc
	// field.
	PregeneratedLocalNonce []byte `protobuf:"bytes,7,opt,name=pregenerated_local_nonce,json=pregeneratedLocalNonce,proto3" json:"pregenerated_local_nonce,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

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

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

func (*MuSig2SessionRequest) ProtoMessage() {}

func (x *MuSig2SessionRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_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 MuSig2SessionRequest.ProtoReflect.Descriptor instead.
func (*MuSig2SessionRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{18}
}

func (x *MuSig2SessionRequest) GetKeyLoc() *KeyLocator {
	if x != nil {
		return x.KeyLoc
	}
	return nil
}

func (x *MuSig2SessionRequest) GetAllSignerPubkeys() [][]byte {
	if x != nil {
		return x.AllSignerPubkeys
	}
	return nil
}

func (x *MuSig2SessionRequest) GetOtherSignerPublicNonces() [][]byte {
	if x != nil {
		return x.OtherSignerPublicNonces
	}
	return nil
}

func (x *MuSig2SessionRequest) GetTweaks() []*TweakDesc {
	if x != nil {
		return x.Tweaks
	}
	return nil
}

func (x *MuSig2SessionRequest) GetTaprootTweak() *TaprootTweakDesc {
	if x != nil {
		return x.TaprootTweak
	}
	return nil
}

func (x *MuSig2SessionRequest) GetVersion() MuSig2Version {
	if x != nil {
		return x.Version
	}
	return MuSig2Version_MUSIG2_VERSION_UNDEFINED
}

func (x *MuSig2SessionRequest) GetPregeneratedLocalNonce() []byte {
	if x != nil {
		return x.PregeneratedLocalNonce
	}
	return nil
}

type MuSig2SessionResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID that represents this signing session. A session can be used
	// for producing a signature a single time. If the signing fails for any
	// reason, a new session with the same participants needs to be created.
	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// The combined public key (in the 32-byte x-only format) with all tweaks
	// applied to it. If a taproot tweak is specified, this corresponds to the
	// taproot key that can be put into the on-chain output.
	CombinedKey []byte `protobuf:"bytes,2,opt,name=combined_key,json=combinedKey,proto3" json:"combined_key,omitempty"`
	// The raw combined public key (in the 32-byte x-only format) before any tweaks
	// are applied to it. If a taproot tweak is specified, this corresponds to the
	// internal key that needs to be put into the witness if the script spend path
	// is used.
	TaprootInternalKey []byte `protobuf:"bytes,3,opt,name=taproot_internal_key,json=taprootInternalKey,proto3" json:"taproot_internal_key,omitempty"`
	// The two public nonces the local signer uses, combined into a single value
	// of 66 bytes. Can be split into the two 33-byte points to get the individual
	// nonces.
	LocalPublicNonces []byte `protobuf:"bytes,4,opt,name=local_public_nonces,json=localPublicNonces,proto3" json:"local_public_nonces,omitempty"`
	// Indicates whether all nonces required to start the signing process are known
	// now.
	HaveAllNonces bool `protobuf:"varint,5,opt,name=have_all_nonces,json=haveAllNonces,proto3" json:"have_all_nonces,omitempty"`
	// The version of the MuSig2 BIP that was used to create the session.
	Version       MuSig2Version `protobuf:"varint,6,opt,name=version,proto3,enum=signrpc.MuSig2Version" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2SessionResponse) Reset() {
	*x = MuSig2SessionResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2SessionResponse) ProtoMessage() {}

func (x *MuSig2SessionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[19]
	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 MuSig2SessionResponse.ProtoReflect.Descriptor instead.
func (*MuSig2SessionResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{19}
}

func (x *MuSig2SessionResponse) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *MuSig2SessionResponse) GetCombinedKey() []byte {
	if x != nil {
		return x.CombinedKey
	}
	return nil
}

func (x *MuSig2SessionResponse) GetTaprootInternalKey() []byte {
	if x != nil {
		return x.TaprootInternalKey
	}
	return nil
}

func (x *MuSig2SessionResponse) GetLocalPublicNonces() []byte {
	if x != nil {
		return x.LocalPublicNonces
	}
	return nil
}

func (x *MuSig2SessionResponse) GetHaveAllNonces() bool {
	if x != nil {
		return x.HaveAllNonces
	}
	return false
}

func (x *MuSig2SessionResponse) GetVersion() MuSig2Version {
	if x != nil {
		return x.Version
	}
	return MuSig2Version_MUSIG2_VERSION_UNDEFINED
}

type MuSig2RegisterNoncesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session those nonces should be registered with.
	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// A list of all public nonces of other signing participants that should be
	// registered.
	OtherSignerPublicNonces [][]byte `protobuf:"bytes,3,rep,name=other_signer_public_nonces,json=otherSignerPublicNonces,proto3" json:"other_signer_public_nonces,omitempty"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

func (x *MuSig2RegisterNoncesRequest) Reset() {
	*x = MuSig2RegisterNoncesRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2RegisterNoncesRequest) ProtoMessage() {}

func (x *MuSig2RegisterNoncesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[20]
	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 MuSig2RegisterNoncesRequest.ProtoReflect.Descriptor instead.
func (*MuSig2RegisterNoncesRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{20}
}

func (x *MuSig2RegisterNoncesRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *MuSig2RegisterNoncesRequest) GetOtherSignerPublicNonces() [][]byte {
	if x != nil {
		return x.OtherSignerPublicNonces
	}
	return nil
}

type MuSig2RegisterNoncesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Indicates whether all nonces required to start the signing process are known
	// now.
	HaveAllNonces bool `protobuf:"varint,1,opt,name=have_all_nonces,json=haveAllNonces,proto3" json:"have_all_nonces,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2RegisterNoncesResponse) Reset() {
	*x = MuSig2RegisterNoncesResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2RegisterNoncesResponse) ProtoMessage() {}

func (x *MuSig2RegisterNoncesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[21]
	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 MuSig2RegisterNoncesResponse.ProtoReflect.Descriptor instead.
func (*MuSig2RegisterNoncesResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{21}
}

func (x *MuSig2RegisterNoncesResponse) GetHaveAllNonces() bool {
	if x != nil {
		return x.HaveAllNonces
	}
	return false
}

type MuSig2RegisterCombinedNonceRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session the combined nonce should be registered
	// with.
	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// The 66-byte combined public nonce that was aggregated externally. This is a
	// concatenation of two 33-byte compressed public keys (R1 || R2).
	CombinedPublicNonce []byte `protobuf:"bytes,2,opt,name=combined_public_nonce,json=combinedPublicNonce,proto3" json:"combined_public_nonce,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *MuSig2RegisterCombinedNonceRequest) Reset() {
	*x = MuSig2RegisterCombinedNonceRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2RegisterCombinedNonceRequest) ProtoMessage() {}

func (x *MuSig2RegisterCombinedNonceRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[22]
	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 MuSig2RegisterCombinedNonceRequest.ProtoReflect.Descriptor instead.
func (*MuSig2RegisterCombinedNonceRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{22}
}

func (x *MuSig2RegisterCombinedNonceRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *MuSig2RegisterCombinedNonceRequest) GetCombinedPublicNonce() []byte {
	if x != nil {
		return x.CombinedPublicNonce
	}
	return nil
}

type MuSig2RegisterCombinedNonceResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2RegisterCombinedNonceResponse) Reset() {
	*x = MuSig2RegisterCombinedNonceResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2RegisterCombinedNonceResponse) ProtoMessage() {}

func (x *MuSig2RegisterCombinedNonceResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[23]
	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 MuSig2RegisterCombinedNonceResponse.ProtoReflect.Descriptor instead.
func (*MuSig2RegisterCombinedNonceResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{23}
}

type MuSig2GetCombinedNonceRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session to get the combined nonce for.
	SessionId     []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2GetCombinedNonceRequest) Reset() {
	*x = MuSig2GetCombinedNonceRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2GetCombinedNonceRequest) ProtoMessage() {}

func (x *MuSig2GetCombinedNonceRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[24]
	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 MuSig2GetCombinedNonceRequest.ProtoReflect.Descriptor instead.
func (*MuSig2GetCombinedNonceRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{24}
}

func (x *MuSig2GetCombinedNonceRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

type MuSig2GetCombinedNonceResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The 66-byte combined public nonce. This is a concatenation of two 33-byte
	// compressed public keys (R1 || R2).
	CombinedPublicNonce []byte `protobuf:"bytes,1,opt,name=combined_public_nonce,json=combinedPublicNonce,proto3" json:"combined_public_nonce,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *MuSig2GetCombinedNonceResponse) Reset() {
	*x = MuSig2GetCombinedNonceResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2GetCombinedNonceResponse) ProtoMessage() {}

func (x *MuSig2GetCombinedNonceResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[25]
	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 MuSig2GetCombinedNonceResponse.ProtoReflect.Descriptor instead.
func (*MuSig2GetCombinedNonceResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{25}
}

func (x *MuSig2GetCombinedNonceResponse) GetCombinedPublicNonce() []byte {
	if x != nil {
		return x.CombinedPublicNonce
	}
	return nil
}

type MuSig2SignRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session to use for signing.
	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// The 32-byte SHA256 digest of the message to sign.
	MessageDigest []byte `protobuf:"bytes,2,opt,name=message_digest,json=messageDigest,proto3" json:"message_digest,omitempty"`
	// Cleanup indicates that after signing, the session state can be cleaned up,
	// since another participant is going to be responsible for combining the
	// partial signatures.
	Cleanup       bool `protobuf:"varint,3,opt,name=cleanup,proto3" json:"cleanup,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2SignRequest) Reset() {
	*x = MuSig2SignRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2SignRequest) ProtoMessage() {}

func (x *MuSig2SignRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[26]
	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 MuSig2SignRequest.ProtoReflect.Descriptor instead.
func (*MuSig2SignRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{26}
}

func (x *MuSig2SignRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *MuSig2SignRequest) GetMessageDigest() []byte {
	if x != nil {
		return x.MessageDigest
	}
	return nil
}

func (x *MuSig2SignRequest) GetCleanup() bool {
	if x != nil {
		return x.Cleanup
	}
	return false
}

type MuSig2SignResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The partial signature created by the local signer.
	LocalPartialSignature []byte `protobuf:"bytes,1,opt,name=local_partial_signature,json=localPartialSignature,proto3" json:"local_partial_signature,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *MuSig2SignResponse) Reset() {
	*x = MuSig2SignResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2SignResponse) ProtoMessage() {}

func (x *MuSig2SignResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[27]
	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 MuSig2SignResponse.ProtoReflect.Descriptor instead.
func (*MuSig2SignResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{27}
}

func (x *MuSig2SignResponse) GetLocalPartialSignature() []byte {
	if x != nil {
		return x.LocalPartialSignature
	}
	return nil
}

type MuSig2CombineSigRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session to combine the signatures for.
	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// The list of all other participants' partial signatures to add to the current
	// session.
	OtherPartialSignatures [][]byte `protobuf:"bytes,2,rep,name=other_partial_signatures,json=otherPartialSignatures,proto3" json:"other_partial_signatures,omitempty"`
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *MuSig2CombineSigRequest) Reset() {
	*x = MuSig2CombineSigRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2CombineSigRequest) ProtoMessage() {}

func (x *MuSig2CombineSigRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[28]
	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 MuSig2CombineSigRequest.ProtoReflect.Descriptor instead.
func (*MuSig2CombineSigRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{28}
}

func (x *MuSig2CombineSigRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *MuSig2CombineSigRequest) GetOtherPartialSignatures() [][]byte {
	if x != nil {
		return x.OtherPartialSignatures
	}
	return nil
}

type MuSig2CombineSigResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Indicates whether all partial signatures required to create a final, full
	// signature are known yet. If this is true, then the final_signature field is
	// set, otherwise it is empty.
	HaveAllSignatures bool `protobuf:"varint,1,opt,name=have_all_signatures,json=haveAllSignatures,proto3" json:"have_all_signatures,omitempty"`
	// The final, full signature that is valid for the combined public key.
	FinalSignature []byte `protobuf:"bytes,2,opt,name=final_signature,json=finalSignature,proto3" json:"final_signature,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *MuSig2CombineSigResponse) Reset() {
	*x = MuSig2CombineSigResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2CombineSigResponse) ProtoMessage() {}

func (x *MuSig2CombineSigResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[29]
	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 MuSig2CombineSigResponse.ProtoReflect.Descriptor instead.
func (*MuSig2CombineSigResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{29}
}

func (x *MuSig2CombineSigResponse) GetHaveAllSignatures() bool {
	if x != nil {
		return x.HaveAllSignatures
	}
	return false
}

func (x *MuSig2CombineSigResponse) GetFinalSignature() []byte {
	if x != nil {
		return x.FinalSignature
	}
	return nil
}

type MuSig2CleanupRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique ID of the signing session that should be removed/cleaned up.
	SessionId     []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2CleanupRequest) Reset() {
	*x = MuSig2CleanupRequest{}
	mi := &file_signrpc_signer_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2CleanupRequest) ProtoMessage() {}

func (x *MuSig2CleanupRequest) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[30]
	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 MuSig2CleanupRequest.ProtoReflect.Descriptor instead.
func (*MuSig2CleanupRequest) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{30}
}

func (x *MuSig2CleanupRequest) GetSessionId() []byte {
	if x != nil {
		return x.SessionId
	}
	return nil
}

type MuSig2CleanupResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MuSig2CleanupResponse) Reset() {
	*x = MuSig2CleanupResponse{}
	mi := &file_signrpc_signer_proto_msgTypes[31]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MuSig2CleanupResponse) ProtoMessage() {}

func (x *MuSig2CleanupResponse) ProtoReflect() protoreflect.Message {
	mi := &file_signrpc_signer_proto_msgTypes[31]
	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 MuSig2CleanupResponse.ProtoReflect.Descriptor instead.
func (*MuSig2CleanupResponse) Descriptor() ([]byte, []int) {
	return file_signrpc_signer_proto_rawDescGZIP(), []int{31}
}

var File_signrpc_signer_proto protoreflect.FileDescriptor

const file_signrpc_signer_proto_rawDesc = "" +
	"\n" +
	"\x14signrpc/signer.proto\x12\asignrpc\"H\n" +
	"\n" +
	"KeyLocator\x12\x1d\n" +
	"\n" +
	"key_family\x18\x01 \x01(\x05R\tkeyFamily\x12\x1b\n" +
	"\tkey_index\x18\x02 \x01(\x05R\bkeyIndex\"a\n" +
	"\rKeyDescriptor\x12\"\n" +
	"\rraw_key_bytes\x18\x01 \x01(\fR\vrawKeyBytes\x12,\n" +
	"\akey_loc\x18\x02 \x01(\v2\x13.signrpc.KeyLocatorR\x06keyLoc\":\n" +
	"\x05TxOut\x12\x14\n" +
	"\x05value\x18\x01 \x01(\x03R\x05value\x12\x1b\n" +
	"\tpk_script\x18\x02 \x01(\fR\bpkScript\"\xe6\x02\n" +
	"\x0eSignDescriptor\x121\n" +
	"\bkey_desc\x18\x01 \x01(\v2\x16.signrpc.KeyDescriptorR\akeyDesc\x12!\n" +
	"\fsingle_tweak\x18\x02 \x01(\fR\vsingleTweak\x12!\n" +
	"\fdouble_tweak\x18\x03 \x01(\fR\vdoubleTweak\x12\x1b\n" +
	"\ttap_tweak\x18\n" +
	" \x01(\fR\btapTweak\x12%\n" +
	"\x0ewitness_script\x18\x04 \x01(\fR\rwitnessScript\x12&\n" +
	"\x06output\x18\x05 \x01(\v2\x0e.signrpc.TxOutR\x06output\x12\x18\n" +
	"\asighash\x18\a \x01(\rR\asighash\x12\x1f\n" +
	"\vinput_index\x18\b \x01(\x05R\n" +
	"inputIndex\x124\n" +
	"\vsign_method\x18\t \x01(\x0e2\x13.signrpc.SignMethodR\n" +
	"signMethod\"\x96\x01\n" +
	"\aSignReq\x12 \n" +
	"\fraw_tx_bytes\x18\x01 \x01(\fR\n" +
	"rawTxBytes\x126\n" +
	"\n" +
	"sign_descs\x18\x02 \x03(\v2\x17.signrpc.SignDescriptorR\tsignDescs\x121\n" +
	"\fprev_outputs\x18\x03 \x03(\v2\x0e.signrpc.TxOutR\vprevOutputs\"%\n" +
	"\bSignResp\x12\x19\n" +
	"\braw_sigs\x18\x01 \x03(\fR\arawSigs\"F\n" +
	"\vInputScript\x12\x18\n" +
	"\awitness\x18\x01 \x03(\fR\awitness\x12\x1d\n" +
	"\n" +
	"sig_script\x18\x02 \x01(\fR\tsigScript\"L\n" +
	"\x0fInputScriptResp\x129\n" +
	"\rinput_scripts\x18\x01 \x03(\v2\x14.signrpc.InputScriptR\finputScripts\"\xf8\x01\n" +
	"\x0eSignMessageReq\x12\x10\n" +
	"\x03msg\x18\x01 \x01(\fR\x03msg\x12,\n" +
	"\akey_loc\x18\x02 \x01(\v2\x13.signrpc.KeyLocatorR\x06keyLoc\x12\x1f\n" +
	"\vdouble_hash\x18\x03 \x01(\bR\n" +
	"doubleHash\x12\x1f\n" +
	"\vcompact_sig\x18\x04 \x01(\bR\n" +
	"compactSig\x12\x1f\n" +
	"\vschnorr_sig\x18\x05 \x01(\bR\n" +
	"schnorrSig\x121\n" +
	"\x15schnorr_sig_tap_tweak\x18\x06 \x01(\fR\x12schnorrSigTapTweak\x12\x10\n" +
	"\x03tag\x18\a \x01(\fR\x03tag\"/\n" +
	"\x0fSignMessageResp\x12\x1c\n" +
	"\tsignature\x18\x01 \x01(\fR\tsignature\"\x92\x01\n" +
	"\x10VerifyMessageReq\x12\x10\n" +
	"\x03msg\x18\x01 \x01(\fR\x03msg\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x12\x16\n" +
	"\x06pubkey\x18\x03 \x01(\fR\x06pubkey\x12$\n" +
	"\x0eis_schnorr_sig\x18\x04 \x01(\bR\fisSchnorrSig\x12\x10\n" +
	"\x03tag\x18\x05 \x01(\fR\x03tag\")\n" +
	"\x11VerifyMessageResp\x12\x14\n" +
	"\x05valid\x18\x01 \x01(\bR\x05valid\"\xa2\x01\n" +
	"\x10SharedKeyRequest\x12)\n" +
	"\x10ephemeral_pubkey\x18\x01 \x01(\fR\x0fephemeralPubkey\x120\n" +
	"\akey_loc\x18\x02 \x01(\v2\x13.signrpc.KeyLocatorB\x02\x18\x01R\x06keyLoc\x121\n" +
	"\bkey_desc\x18\x03 \x01(\v2\x16.signrpc.KeyDescriptorR\akeyDesc\"2\n" +
	"\x11SharedKeyResponse\x12\x1d\n" +
	"\n" +
	"shared_key\x18\x01 \x01(\fR\tsharedKey\"=\n" +
	"\tTweakDesc\x12\x14\n" +
	"\x05tweak\x18\x01 \x01(\fR\x05tweak\x12\x1a\n" +
	"\tis_x_only\x18\x02 \x01(\bR\aisXOnly\"Y\n" +
	"\x10TaprootTweakDesc\x12\x1f\n" +
	"\vscript_root\x18\x01 \x01(\fR\n" +
	"scriptRoot\x12$\n" +
	"\x0ekey_spend_only\x18\x02 \x01(\bR\fkeySpendOnly\"\xe6\x01\n" +
	"\x18MuSig2CombineKeysRequest\x12,\n" +
	"\x12all_signer_pubkeys\x18\x01 \x03(\fR\x10allSignerPubkeys\x12*\n" +
	"\x06tweaks\x18\x02 \x03(\v2\x12.signrpc.TweakDescR\x06tweaks\x12>\n" +
	"\rtaproot_tweak\x18\x03 \x01(\v2\x19.signrpc.TaprootTweakDescR\ftaprootTweak\x120\n" +
	"\aversion\x18\x04 \x01(\x0e2\x16.signrpc.MuSig2VersionR\aversion\"\xa2\x01\n" +
	"\x19MuSig2CombineKeysResponse\x12!\n" +
	"\fcombined_key\x18\x01 \x01(\fR\vcombinedKey\x120\n" +
	"\x14taproot_internal_key\x18\x02 \x01(\fR\x12taprootInternalKey\x120\n" +
	"\aversion\x18\x04 \x01(\x0e2\x16.signrpc.MuSig2VersionR\aversion\"\x87\x03\n" +
	"\x14MuSig2SessionRequest\x12,\n" +
	"\akey_loc\x18\x01 \x01(\v2\x13.signrpc.KeyLocatorR\x06keyLoc\x12,\n" +
	"\x12all_signer_pubkeys\x18\x02 \x03(\fR\x10allSignerPubkeys\x12;\n" +
	"\x1aother_signer_public_nonces\x18\x03 \x03(\fR\x17otherSignerPublicNonces\x12*\n" +
	"\x06tweaks\x18\x04 \x03(\v2\x12.signrpc.TweakDescR\x06tweaks\x12>\n" +
	"\rtaproot_tweak\x18\x05 \x01(\v2\x19.signrpc.TaprootTweakDescR\ftaprootTweak\x120\n" +
	"\aversion\x18\x06 \x01(\x0e2\x16.signrpc.MuSig2VersionR\aversion\x128\n" +
	"\x18pregenerated_local_nonce\x18\a \x01(\fR\x16pregeneratedLocalNonce\"\x95\x02\n" +
	"\x15MuSig2SessionResponse\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\x12!\n" +
	"\fcombined_key\x18\x02 \x01(\fR\vcombinedKey\x120\n" +
	"\x14taproot_internal_key\x18\x03 \x01(\fR\x12taprootInternalKey\x12.\n" +
	"\x13local_public_nonces\x18\x04 \x01(\fR\x11localPublicNonces\x12&\n" +
	"\x0fhave_all_nonces\x18\x05 \x01(\bR\rhaveAllNonces\x120\n" +
	"\aversion\x18\x06 \x01(\x0e2\x16.signrpc.MuSig2VersionR\aversion\"y\n" +
	"\x1bMuSig2RegisterNoncesRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\x12;\n" +
	"\x1aother_signer_public_nonces\x18\x03 \x03(\fR\x17otherSignerPublicNonces\"F\n" +
	"\x1cMuSig2RegisterNoncesResponse\x12&\n" +
	"\x0fhave_all_nonces\x18\x01 \x01(\bR\rhaveAllNonces\"w\n" +
	"\"MuSig2RegisterCombinedNonceRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\x122\n" +
	"\x15combined_public_nonce\x18\x02 \x01(\fR\x13combinedPublicNonce\"%\n" +
	"#MuSig2RegisterCombinedNonceResponse\">\n" +
	"\x1dMuSig2GetCombinedNonceRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\"T\n" +
	"\x1eMuSig2GetCombinedNonceResponse\x122\n" +
	"\x15combined_public_nonce\x18\x01 \x01(\fR\x13combinedPublicNonce\"s\n" +
	"\x11MuSig2SignRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\x12%\n" +
	"\x0emessage_digest\x18\x02 \x01(\fR\rmessageDigest\x12\x18\n" +
	"\acleanup\x18\x03 \x01(\bR\acleanup\"L\n" +
	"\x12MuSig2SignResponse\x126\n" +
	"\x17local_partial_signature\x18\x01 \x01(\fR\x15localPartialSignature\"r\n" +
	"\x17MuSig2CombineSigRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\x128\n" +
	"\x18other_partial_signatures\x18\x02 \x03(\fR\x16otherPartialSignatures\"s\n" +
	"\x18MuSig2CombineSigResponse\x12.\n" +
	"\x13have_all_signatures\x18\x01 \x01(\bR\x11haveAllSignatures\x12'\n" +
	"\x0ffinal_signature\x18\x02 \x01(\fR\x0efinalSignature\"5\n" +
	"\x14MuSig2CleanupRequest\x12\x1d\n" +
	"\n" +
	"session_id\x18\x01 \x01(\fR\tsessionId\"\x17\n" +
	"\x15MuSig2CleanupResponse*\x9c\x01\n" +
	"\n" +
	"SignMethod\x12\x1a\n" +
	"\x16SIGN_METHOD_WITNESS_V0\x10\x00\x12)\n" +
	"%SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086\x10\x01\x12!\n" +
	"\x1dSIGN_METHOD_TAPROOT_KEY_SPEND\x10\x02\x12$\n" +
	" SIGN_METHOD_TAPROOT_SCRIPT_SPEND\x10\x03*b\n" +
	"\rMuSig2Version\x12\x1c\n" +
	"\x18MUSIG2_VERSION_UNDEFINED\x10\x00\x12\x17\n" +
	"\x13MUSIG2_VERSION_V040\x10\x01\x12\x1a\n" +
	"\x16MUSIG2_VERSION_V100RC2\x10\x022\xc0\b\n" +
	"\x06Signer\x124\n" +
	"\rSignOutputRaw\x12\x10.signrpc.SignReq\x1a\x11.signrpc.SignResp\x12@\n" +
	"\x12ComputeInputScript\x12\x10.signrpc.SignReq\x1a\x18.signrpc.InputScriptResp\x12@\n" +
	"\vSignMessage\x12\x17.signrpc.SignMessageReq\x1a\x18.signrpc.SignMessageResp\x12F\n" +
	"\rVerifyMessage\x12\x19.signrpc.VerifyMessageReq\x1a\x1a.signrpc.VerifyMessageResp\x12H\n" +
	"\x0fDeriveSharedKey\x12\x19.signrpc.SharedKeyRequest\x1a\x1a.signrpc.SharedKeyResponse\x12Z\n" +
	"\x11MuSig2CombineKeys\x12!.signrpc.MuSig2CombineKeysRequest\x1a\".signrpc.MuSig2CombineKeysResponse\x12T\n" +
	"\x13MuSig2CreateSession\x12\x1d.signrpc.MuSig2SessionRequest\x1a\x1e.signrpc.MuSig2SessionResponse\x12c\n" +
	"\x14MuSig2RegisterNonces\x12$.signrpc.MuSig2RegisterNoncesRequest\x1a%.signrpc.MuSig2RegisterNoncesResponse\x12x\n" +
	"\x1bMuSig2RegisterCombinedNonce\x12+.signrpc.MuSig2RegisterCombinedNonceRequest\x1a,.signrpc.MuSig2RegisterCombinedNonceResponse\x12i\n" +
	"\x16MuSig2GetCombinedNonce\x12&.signrpc.MuSig2GetCombinedNonceRequest\x1a'.signrpc.MuSig2GetCombinedNonceResponse\x12E\n" +
	"\n" +
	"MuSig2Sign\x12\x1a.signrpc.MuSig2SignRequest\x1a\x1b.signrpc.MuSig2SignResponse\x12W\n" +
	"\x10MuSig2CombineSig\x12 .signrpc.MuSig2CombineSigRequest\x1a!.signrpc.MuSig2CombineSigResponse\x12N\n" +
	"\rMuSig2Cleanup\x12\x1d.signrpc.MuSig2CleanupRequest\x1a\x1e.signrpc.MuSig2CleanupResponseB/Z-github.com/lightningnetwork/lnd/lnrpc/signrpcb\x06proto3"

var (
	file_signrpc_signer_proto_rawDescOnce sync.Once
	file_signrpc_signer_proto_rawDescData []byte
)

func file_signrpc_signer_proto_rawDescGZIP() []byte {
	file_signrpc_signer_proto_rawDescOnce.Do(func() {
		file_signrpc_signer_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_signrpc_signer_proto_rawDesc), len(file_signrpc_signer_proto_rawDesc)))
	})
	return file_signrpc_signer_proto_rawDescData
}

var file_signrpc_signer_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_signrpc_signer_proto_msgTypes = make([]protoimpl.MessageInfo, 32)
var file_signrpc_signer_proto_goTypes = []any{
	(SignMethod)(0),                             // 0: signrpc.SignMethod
	(MuSig2Version)(0),                          // 1: signrpc.MuSig2Version
	(*KeyLocator)(nil),                          // 2: signrpc.KeyLocator
	(*KeyDescriptor)(nil),                       // 3: signrpc.KeyDescriptor
	(*TxOut)(nil),                               // 4: signrpc.TxOut
	(*SignDescriptor)(nil),                      // 5: signrpc.SignDescriptor
	(*SignReq)(nil),                             // 6: signrpc.SignReq
	(*SignResp)(nil),                            // 7: signrpc.SignResp
	(*InputScript)(nil),                         // 8: signrpc.InputScript
	(*InputScriptResp)(nil),                     // 9: signrpc.InputScriptResp
	(*SignMessageReq)(nil),                      // 10: signrpc.SignMessageReq
	(*SignMessageResp)(nil),                     // 11: signrpc.SignMessageResp
	(*VerifyMessageReq)(nil),                    // 12: signrpc.VerifyMessageReq
	(*VerifyMessageResp)(nil),                   // 13: signrpc.VerifyMessageResp
	(*SharedKeyRequest)(nil),                    // 14: signrpc.SharedKeyRequest
	(*SharedKeyResponse)(nil),                   // 15: signrpc.SharedKeyResponse
	(*TweakDesc)(nil),                           // 16: signrpc.TweakDesc
	(*TaprootTweakDesc)(nil),                    // 17: signrpc.TaprootTweakDesc
	(*MuSig2CombineKeysRequest)(nil),            // 18: signrpc.MuSig2CombineKeysRequest
	(*MuSig2CombineKeysResponse)(nil),           // 19: signrpc.MuSig2CombineKeysResponse
	(*MuSig2SessionRequest)(nil),                // 20: signrpc.MuSig2SessionRequest
	(*MuSig2SessionResponse)(nil),               // 21: signrpc.MuSig2SessionResponse
	(*MuSig2RegisterNoncesRequest)(nil),         // 22: signrpc.MuSig2RegisterNoncesRequest
	(*MuSig2RegisterNoncesResponse)(nil),        // 23: signrpc.MuSig2RegisterNoncesResponse
	(*MuSig2RegisterCombinedNonceRequest)(nil),  // 24: signrpc.MuSig2RegisterCombinedNonceRequest
	(*MuSig2RegisterCombinedNonceResponse)(nil), // 25: signrpc.MuSig2RegisterCombinedNonceResponse
	(*MuSig2GetCombinedNonceRequest)(nil),       // 26: signrpc.MuSig2GetCombinedNonceRequest
	(*MuSig2GetCombinedNonceResponse)(nil),      // 27: signrpc.MuSig2GetCombinedNonceResponse
	(*MuSig2SignRequest)(nil),                   // 28: signrpc.MuSig2SignRequest
	(*MuSig2SignResponse)(nil),                  // 29: signrpc.MuSig2SignResponse
	(*MuSig2CombineSigRequest)(nil),             // 30: signrpc.MuSig2CombineSigRequest
	(*MuSig2CombineSigResponse)(nil),            // 31: signrpc.MuSig2CombineSigResponse
	(*MuSig2CleanupRequest)(nil),                // 32: signrpc.MuSig2CleanupRequest
	(*MuSig2CleanupResponse)(nil),               // 33: signrpc.MuSig2CleanupResponse
}
var file_signrpc_signer_proto_depIdxs = []int32{
	2,  // 0: signrpc.KeyDescriptor.key_loc:type_name -> signrpc.KeyLocator
	3,  // 1: signrpc.SignDescriptor.key_desc:type_name -> signrpc.KeyDescriptor
	4,  // 2: signrpc.SignDescriptor.output:type_name -> signrpc.TxOut
	0,  // 3: signrpc.SignDescriptor.sign_method:type_name -> signrpc.SignMethod
	5,  // 4: signrpc.SignReq.sign_descs:type_name -> signrpc.SignDescriptor
	4,  // 5: signrpc.SignReq.prev_outputs:type_name -> signrpc.TxOut
	8,  // 6: signrpc.InputScriptResp.input_scripts:type_name -> signrpc.InputScript
	2,  // 7: signrpc.SignMessageReq.key_loc:type_name -> signrpc.KeyLocator
	2,  // 8: signrpc.SharedKeyRequest.key_loc:type_name -> signrpc.KeyLocator
	3,  // 9: signrpc.SharedKeyRequest.key_desc:type_name -> signrpc.KeyDescriptor
	16, // 10: signrpc.MuSig2CombineKeysRequest.tweaks:type_name -> signrpc.TweakDesc
	17, // 11: signrpc.MuSig2CombineKeysRequest.taproot_tweak:type_name -> signrpc.TaprootTweakDesc
	1,  // 12: signrpc.MuSig2CombineKeysRequest.version:type_name -> signrpc.MuSig2Version
	1,  // 13: signrpc.MuSig2CombineKeysResponse.version:type_name -> signrpc.MuSig2Version
	2,  // 14: signrpc.MuSig2SessionRequest.key_loc:type_name -> signrpc.KeyLocator
	16, // 15: signrpc.MuSig2SessionRequest.tweaks:type_name -> signrpc.TweakDesc
	17, // 16: signrpc.MuSig2SessionRequest.taproot_tweak:type_name -> signrpc.TaprootTweakDesc
	1,  // 17: signrpc.MuSig2SessionRequest.version:type_name -> signrpc.MuSig2Version
	1,  // 18: signrpc.MuSig2SessionResponse.version:type_name -> signrpc.MuSig2Version
	6,  // 19: signrpc.Signer.SignOutputRaw:input_type -> signrpc.SignReq
	6,  // 20: signrpc.Signer.ComputeInputScript:input_type -> signrpc.SignReq
	10, // 21: signrpc.Signer.SignMessage:input_type -> signrpc.SignMessageReq
	12, // 22: signrpc.Signer.VerifyMessage:input_type -> signrpc.VerifyMessageReq
	14, // 23: signrpc.Signer.DeriveSharedKey:input_type -> signrpc.SharedKeyRequest
	18, // 24: signrpc.Signer.MuSig2CombineKeys:input_type -> signrpc.MuSig2CombineKeysRequest
	20, // 25: signrpc.Signer.MuSig2CreateSession:input_type -> signrpc.MuSig2SessionRequest
	22, // 26: signrpc.Signer.MuSig2RegisterNonces:input_type -> signrpc.MuSig2RegisterNoncesRequest
	24, // 27: signrpc.Signer.MuSig2RegisterCombinedNonce:input_type -> signrpc.MuSig2RegisterCombinedNonceRequest
	26, // 28: signrpc.Signer.MuSig2GetCombinedNonce:input_type -> signrpc.MuSig2GetCombinedNonceRequest
	28, // 29: signrpc.Signer.MuSig2Sign:input_type -> signrpc.MuSig2SignRequest
	30, // 30: signrpc.Signer.MuSig2CombineSig:input_type -> signrpc.MuSig2CombineSigRequest
	32, // 31: signrpc.Signer.MuSig2Cleanup:input_type -> signrpc.MuSig2CleanupRequest
	7,  // 32: signrpc.Signer.SignOutputRaw:output_type -> signrpc.SignResp
	9,  // 33: signrpc.Signer.ComputeInputScript:output_type -> signrpc.InputScriptResp
	11, // 34: signrpc.Signer.SignMessage:output_type -> signrpc.SignMessageResp
	13, // 35: signrpc.Signer.VerifyMessage:output_type -> signrpc.VerifyMessageResp
	15, // 36: signrpc.Signer.DeriveSharedKey:output_type -> signrpc.SharedKeyResponse
	19, // 37: signrpc.Signer.MuSig2CombineKeys:output_type -> signrpc.MuSig2CombineKeysResponse
	21, // 38: signrpc.Signer.MuSig2CreateSession:output_type -> signrpc.MuSig2SessionResponse
	23, // 39: signrpc.Signer.MuSig2RegisterNonces:output_type -> signrpc.MuSig2RegisterNoncesResponse
	25, // 40: signrpc.Signer.MuSig2RegisterCombinedNonce:output_type -> signrpc.MuSig2RegisterCombinedNonceResponse
	27, // 41: signrpc.Signer.MuSig2GetCombinedNonce:output_type -> signrpc.MuSig2GetCombinedNonceResponse
	29, // 42: signrpc.Signer.MuSig2Sign:output_type -> signrpc.MuSig2SignResponse
	31, // 43: signrpc.Signer.MuSig2CombineSig:output_type -> signrpc.MuSig2CombineSigResponse
	33, // 44: signrpc.Signer.MuSig2Cleanup:output_type -> signrpc.MuSig2CleanupResponse
	32, // [32:45] is the sub-list for method output_type
	19, // [19:32] is the sub-list for method input_type
	19, // [19:19] is the sub-list for extension type_name
	19, // [19:19] is the sub-list for extension extendee
	0,  // [0:19] is the sub-list for field type_name
}

func init() { file_signrpc_signer_proto_init() }
func file_signrpc_signer_proto_init() {
	if File_signrpc_signer_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_signrpc_signer_proto_rawDesc), len(file_signrpc_signer_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   32,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_signrpc_signer_proto_goTypes,
		DependencyIndexes: file_signrpc_signer_proto_depIdxs,
		EnumInfos:         file_signrpc_signer_proto_enumTypes,
		MessageInfos:      file_signrpc_signer_proto_msgTypes,
	}.Build()
	File_signrpc_signer_proto = out.File
	file_signrpc_signer_proto_goTypes = nil
	file_signrpc_signer_proto_depIdxs = nil
}
