lnd.xprv/lnrpc/signrpc/signer.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: signrpc/signer.proto

package signrpc

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

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

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

type KeyLocator struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_KeyLocator proto.InternalMessageInfo

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

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

type KeyDescriptor struct {
	//
	//The raw bytes of the key 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 key to use for signing. Either this
	//or the raw bytes of the target key must be specified.
	KeyLoc               *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_KeyDescriptor proto.InternalMessageInfo

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

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

type TxOut struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TxOut proto.InternalMessageInfo

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

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

type SignDescriptor struct {
	//
	//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.
	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 full script required to properly redeem the output.  This field will
	//only be populated if a p2wsh or a p2sh output is being signed.
	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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SignDescriptor proto.InternalMessageInfo

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

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

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

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

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

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

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

type SignReq struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_SignReq proto.InternalMessageInfo

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

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

type SignResp struct {
	//
	//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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SignResp proto.InternalMessageInfo

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

type InputScript struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_InputScript proto.InternalMessageInfo

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

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

type InputScriptResp struct {
	// The set of fully valid input scripts requested.
	InputScripts         []*InputScript `protobuf:"bytes,1,rep,name=input_scripts,json=inputScripts,proto3" json:"input_scripts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_InputScriptResp proto.InternalMessageInfo

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

type SignMessageReq struct {
	// The message to be signed.
	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"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_SignMessageReq proto.InternalMessageInfo

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

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

type SignMessageResp struct {
	//
	//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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SignMessageResp proto.InternalMessageInfo

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

type VerifyMessageReq struct {
	// The message over which the signature is to be verified.
	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.
	Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	// The public key the signature has to be valid for.
	Pubkey               []byte   `protobuf:"bytes,3,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VerifyMessageReq proto.InternalMessageInfo

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

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

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

type VerifyMessageResp struct {
	// Whether the signature was valid over the given message.
	Valid                bool     `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_VerifyMessageResp proto.InternalMessageInfo

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

type SharedKeyRequest struct {
	// 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"`
	//
	//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.
	KeyLoc               *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_SharedKeyRequest proto.InternalMessageInfo

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

func (m *SharedKeyRequest) GetKeyLoc() *KeyLocator {
	if m != nil {
		return m.KeyLoc
	}
	return nil
}

type SharedKeyResponse struct {
	// The shared public key, hashed with sha256.
	SharedKey            []byte   `protobuf:"bytes,1,opt,name=shared_key,json=sharedKey,proto3" json:"shared_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SharedKeyResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*KeyLocator)(nil), "signrpc.KeyLocator")
	proto.RegisterType((*KeyDescriptor)(nil), "signrpc.KeyDescriptor")
	proto.RegisterType((*TxOut)(nil), "signrpc.TxOut")
	proto.RegisterType((*SignDescriptor)(nil), "signrpc.SignDescriptor")
	proto.RegisterType((*SignReq)(nil), "signrpc.SignReq")
	proto.RegisterType((*SignResp)(nil), "signrpc.SignResp")
	proto.RegisterType((*InputScript)(nil), "signrpc.InputScript")
	proto.RegisterType((*InputScriptResp)(nil), "signrpc.InputScriptResp")
	proto.RegisterType((*SignMessageReq)(nil), "signrpc.SignMessageReq")
	proto.RegisterType((*SignMessageResp)(nil), "signrpc.SignMessageResp")
	proto.RegisterType((*VerifyMessageReq)(nil), "signrpc.VerifyMessageReq")
	proto.RegisterType((*VerifyMessageResp)(nil), "signrpc.VerifyMessageResp")
	proto.RegisterType((*SharedKeyRequest)(nil), "signrpc.SharedKeyRequest")
	proto.RegisterType((*SharedKeyResponse)(nil), "signrpc.SharedKeyResponse")
}

func init() { proto.RegisterFile("signrpc/signer.proto", fileDescriptor_4ecd772f6c7ffacf) }

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

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// SignerClient is the client API for Signer service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SignerClient interface {
	//
	//SignOutputRaw is a method that can be used to generated a signature for a
	//set of inputs/outputs to a transaction. Each request specifies details
	//concerning how the outputs should be signed, which keys they should be
	//signed with, and also any optional tweaks. The return value is a fixed
	//64-byte signature (the same format as we use on the wire in Lightning).
	//
	//If we are  unable to sign using the specified keys, then an error will be
	//returned.
	SignOutputRaw(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*SignResp, error)
	//
	//ComputeInputScript generates a complete InputIndex for the passed
	//transaction with the signature as defined within the passed SignDescriptor.
	//This method should be capable of generating the proper input script for
	//both regular p2wkh output and p2wkh outputs nested within a regular p2sh
	//output.
	//
	//Note that when using this method to sign inputs belonging to the wallet,
	//the only items of the SignDescriptor that need to be populated are pkScript
	//in the TxOut field, the value in that same field, and finally the input
	//index.
	ComputeInputScript(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*InputScriptResp, error)
	//
	//SignMessage signs a message with the key specified in the key locator. The
	//returned signature is fixed-size LN wire format encoded.
	//
	//The main difference to SignMessage in the main RPC is that a specific key is
	//used to sign the message instead of the node identity private key.
	SignMessage(ctx context.Context, in *SignMessageReq, opts ...grpc.CallOption) (*SignMessageResp, error)
	//
	//VerifyMessage verifies a signature over a message using the public key
	//provided. The signature must be fixed-size LN wire format encoded.
	//
	//The main difference to VerifyMessage in the main RPC is that the public key
	//used to sign the message does not have to be a node known to the network.
	VerifyMessage(ctx context.Context, in *VerifyMessageReq, opts ...grpc.CallOption) (*VerifyMessageResp, error)
	//
	//DeriveSharedKey returns a shared secret key by performing Diffie-Hellman key
	//derivation between the ephemeral public key in the request and the node's
	//key specified in the key_loc parameter (or the node's identity private key
	//if no key locator is specified):
	//P_shared = privKeyNode * ephemeralPubkey
	//The resulting shared public key is serialized in the compressed format and
	//hashed with sha256, resulting in the final key length of 256bit.
	DeriveSharedKey(ctx context.Context, in *SharedKeyRequest, opts ...grpc.CallOption) (*SharedKeyResponse, error)
}

type signerClient struct {
	cc *grpc.ClientConn
}

func NewSignerClient(cc *grpc.ClientConn) SignerClient {
	return &signerClient{cc}
}

func (c *signerClient) SignOutputRaw(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*SignResp, error) {
	out := new(SignResp)
	err := c.cc.Invoke(ctx, "/signrpc.Signer/SignOutputRaw", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *signerClient) ComputeInputScript(ctx context.Context, in *SignReq, opts ...grpc.CallOption) (*InputScriptResp, error) {
	out := new(InputScriptResp)
	err := c.cc.Invoke(ctx, "/signrpc.Signer/ComputeInputScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *signerClient) SignMessage(ctx context.Context, in *SignMessageReq, opts ...grpc.CallOption) (*SignMessageResp, error) {
	out := new(SignMessageResp)
	err := c.cc.Invoke(ctx, "/signrpc.Signer/SignMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *signerClient) VerifyMessage(ctx context.Context, in *VerifyMessageReq, opts ...grpc.CallOption) (*VerifyMessageResp, error) {
	out := new(VerifyMessageResp)
	err := c.cc.Invoke(ctx, "/signrpc.Signer/VerifyMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *signerClient) DeriveSharedKey(ctx context.Context, in *SharedKeyRequest, opts ...grpc.CallOption) (*SharedKeyResponse, error) {
	out := new(SharedKeyResponse)
	err := c.cc.Invoke(ctx, "/signrpc.Signer/DeriveSharedKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SignerServer is the server API for Signer service.
type SignerServer interface {
	//
	//SignOutputRaw is a method that can be used to generated a signature for a
	//set of inputs/outputs to a transaction. Each request specifies details
	//concerning how the outputs should be signed, which keys they should be
	//signed with, and also any optional tweaks. The return value is a fixed
	//64-byte signature (the same format as we use on the wire in Lightning).
	//
	//If we are  unable to sign using the specified keys, then an error will be
	//returned.
	SignOutputRaw(context.Context, *SignReq) (*SignResp, error)
	//
	//ComputeInputScript generates a complete InputIndex for the passed
	//transaction with the signature as defined within the passed SignDescriptor.
	//This method should be capable of generating the proper input script for
	//both regular p2wkh output and p2wkh outputs nested within a regular p2sh
	//output.
	//
	//Note that when using this method to sign inputs belonging to the wallet,
	//the only items of the SignDescriptor that need to be populated are pkScript
	//in the TxOut field, the value in that same field, and finally the input
	//index.
	ComputeInputScript(context.Context, *SignReq) (*InputScriptResp, error)
	//
	//SignMessage signs a message with the key specified in the key locator. The
	//returned signature is fixed-size LN wire format encoded.
	//
	//The main difference to SignMessage in the main RPC is that a specific key is
	//used to sign the message instead of the node identity private key.
	SignMessage(context.Context, *SignMessageReq) (*SignMessageResp, error)
	//
	//VerifyMessage verifies a signature over a message using the public key
	//provided. The signature must be fixed-size LN wire format encoded.
	//
	//The main difference to VerifyMessage in the main RPC is that the public key
	//used to sign the message does not have to be a node known to the network.
	VerifyMessage(context.Context, *VerifyMessageReq) (*VerifyMessageResp, error)
	//
	//DeriveSharedKey returns a shared secret key by performing Diffie-Hellman key
	//derivation between the ephemeral public key in the request and the node's
	//key specified in the key_loc parameter (or the node's identity private key
	//if no key locator is specified):
	//P_shared = privKeyNode * ephemeralPubkey
	//The resulting shared public key is serialized in the compressed format and
	//hashed with sha256, resulting in the final key length of 256bit.
	DeriveSharedKey(context.Context, *SharedKeyRequest) (*SharedKeyResponse, error)
}

func RegisterSignerServer(s *grpc.Server, srv SignerServer) {
	s.RegisterService(&_Signer_serviceDesc, srv)
}

func _Signer_SignOutputRaw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).SignOutputRaw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/signrpc.Signer/SignOutputRaw",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).SignOutputRaw(ctx, req.(*SignReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Signer_ComputeInputScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).ComputeInputScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/signrpc.Signer/ComputeInputScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).ComputeInputScript(ctx, req.(*SignReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Signer_SignMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignMessageReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).SignMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/signrpc.Signer/SignMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).SignMessage(ctx, req.(*SignMessageReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Signer_VerifyMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyMessageReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).VerifyMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/signrpc.Signer/VerifyMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).VerifyMessage(ctx, req.(*VerifyMessageReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Signer_DeriveSharedKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SharedKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).DeriveSharedKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/signrpc.Signer/DeriveSharedKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).DeriveSharedKey(ctx, req.(*SharedKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Signer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "signrpc.Signer",
	HandlerType: (*SignerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SignOutputRaw",
			Handler:    _Signer_SignOutputRaw_Handler,
		},
		{
			MethodName: "ComputeInputScript",
			Handler:    _Signer_ComputeInputScript_Handler,
		},
		{
			MethodName: "SignMessage",
			Handler:    _Signer_SignMessage_Handler,
		},
		{
			MethodName: "VerifyMessage",
			Handler:    _Signer_VerifyMessage_Handler,
		},
		{
			MethodName: "DeriveSharedKey",
			Handler:    _Signer_DeriveSharedKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "signrpc/signer.proto",
}