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

package types

import (
	context "context"
	fmt "fmt"
	math "math"

	types "github.com/33cn/chain33/types"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

//////////////////////////////////////////////////////////////////////////////
// message for Privacy
// start/////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
type PrivacyAction struct {
	// Types that are valid to be assigned to Value:
	//	*PrivacyAction_Public2Privacy
	//	*PrivacyAction_Privacy2Privacy
	//	*PrivacyAction_Privacy2Public
	Value                isPrivacyAction_Value `protobuf_oneof:"value"`
	Ty                   int32                 `protobuf:"varint,4,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_PrivacyAction proto.InternalMessageInfo

type isPrivacyAction_Value interface {
	isPrivacyAction_Value()
}

type PrivacyAction_Public2Privacy struct {
	Public2Privacy *Public2Privacy `protobuf:"bytes,1,opt,name=public2privacy,proto3,oneof"`
}

type PrivacyAction_Privacy2Privacy struct {
	Privacy2Privacy *Privacy2Privacy `protobuf:"bytes,2,opt,name=privacy2privacy,proto3,oneof"`
}

type PrivacyAction_Privacy2Public struct {
	Privacy2Public *Privacy2Public `protobuf:"bytes,3,opt,name=privacy2public,proto3,oneof"`
}

func (*PrivacyAction_Public2Privacy) isPrivacyAction_Value() {}

func (*PrivacyAction_Privacy2Privacy) isPrivacyAction_Value() {}

func (*PrivacyAction_Privacy2Public) isPrivacyAction_Value() {}

func (m *PrivacyAction) GetValue() isPrivacyAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *PrivacyAction) GetPublic2Privacy() *Public2Privacy {
	if x, ok := m.GetValue().(*PrivacyAction_Public2Privacy); ok {
		return x.Public2Privacy
	}
	return nil
}

func (m *PrivacyAction) GetPrivacy2Privacy() *Privacy2Privacy {
	if x, ok := m.GetValue().(*PrivacyAction_Privacy2Privacy); ok {
		return x.Privacy2Privacy
	}
	return nil
}

func (m *PrivacyAction) GetPrivacy2Public() *Privacy2Public {
	if x, ok := m.GetValue().(*PrivacyAction_Privacy2Public); ok {
		return x.Privacy2Public
	}
	return nil
}

func (m *PrivacyAction) GetTy() int32 {
	if m != nil {
		return m.Ty
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*PrivacyAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _PrivacyAction_OneofMarshaler, _PrivacyAction_OneofUnmarshaler, _PrivacyAction_OneofSizer, []interface{}{
		(*PrivacyAction_Public2Privacy)(nil),
		(*PrivacyAction_Privacy2Privacy)(nil),
		(*PrivacyAction_Privacy2Public)(nil),
	}
}

func _PrivacyAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*PrivacyAction)
	// value
	switch x := m.Value.(type) {
	case *PrivacyAction_Public2Privacy:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Public2Privacy); err != nil {
			return err
		}
	case *PrivacyAction_Privacy2Privacy:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Privacy2Privacy); err != nil {
			return err
		}
	case *PrivacyAction_Privacy2Public:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Privacy2Public); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("PrivacyAction.Value has unexpected type %T", x)
	}
	return nil
}

func _PrivacyAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*PrivacyAction)
	switch tag {
	case 1: // value.public2privacy
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Public2Privacy)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction_Public2Privacy{msg}
		return true, err
	case 2: // value.privacy2privacy
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Privacy2Privacy)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction_Privacy2Privacy{msg}
		return true, err
	case 3: // value.privacy2public
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Privacy2Public)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction_Privacy2Public{msg}
		return true, err
	default:
		return false, nil
	}
}

func _PrivacyAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*PrivacyAction)
	// value
	switch x := m.Value.(type) {
	case *PrivacyAction_Public2Privacy:
		s := proto.Size(x.Public2Privacy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *PrivacyAction_Privacy2Privacy:
		s := proto.Size(x.Privacy2Privacy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *PrivacyAction_Privacy2Public:
		s := proto.Size(x.Privacy2Public)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Public2Privacy struct {
	Tokenname            string         `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64          `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string         `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	Output               *PrivacyOutput `protobuf:"bytes,7,opt,name=output,proto3" json:"output,omitempty"`
	AssetExec            string         `protobuf:"bytes,8,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Public2Privacy proto.InternalMessageInfo

func (m *Public2Privacy) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Public2Privacy) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Public2Privacy) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Public2Privacy) GetOutput() *PrivacyOutput {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *Public2Privacy) GetAssetExec() string {
	if m != nil {
		return m.AssetExec
	}
	return ""
}

type Privacy2Privacy struct {
	Tokenname            string         `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64          `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string         `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	Input                *PrivacyInput  `protobuf:"bytes,6,opt,name=input,proto3" json:"input,omitempty"`
	Output               *PrivacyOutput `protobuf:"bytes,7,opt,name=output,proto3" json:"output,omitempty"`
	AssetExec            string         `protobuf:"bytes,8,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Privacy2Privacy proto.InternalMessageInfo

func (m *Privacy2Privacy) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Privacy2Privacy) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Privacy2Privacy) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Privacy2Privacy) GetInput() *PrivacyInput {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Privacy2Privacy) GetOutput() *PrivacyOutput {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *Privacy2Privacy) GetAssetExec() string {
	if m != nil {
		return m.AssetExec
	}
	return ""
}

type Privacy2Public struct {
	Tokenname            string         `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64          `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string         `protobuf:"bytes,3,opt,name=note,proto3" json:"note,omitempty"`
	To                   string         `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
	Input                *PrivacyInput  `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
	Output               *PrivacyOutput `protobuf:"bytes,5,opt,name=output,proto3" json:"output,omitempty"`
	AssetExec            string         `protobuf:"bytes,8,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_Privacy2Public proto.InternalMessageInfo

func (m *Privacy2Public) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Privacy2Public) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Privacy2Public) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Privacy2Public) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *Privacy2Public) GetInput() *PrivacyInput {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Privacy2Public) GetOutput() *PrivacyOutput {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *Privacy2Public) GetAssetExec() string {
	if m != nil {
		return m.AssetExec
	}
	return ""
}

type UTXOGlobalIndex struct {
	//	int64 height   = 1;
	//	int32 txindex  = 2;
	Txhash               []byte   `protobuf:"bytes,3,opt,name=txhash,proto3" json:"txhash,omitempty"`
	Outindex             int32    `protobuf:"varint,4,opt,name=outindex,proto3" json:"outindex,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_UTXOGlobalIndex proto.InternalMessageInfo

func (m *UTXOGlobalIndex) GetTxhash() []byte {
	if m != nil {
		return m.Txhash
	}
	return nil
}

func (m *UTXOGlobalIndex) GetOutindex() int32 {
	if m != nil {
		return m.Outindex
	}
	return 0
}

// privacy input
type KeyInput struct {
	Amount               int64              `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	UtxoGlobalIndex      []*UTXOGlobalIndex `protobuf:"bytes,2,rep,name=utxoGlobalIndex,proto3" json:"utxoGlobalIndex,omitempty"`
	KeyImage             []byte             `protobuf:"bytes,3,opt,name=keyImage,proto3" json:"keyImage,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_KeyInput proto.InternalMessageInfo

func (m *KeyInput) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *KeyInput) GetUtxoGlobalIndex() []*UTXOGlobalIndex {
	if m != nil {
		return m.UtxoGlobalIndex
	}
	return nil
}

func (m *KeyInput) GetKeyImage() []byte {
	if m != nil {
		return m.KeyImage
	}
	return nil
}

type PrivacyInput struct {
	Keyinput             []*KeyInput `protobuf:"bytes,1,rep,name=keyinput,proto3" json:"keyinput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_PrivacyInput proto.InternalMessageInfo

func (m *PrivacyInput) GetKeyinput() []*KeyInput {
	if m != nil {
		return m.Keyinput
	}
	return nil
}

// privacy output
type KeyOutput struct {
	Amount               int64    `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	Onetimepubkey        []byte   `protobuf:"bytes,2,opt,name=onetimepubkey,proto3" json:"onetimepubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_KeyOutput proto.InternalMessageInfo

func (m *KeyOutput) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *KeyOutput) GetOnetimepubkey() []byte {
	if m != nil {
		return m.Onetimepubkey
	}
	return nil
}

type PrivacyOutput struct {
	RpubKeytx            []byte       `protobuf:"bytes,1,opt,name=RpubKeytx,proto3" json:"RpubKeytx,omitempty"`
	Keyoutput            []*KeyOutput `protobuf:"bytes,2,rep,name=keyoutput,proto3" json:"keyoutput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_PrivacyOutput proto.InternalMessageInfo

func (m *PrivacyOutput) GetRpubKeytx() []byte {
	if m != nil {
		return m.RpubKeytx
	}
	return nil
}

func (m *PrivacyOutput) GetKeyoutput() []*KeyOutput {
	if m != nil {
		return m.Keyoutput
	}
	return nil
}

type GroupUTXOGlobalIndex struct {
	Amount               int64              `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	UtxoGlobalIndex      []*UTXOGlobalIndex `protobuf:"bytes,2,rep,name=utxoGlobalIndex,proto3" json:"utxoGlobalIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_GroupUTXOGlobalIndex proto.InternalMessageInfo

func (m *GroupUTXOGlobalIndex) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *GroupUTXOGlobalIndex) GetUtxoGlobalIndex() []*UTXOGlobalIndex {
	if m != nil {
		return m.UtxoGlobalIndex
	}
	return nil
}

type LocalUTXOItem struct {
	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Txindex              int32    `protobuf:"varint,2,opt,name=txindex,proto3" json:"txindex,omitempty"`
	Outindex             int32    `protobuf:"varint,3,opt,name=outindex,proto3" json:"outindex,omitempty"`
	Txhash               []byte   `protobuf:"bytes,4,opt,name=txhash,proto3" json:"txhash,omitempty"`
	Onetimepubkey        []byte   `protobuf:"bytes,5,opt,name=onetimepubkey,proto3" json:"onetimepubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LocalUTXOItem proto.InternalMessageInfo

func (m *LocalUTXOItem) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *LocalUTXOItem) GetTxindex() int32 {
	if m != nil {
		return m.Txindex
	}
	return 0
}

func (m *LocalUTXOItem) GetOutindex() int32 {
	if m != nil {
		return m.Outindex
	}
	return 0
}

func (m *LocalUTXOItem) GetTxhash() []byte {
	if m != nil {
		return m.Txhash
	}
	return nil
}

func (m *LocalUTXOItem) GetOnetimepubkey() []byte {
	if m != nil {
		return m.Onetimepubkey
	}
	return nil
}

type ReqUTXOPubKeys struct {
	TokenName            string                  `protobuf:"bytes,1,opt,name=tokenName,proto3" json:"tokenName,omitempty"`
	GroupUTXOGlobalIndex []*GroupUTXOGlobalIndex `protobuf:"bytes,2,rep,name=groupUTXOGlobalIndex,proto3" json:"groupUTXOGlobalIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_ReqUTXOPubKeys proto.InternalMessageInfo

func (m *ReqUTXOPubKeys) GetTokenName() string {
	if m != nil {
		return m.TokenName
	}
	return ""
}

func (m *ReqUTXOPubKeys) GetGroupUTXOGlobalIndex() []*GroupUTXOGlobalIndex {
	if m != nil {
		return m.GroupUTXOGlobalIndex
	}
	return nil
}

// 一个公钥信息
type PublicKeyData struct {
	Data                 [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PublicKeyData proto.InternalMessageInfo

func (m *PublicKeyData) GetData() [][]byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type GroupUTXOPubKey struct {
	Amount int64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	// 输出签名的所有公钥
	Pubkey               [][]byte `protobuf:"bytes,2,rep,name=pubkey,proto3" json:"pubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_GroupUTXOPubKey proto.InternalMessageInfo

func (m *GroupUTXOPubKey) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

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

type ResUTXOPubKeys struct {
	GroupUTXOPubKeys     []*GroupUTXOPubKey `protobuf:"bytes,1,rep,name=groupUTXOPubKeys,proto3" json:"groupUTXOPubKeys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_ResUTXOPubKeys proto.InternalMessageInfo

func (m *ResUTXOPubKeys) GetGroupUTXOPubKeys() []*GroupUTXOPubKey {
	if m != nil {
		return m.GroupUTXOPubKeys
	}
	return nil
}

type ReqPrivacyToken struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Amount               int64    `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReqPrivacyToken proto.InternalMessageInfo

func (m *ReqPrivacyToken) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *ReqPrivacyToken) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

type AmountDetail struct {
	Amount               int64    `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	Count                int64    `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AmountDetail proto.InternalMessageInfo

func (m *AmountDetail) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *AmountDetail) GetCount() int64 {
	if m != nil {
		return m.Count
	}
	return 0
}

type ReplyPrivacyAmounts struct {
	AmountDetail         []*AmountDetail `protobuf:"bytes,1,rep,name=amountDetail,proto3" json:"amountDetail,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_ReplyPrivacyAmounts proto.InternalMessageInfo

func (m *ReplyPrivacyAmounts) GetAmountDetail() []*AmountDetail {
	if m != nil {
		return m.AmountDetail
	}
	return nil
}

type ReplyUTXOsOfAmount struct {
	LocalUTXOItems       []*LocalUTXOItem `protobuf:"bytes,1,rep,name=localUTXOItems,proto3" json:"localUTXOItems,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *ReplyUTXOsOfAmount) Reset()         { *m = ReplyUTXOsOfAmount{} }
func (m *ReplyUTXOsOfAmount) String() string { return proto.CompactTextString(m) }
func (*ReplyUTXOsOfAmount) ProtoMessage()    {}
func (*ReplyUTXOsOfAmount) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{18}
}

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

var xxx_messageInfo_ReplyUTXOsOfAmount proto.InternalMessageInfo

func (m *ReplyUTXOsOfAmount) GetLocalUTXOItems() []*LocalUTXOItem {
	if m != nil {
		return m.LocalUTXOItems
	}
	return nil
}

type ReceiptPrivacyOutput struct {
	Token                string       `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Keyoutput            []*KeyOutput `protobuf:"bytes,2,rep,name=keyoutput,proto3" json:"keyoutput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ReceiptPrivacyOutput) Reset()         { *m = ReceiptPrivacyOutput{} }
func (m *ReceiptPrivacyOutput) String() string { return proto.CompactTextString(m) }
func (*ReceiptPrivacyOutput) ProtoMessage()    {}
func (*ReceiptPrivacyOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{19}
}

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

var xxx_messageInfo_ReceiptPrivacyOutput proto.InternalMessageInfo

func (m *ReceiptPrivacyOutput) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *ReceiptPrivacyOutput) GetKeyoutput() []*KeyOutput {
	if m != nil {
		return m.Keyoutput
	}
	return nil
}

//各种amount额度的UTXO在链上的数量
type AmountsOfUTXO struct {
	AmountMap            map[int64]int64 `protobuf:"bytes,1,rep,name=amountMap,proto3" json:"amountMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *AmountsOfUTXO) Reset()         { *m = AmountsOfUTXO{} }
func (m *AmountsOfUTXO) String() string { return proto.CompactTextString(m) }
func (*AmountsOfUTXO) ProtoMessage()    {}
func (*AmountsOfUTXO) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{20}
}

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

var xxx_messageInfo_AmountsOfUTXO proto.InternalMessageInfo

func (m *AmountsOfUTXO) GetAmountMap() map[int64]int64 {
	if m != nil {
		return m.AmountMap
	}
	return nil
}

type TokenNamesOfUTXO struct {
	TokensMap            map[string]string `protobuf:"bytes,1,rep,name=tokensMap,proto3" json:"tokensMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *TokenNamesOfUTXO) Reset()         { *m = TokenNamesOfUTXO{} }
func (m *TokenNamesOfUTXO) String() string { return proto.CompactTextString(m) }
func (*TokenNamesOfUTXO) ProtoMessage()    {}
func (*TokenNamesOfUTXO) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{21}
}

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

var xxx_messageInfo_TokenNamesOfUTXO proto.InternalMessageInfo

func (m *TokenNamesOfUTXO) GetTokensMap() map[string]string {
	if m != nil {
		return m.TokensMap
	}
	return nil
}

// 用以转换成json后继续可见的结构
type UTXOGlobalIndex4Print struct {
	Txhash               string   `protobuf:"bytes,1,opt,name=txhash,proto3" json:"txhash,omitempty"`
	Outindex             int32    `protobuf:"varint,2,opt,name=outindex,proto3" json:"outindex,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UTXOGlobalIndex4Print) Reset()         { *m = UTXOGlobalIndex4Print{} }
func (m *UTXOGlobalIndex4Print) String() string { return proto.CompactTextString(m) }
func (*UTXOGlobalIndex4Print) ProtoMessage()    {}
func (*UTXOGlobalIndex4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{22}
}

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

var xxx_messageInfo_UTXOGlobalIndex4Print proto.InternalMessageInfo

func (m *UTXOGlobalIndex4Print) GetTxhash() string {
	if m != nil {
		return m.Txhash
	}
	return ""
}

func (m *UTXOGlobalIndex4Print) GetOutindex() int32 {
	if m != nil {
		return m.Outindex
	}
	return 0
}

type KeyInput4Print struct {
	Amount               int64                    `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	UtxoGlobalIndex      []*UTXOGlobalIndex4Print `protobuf:"bytes,2,rep,name=utxoGlobalIndex,proto3" json:"utxoGlobalIndex,omitempty"`
	KeyImage             string                   `protobuf:"bytes,3,opt,name=keyImage,proto3" json:"keyImage,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *KeyInput4Print) Reset()         { *m = KeyInput4Print{} }
func (m *KeyInput4Print) String() string { return proto.CompactTextString(m) }
func (*KeyInput4Print) ProtoMessage()    {}
func (*KeyInput4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{23}
}

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

var xxx_messageInfo_KeyInput4Print proto.InternalMessageInfo

func (m *KeyInput4Print) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *KeyInput4Print) GetUtxoGlobalIndex() []*UTXOGlobalIndex4Print {
	if m != nil {
		return m.UtxoGlobalIndex
	}
	return nil
}

func (m *KeyInput4Print) GetKeyImage() string {
	if m != nil {
		return m.KeyImage
	}
	return ""
}

type KeyOutput4Print struct {
	Amount               int64    `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	Onetimepubkey        string   `protobuf:"bytes,2,opt,name=onetimepubkey,proto3" json:"onetimepubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KeyOutput4Print) Reset()         { *m = KeyOutput4Print{} }
func (m *KeyOutput4Print) String() string { return proto.CompactTextString(m) }
func (*KeyOutput4Print) ProtoMessage()    {}
func (*KeyOutput4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{24}
}

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

var xxx_messageInfo_KeyOutput4Print proto.InternalMessageInfo

func (m *KeyOutput4Print) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *KeyOutput4Print) GetOnetimepubkey() string {
	if m != nil {
		return m.Onetimepubkey
	}
	return ""
}

type PrivacyInput4Print struct {
	Keyinput             []*KeyInput4Print `protobuf:"bytes,1,rep,name=keyinput,proto3" json:"keyinput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *PrivacyInput4Print) Reset()         { *m = PrivacyInput4Print{} }
func (m *PrivacyInput4Print) String() string { return proto.CompactTextString(m) }
func (*PrivacyInput4Print) ProtoMessage()    {}
func (*PrivacyInput4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{25}
}

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

var xxx_messageInfo_PrivacyInput4Print proto.InternalMessageInfo

func (m *PrivacyInput4Print) GetKeyinput() []*KeyInput4Print {
	if m != nil {
		return m.Keyinput
	}
	return nil
}

type PrivacyOutput4Print struct {
	RpubKeytx            string             `protobuf:"bytes,1,opt,name=RpubKeytx,proto3" json:"RpubKeytx,omitempty"`
	Keyoutput            []*KeyOutput4Print `protobuf:"bytes,2,rep,name=keyoutput,proto3" json:"keyoutput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *PrivacyOutput4Print) Reset()         { *m = PrivacyOutput4Print{} }
func (m *PrivacyOutput4Print) String() string { return proto.CompactTextString(m) }
func (*PrivacyOutput4Print) ProtoMessage()    {}
func (*PrivacyOutput4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{26}
}

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

var xxx_messageInfo_PrivacyOutput4Print proto.InternalMessageInfo

func (m *PrivacyOutput4Print) GetRpubKeytx() string {
	if m != nil {
		return m.RpubKeytx
	}
	return ""
}

func (m *PrivacyOutput4Print) GetKeyoutput() []*KeyOutput4Print {
	if m != nil {
		return m.Keyoutput
	}
	return nil
}

type Public2Privacy4Print struct {
	Tokenname            string               `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64                `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string               `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	Output               *PrivacyOutput4Print `protobuf:"bytes,7,opt,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Public2Privacy4Print) Reset()         { *m = Public2Privacy4Print{} }
func (m *Public2Privacy4Print) String() string { return proto.CompactTextString(m) }
func (*Public2Privacy4Print) ProtoMessage()    {}
func (*Public2Privacy4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{27}
}

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

var xxx_messageInfo_Public2Privacy4Print proto.InternalMessageInfo

func (m *Public2Privacy4Print) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Public2Privacy4Print) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Public2Privacy4Print) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Public2Privacy4Print) GetOutput() *PrivacyOutput4Print {
	if m != nil {
		return m.Output
	}
	return nil
}

type Privacy2Privacy4Print struct {
	Tokenname            string               `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64                `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string               `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	Input                *PrivacyInput4Print  `protobuf:"bytes,6,opt,name=input,proto3" json:"input,omitempty"`
	Output               *PrivacyOutput4Print `protobuf:"bytes,7,opt,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Privacy2Privacy4Print) Reset()         { *m = Privacy2Privacy4Print{} }
func (m *Privacy2Privacy4Print) String() string { return proto.CompactTextString(m) }
func (*Privacy2Privacy4Print) ProtoMessage()    {}
func (*Privacy2Privacy4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{28}
}

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

var xxx_messageInfo_Privacy2Privacy4Print proto.InternalMessageInfo

func (m *Privacy2Privacy4Print) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Privacy2Privacy4Print) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Privacy2Privacy4Print) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Privacy2Privacy4Print) GetInput() *PrivacyInput4Print {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Privacy2Privacy4Print) GetOutput() *PrivacyOutput4Print {
	if m != nil {
		return m.Output
	}
	return nil
}

type Privacy2Public4Print struct {
	Tokenname            string               `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64                `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`
	Note                 string               `protobuf:"bytes,3,opt,name=note,proto3" json:"note,omitempty"`
	Input                *PrivacyInput4Print  `protobuf:"bytes,4,opt,name=input,proto3" json:"input,omitempty"`
	Output               *PrivacyOutput4Print `protobuf:"bytes,5,opt,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Privacy2Public4Print) Reset()         { *m = Privacy2Public4Print{} }
func (m *Privacy2Public4Print) String() string { return proto.CompactTextString(m) }
func (*Privacy2Public4Print) ProtoMessage()    {}
func (*Privacy2Public4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{29}
}

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

var xxx_messageInfo_Privacy2Public4Print proto.InternalMessageInfo

func (m *Privacy2Public4Print) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *Privacy2Public4Print) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *Privacy2Public4Print) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *Privacy2Public4Print) GetInput() *PrivacyInput4Print {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Privacy2Public4Print) GetOutput() *PrivacyOutput4Print {
	if m != nil {
		return m.Output
	}
	return nil
}

type PrivacyAction4Print struct {
	// Types that are valid to be assigned to Value:
	//	*PrivacyAction4Print_Public2Privacy
	//	*PrivacyAction4Print_Privacy2Privacy
	//	*PrivacyAction4Print_Privacy2Public
	Value                isPrivacyAction4Print_Value `protobuf_oneof:"value"`
	Ty                   int32                       `protobuf:"varint,4,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *PrivacyAction4Print) Reset()         { *m = PrivacyAction4Print{} }
func (m *PrivacyAction4Print) String() string { return proto.CompactTextString(m) }
func (*PrivacyAction4Print) ProtoMessage()    {}
func (*PrivacyAction4Print) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{30}
}

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

var xxx_messageInfo_PrivacyAction4Print proto.InternalMessageInfo

type isPrivacyAction4Print_Value interface {
	isPrivacyAction4Print_Value()
}

type PrivacyAction4Print_Public2Privacy struct {
	Public2Privacy *Public2Privacy4Print `protobuf:"bytes,1,opt,name=public2privacy,proto3,oneof"`
}

type PrivacyAction4Print_Privacy2Privacy struct {
	Privacy2Privacy *Privacy2Privacy4Print `protobuf:"bytes,2,opt,name=privacy2privacy,proto3,oneof"`
}

type PrivacyAction4Print_Privacy2Public struct {
	Privacy2Public *Privacy2Public4Print `protobuf:"bytes,3,opt,name=privacy2public,proto3,oneof"`
}

func (*PrivacyAction4Print_Public2Privacy) isPrivacyAction4Print_Value() {}

func (*PrivacyAction4Print_Privacy2Privacy) isPrivacyAction4Print_Value() {}

func (*PrivacyAction4Print_Privacy2Public) isPrivacyAction4Print_Value() {}

func (m *PrivacyAction4Print) GetValue() isPrivacyAction4Print_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *PrivacyAction4Print) GetPublic2Privacy() *Public2Privacy4Print {
	if x, ok := m.GetValue().(*PrivacyAction4Print_Public2Privacy); ok {
		return x.Public2Privacy
	}
	return nil
}

func (m *PrivacyAction4Print) GetPrivacy2Privacy() *Privacy2Privacy4Print {
	if x, ok := m.GetValue().(*PrivacyAction4Print_Privacy2Privacy); ok {
		return x.Privacy2Privacy
	}
	return nil
}

func (m *PrivacyAction4Print) GetPrivacy2Public() *Privacy2Public4Print {
	if x, ok := m.GetValue().(*PrivacyAction4Print_Privacy2Public); ok {
		return x.Privacy2Public
	}
	return nil
}

func (m *PrivacyAction4Print) GetTy() int32 {
	if m != nil {
		return m.Ty
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*PrivacyAction4Print) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _PrivacyAction4Print_OneofMarshaler, _PrivacyAction4Print_OneofUnmarshaler, _PrivacyAction4Print_OneofSizer, []interface{}{
		(*PrivacyAction4Print_Public2Privacy)(nil),
		(*PrivacyAction4Print_Privacy2Privacy)(nil),
		(*PrivacyAction4Print_Privacy2Public)(nil),
	}
}

func _PrivacyAction4Print_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*PrivacyAction4Print)
	// value
	switch x := m.Value.(type) {
	case *PrivacyAction4Print_Public2Privacy:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Public2Privacy); err != nil {
			return err
		}
	case *PrivacyAction4Print_Privacy2Privacy:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Privacy2Privacy); err != nil {
			return err
		}
	case *PrivacyAction4Print_Privacy2Public:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Privacy2Public); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("PrivacyAction4Print.Value has unexpected type %T", x)
	}
	return nil
}

func _PrivacyAction4Print_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*PrivacyAction4Print)
	switch tag {
	case 1: // value.public2privacy
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Public2Privacy4Print)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction4Print_Public2Privacy{msg}
		return true, err
	case 2: // value.privacy2privacy
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Privacy2Privacy4Print)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction4Print_Privacy2Privacy{msg}
		return true, err
	case 3: // value.privacy2public
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Privacy2Public4Print)
		err := b.DecodeMessage(msg)
		m.Value = &PrivacyAction4Print_Privacy2Public{msg}
		return true, err
	default:
		return false, nil
	}
}

func _PrivacyAction4Print_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*PrivacyAction4Print)
	// value
	switch x := m.Value.(type) {
	case *PrivacyAction4Print_Public2Privacy:
		s := proto.Size(x.Public2Privacy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *PrivacyAction4Print_Privacy2Privacy:
		s := proto.Size(x.Privacy2Privacy)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *PrivacyAction4Print_Privacy2Public:
		s := proto.Size(x.Privacy2Public)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ReplyPrivacyPkPair struct {
	ShowSuccessful bool `protobuf:"varint,1,opt,name=showSuccessful,proto3" json:"showSuccessful,omitempty"`
	// string viewPub       = 2;
	// string spendPub      = 3;
	Pubkeypair           string   `protobuf:"bytes,4,opt,name=pubkeypair,proto3" json:"pubkeypair,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReplyPrivacyPkPair) Reset()         { *m = ReplyPrivacyPkPair{} }
func (m *ReplyPrivacyPkPair) String() string { return proto.CompactTextString(m) }
func (*ReplyPrivacyPkPair) ProtoMessage()    {}
func (*ReplyPrivacyPkPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{31}
}

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

var xxx_messageInfo_ReplyPrivacyPkPair proto.InternalMessageInfo

func (m *ReplyPrivacyPkPair) GetShowSuccessful() bool {
	if m != nil {
		return m.ShowSuccessful
	}
	return false
}

func (m *ReplyPrivacyPkPair) GetPubkeypair() string {
	if m != nil {
		return m.Pubkeypair
	}
	return ""
}

type ReqPrivBal4AddrToken struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Token                string   `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqPrivBal4AddrToken) Reset()         { *m = ReqPrivBal4AddrToken{} }
func (m *ReqPrivBal4AddrToken) String() string { return proto.CompactTextString(m) }
func (*ReqPrivBal4AddrToken) ProtoMessage()    {}
func (*ReqPrivBal4AddrToken) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{32}
}

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

var xxx_messageInfo_ReqPrivBal4AddrToken proto.InternalMessageInfo

func (m *ReqPrivBal4AddrToken) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReqPrivBal4AddrToken) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

type ReplyPrivacyBalance struct {
	Onetimeaddr          string   `protobuf:"bytes,1,opt,name=onetimeaddr,proto3" json:"onetimeaddr,omitempty"`
	Balance              int64    `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReplyPrivacyBalance) Reset()         { *m = ReplyPrivacyBalance{} }
func (m *ReplyPrivacyBalance) String() string { return proto.CompactTextString(m) }
func (*ReplyPrivacyBalance) ProtoMessage()    {}
func (*ReplyPrivacyBalance) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{33}
}

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

var xxx_messageInfo_ReplyPrivacyBalance proto.InternalMessageInfo

func (m *ReplyPrivacyBalance) GetOnetimeaddr() string {
	if m != nil {
		return m.Onetimeaddr
	}
	return ""
}

func (m *ReplyPrivacyBalance) GetBalance() int64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

type PrivacyDBStore struct {
	Txhash               []byte   `protobuf:"bytes,1,opt,name=txhash,proto3" json:"txhash,omitempty"`
	Tokenname            string   `protobuf:"bytes,2,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Amount               int64    `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	OutIndex             int32    `protobuf:"varint,4,opt,name=outIndex,proto3" json:"outIndex,omitempty"`
	TxPublicKeyR         []byte   `protobuf:"bytes,5,opt,name=txPublicKeyR,proto3" json:"txPublicKeyR,omitempty"`
	OnetimePublicKey     []byte   `protobuf:"bytes,6,opt,name=onetimePublicKey,proto3" json:"onetimePublicKey,omitempty"`
	Owner                string   `protobuf:"bytes,7,opt,name=owner,proto3" json:"owner,omitempty"`
	Height               int64    `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty"`
	Txindex              int32    `protobuf:"varint,9,opt,name=txindex,proto3" json:"txindex,omitempty"`
	Blockhash            []byte   `protobuf:"bytes,10,opt,name=blockhash,proto3" json:"blockhash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrivacyDBStore) Reset()         { *m = PrivacyDBStore{} }
func (m *PrivacyDBStore) String() string { return proto.CompactTextString(m) }
func (*PrivacyDBStore) ProtoMessage()    {}
func (*PrivacyDBStore) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{34}
}

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

var xxx_messageInfo_PrivacyDBStore proto.InternalMessageInfo

func (m *PrivacyDBStore) GetTxhash() []byte {
	if m != nil {
		return m.Txhash
	}
	return nil
}

func (m *PrivacyDBStore) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *PrivacyDBStore) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *PrivacyDBStore) GetOutIndex() int32 {
	if m != nil {
		return m.OutIndex
	}
	return 0
}

func (m *PrivacyDBStore) GetTxPublicKeyR() []byte {
	if m != nil {
		return m.TxPublicKeyR
	}
	return nil
}

func (m *PrivacyDBStore) GetOnetimePublicKey() []byte {
	if m != nil {
		return m.OnetimePublicKey
	}
	return nil
}

func (m *PrivacyDBStore) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *PrivacyDBStore) GetHeight() int64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *PrivacyDBStore) GetTxindex() int32 {
	if m != nil {
		return m.Txindex
	}
	return 0
}

func (m *PrivacyDBStore) GetBlockhash() []byte {
	if m != nil {
		return m.Blockhash
	}
	return nil
}

type UTXO struct {
	Amount               int64      `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	UtxoBasic            *UTXOBasic `protobuf:"bytes,2,opt,name=utxoBasic,proto3" json:"utxoBasic,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UTXO) Reset()         { *m = UTXO{} }
func (m *UTXO) String() string { return proto.CompactTextString(m) }
func (*UTXO) ProtoMessage()    {}
func (*UTXO) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{35}
}

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

var xxx_messageInfo_UTXO proto.InternalMessageInfo

func (m *UTXO) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *UTXO) GetUtxoBasic() *UTXOBasic {
	if m != nil {
		return m.UtxoBasic
	}
	return nil
}

type UTXOHaveTxHash struct {
	Amount               int64      `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	TxHash               string     `protobuf:"bytes,2,opt,name=txHash,proto3" json:"txHash,omitempty"`
	UtxoBasic            *UTXOBasic `protobuf:"bytes,3,opt,name=utxoBasic,proto3" json:"utxoBasic,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *UTXOHaveTxHash) Reset()         { *m = UTXOHaveTxHash{} }
func (m *UTXOHaveTxHash) String() string { return proto.CompactTextString(m) }
func (*UTXOHaveTxHash) ProtoMessage()    {}
func (*UTXOHaveTxHash) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{36}
}

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

var xxx_messageInfo_UTXOHaveTxHash proto.InternalMessageInfo

func (m *UTXOHaveTxHash) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *UTXOHaveTxHash) GetTxHash() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

func (m *UTXOHaveTxHash) GetUtxoBasic() *UTXOBasic {
	if m != nil {
		return m.UtxoBasic
	}
	return nil
}

type UTXOs struct {
	Utxos                []*UTXO  `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UTXOs) Reset()         { *m = UTXOs{} }
func (m *UTXOs) String() string { return proto.CompactTextString(m) }
func (*UTXOs) ProtoMessage()    {}
func (*UTXOs) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{37}
}

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

var xxx_messageInfo_UTXOs proto.InternalMessageInfo

func (m *UTXOs) GetUtxos() []*UTXO {
	if m != nil {
		return m.Utxos
	}
	return nil
}

type UTXOHaveTxHashs struct {
	UtxoHaveTxHashs      []*UTXOHaveTxHash `protobuf:"bytes,1,rep,name=utxoHaveTxHashs,proto3" json:"utxoHaveTxHashs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *UTXOHaveTxHashs) Reset()         { *m = UTXOHaveTxHashs{} }
func (m *UTXOHaveTxHashs) String() string { return proto.CompactTextString(m) }
func (*UTXOHaveTxHashs) ProtoMessage()    {}
func (*UTXOHaveTxHashs) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{38}
}

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

var xxx_messageInfo_UTXOHaveTxHashs proto.InternalMessageInfo

func (m *UTXOHaveTxHashs) GetUtxoHaveTxHashs() []*UTXOHaveTxHash {
	if m != nil {
		return m.UtxoHaveTxHashs
	}
	return nil
}

type ReqUTXOGlobalIndex struct {
	Tokenname            string   `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	MixCount             int32    `protobuf:"varint,2,opt,name=mixCount,proto3" json:"mixCount,omitempty"`
	Amount               []int64  `protobuf:"varint,3,rep,packed,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqUTXOGlobalIndex) Reset()         { *m = ReqUTXOGlobalIndex{} }
func (m *ReqUTXOGlobalIndex) String() string { return proto.CompactTextString(m) }
func (*ReqUTXOGlobalIndex) ProtoMessage()    {}
func (*ReqUTXOGlobalIndex) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{39}
}

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

var xxx_messageInfo_ReqUTXOGlobalIndex proto.InternalMessageInfo

func (m *ReqUTXOGlobalIndex) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ReqUTXOGlobalIndex) GetMixCount() int32 {
	if m != nil {
		return m.MixCount
	}
	return 0
}

func (m *ReqUTXOGlobalIndex) GetAmount() []int64 {
	if m != nil {
		return m.Amount
	}
	return nil
}

type UTXOBasic struct {
	UtxoGlobalIndex      *UTXOGlobalIndex `protobuf:"bytes,1,opt,name=utxoGlobalIndex,proto3" json:"utxoGlobalIndex,omitempty"`
	OnetimePubkey        []byte           `protobuf:"bytes,2,opt,name=onetimePubkey,proto3" json:"onetimePubkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *UTXOBasic) Reset()         { *m = UTXOBasic{} }
func (m *UTXOBasic) String() string { return proto.CompactTextString(m) }
func (*UTXOBasic) ProtoMessage()    {}
func (*UTXOBasic) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{40}
}

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

var xxx_messageInfo_UTXOBasic proto.InternalMessageInfo

func (m *UTXOBasic) GetUtxoGlobalIndex() *UTXOGlobalIndex {
	if m != nil {
		return m.UtxoGlobalIndex
	}
	return nil
}

func (m *UTXOBasic) GetOnetimePubkey() []byte {
	if m != nil {
		return m.OnetimePubkey
	}
	return nil
}

type UTXOIndex4Amount struct {
	Amount               int64        `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	Utxos                []*UTXOBasic `protobuf:"bytes,2,rep,name=utxos,proto3" json:"utxos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *UTXOIndex4Amount) Reset()         { *m = UTXOIndex4Amount{} }
func (m *UTXOIndex4Amount) String() string { return proto.CompactTextString(m) }
func (*UTXOIndex4Amount) ProtoMessage()    {}
func (*UTXOIndex4Amount) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{41}
}

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

var xxx_messageInfo_UTXOIndex4Amount proto.InternalMessageInfo

func (m *UTXOIndex4Amount) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *UTXOIndex4Amount) GetUtxos() []*UTXOBasic {
	if m != nil {
		return m.Utxos
	}
	return nil
}

type ResUTXOGlobalIndex struct {
	Tokenname            string              `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	MixCount             int32               `protobuf:"varint,2,opt,name=mixCount,proto3" json:"mixCount,omitempty"`
	UtxoIndex4Amount     []*UTXOIndex4Amount `protobuf:"bytes,3,rep,name=utxoIndex4Amount,proto3" json:"utxoIndex4Amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ResUTXOGlobalIndex) Reset()         { *m = ResUTXOGlobalIndex{} }
func (m *ResUTXOGlobalIndex) String() string { return proto.CompactTextString(m) }
func (*ResUTXOGlobalIndex) ProtoMessage()    {}
func (*ResUTXOGlobalIndex) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{42}
}

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

var xxx_messageInfo_ResUTXOGlobalIndex proto.InternalMessageInfo

func (m *ResUTXOGlobalIndex) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ResUTXOGlobalIndex) GetMixCount() int32 {
	if m != nil {
		return m.MixCount
	}
	return 0
}

func (m *ResUTXOGlobalIndex) GetUtxoIndex4Amount() []*UTXOIndex4Amount {
	if m != nil {
		return m.UtxoIndex4Amount
	}
	return nil
}

type FTXOsSTXOsInOneTx struct {
	Tokenname string `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Sender    string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"`
	// FTXO的超期，设定原则与Transaction.expire一致
	Expire               int64    `protobuf:"varint,3,opt,name=expire,proto3" json:"expire,omitempty"`
	Txhash               string   `protobuf:"bytes,4,opt,name=txhash,proto3" json:"txhash,omitempty"`
	Utxos                []*UTXO  `protobuf:"bytes,5,rep,name=utxos,proto3" json:"utxos,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FTXOsSTXOsInOneTx) Reset()         { *m = FTXOsSTXOsInOneTx{} }
func (m *FTXOsSTXOsInOneTx) String() string { return proto.CompactTextString(m) }
func (*FTXOsSTXOsInOneTx) ProtoMessage()    {}
func (*FTXOsSTXOsInOneTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{43}
}

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

var xxx_messageInfo_FTXOsSTXOsInOneTx proto.InternalMessageInfo

func (m *FTXOsSTXOsInOneTx) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *FTXOsSTXOsInOneTx) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *FTXOsSTXOsInOneTx) GetExpire() int64 {
	if m != nil {
		return m.Expire
	}
	return 0
}

func (m *FTXOsSTXOsInOneTx) GetTxhash() string {
	if m != nil {
		return m.Txhash
	}
	return ""
}

func (m *FTXOsSTXOsInOneTx) GetUtxos() []*UTXO {
	if m != nil {
		return m.Utxos
	}
	return nil
}

type RealKeyInput struct {
	Realinputkey         int32    `protobuf:"varint,1,opt,name=realinputkey,proto3" json:"realinputkey,omitempty"`
	Onetimeprivkey       []byte   `protobuf:"bytes,2,opt,name=onetimeprivkey,proto3" json:"onetimeprivkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RealKeyInput) Reset()         { *m = RealKeyInput{} }
func (m *RealKeyInput) String() string { return proto.CompactTextString(m) }
func (*RealKeyInput) ProtoMessage()    {}
func (*RealKeyInput) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{44}
}

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

var xxx_messageInfo_RealKeyInput proto.InternalMessageInfo

func (m *RealKeyInput) GetRealinputkey() int32 {
	if m != nil {
		return m.Realinputkey
	}
	return 0
}

func (m *RealKeyInput) GetOnetimeprivkey() []byte {
	if m != nil {
		return m.Onetimeprivkey
	}
	return nil
}

type UTXOBasics struct {
	Utxos                []*UTXOBasic `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *UTXOBasics) Reset()         { *m = UTXOBasics{} }
func (m *UTXOBasics) String() string { return proto.CompactTextString(m) }
func (*UTXOBasics) ProtoMessage()    {}
func (*UTXOBasics) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{45}
}

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

var xxx_messageInfo_UTXOBasics proto.InternalMessageInfo

func (m *UTXOBasics) GetUtxos() []*UTXOBasic {
	if m != nil {
		return m.Utxos
	}
	return nil
}

type CreateTransactionCache struct {
	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// 记录创建时间，用以处理过期的交易
	Createtime int64 `protobuf:"varint,2,opt,name=createtime,proto3" json:"createtime,omitempty"`
	// 记录签名成功的时间，用以处理过期交易
	Signtime int64 `protobuf:"varint,3,opt,name=signtime,proto3" json:"signtime,omitempty"`
	// 缓存状态
	// 0 - 创建状态
	// 1 - 已经签名状态
	Status int32 `protobuf:"varint,4,opt,name=status,proto3" json:"status,omitempty"`
	//
	Transaction          *types.Transaction `protobuf:"bytes,5,opt,name=transaction,proto3" json:"transaction,omitempty"`
	Sender               string             `protobuf:"bytes,6,opt,name=sender,proto3" json:"sender,omitempty"`
	Realkeyinput         []*RealKeyInput    `protobuf:"bytes,7,rep,name=realkeyinput,proto3" json:"realkeyinput,omitempty"`
	Utxos                []*UTXOBasics      `protobuf:"bytes,8,rep,name=utxos,proto3" json:"utxos,omitempty"`
	Tokenname            string             `protobuf:"bytes,9,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *CreateTransactionCache) Reset()         { *m = CreateTransactionCache{} }
func (m *CreateTransactionCache) String() string { return proto.CompactTextString(m) }
func (*CreateTransactionCache) ProtoMessage()    {}
func (*CreateTransactionCache) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{46}
}

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

var xxx_messageInfo_CreateTransactionCache proto.InternalMessageInfo

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

func (m *CreateTransactionCache) GetCreatetime() int64 {
	if m != nil {
		return m.Createtime
	}
	return 0
}

func (m *CreateTransactionCache) GetSigntime() int64 {
	if m != nil {
		return m.Signtime
	}
	return 0
}

func (m *CreateTransactionCache) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

func (m *CreateTransactionCache) GetTransaction() *types.Transaction {
	if m != nil {
		return m.Transaction
	}
	return nil
}

func (m *CreateTransactionCache) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *CreateTransactionCache) GetRealkeyinput() []*RealKeyInput {
	if m != nil {
		return m.Realkeyinput
	}
	return nil
}

func (m *CreateTransactionCache) GetUtxos() []*UTXOBasics {
	if m != nil {
		return m.Utxos
	}
	return nil
}

func (m *CreateTransactionCache) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

type ReqCacheTxList struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Tokenname            string   `protobuf:"bytes,2,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqCacheTxList) Reset()         { *m = ReqCacheTxList{} }
func (m *ReqCacheTxList) String() string { return proto.CompactTextString(m) }
func (*ReqCacheTxList) ProtoMessage()    {}
func (*ReqCacheTxList) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{47}
}

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

var xxx_messageInfo_ReqCacheTxList proto.InternalMessageInfo

func (m *ReqCacheTxList) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReqCacheTxList) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

type ReplyCacheTxList struct {
	Txs                  []*types.Transaction `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ReplyCacheTxList) Reset()         { *m = ReplyCacheTxList{} }
func (m *ReplyCacheTxList) String() string { return proto.CompactTextString(m) }
func (*ReplyCacheTxList) ProtoMessage()    {}
func (*ReplyCacheTxList) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{48}
}

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

var xxx_messageInfo_ReplyCacheTxList proto.InternalMessageInfo

func (m *ReplyCacheTxList) GetTxs() []*types.Transaction {
	if m != nil {
		return m.Txs
	}
	return nil
}

type ReqPrivacyAccount struct {
	Tokenname            string   `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqPrivacyAccount) Reset()         { *m = ReqPrivacyAccount{} }
func (m *ReqPrivacyAccount) String() string { return proto.CompactTextString(m) }
func (*ReqPrivacyAccount) ProtoMessage()    {}
func (*ReqPrivacyAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{49}
}

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

var xxx_messageInfo_ReqPrivacyAccount proto.InternalMessageInfo

func (m *ReqPrivacyAccount) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ReqPrivacyAccount) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

type ReqPPrivacyAccount struct {
	Addr  string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
	// 设定显示的数据类型信息
	// 0： 只显示账户的数值信息
	// 1： 显示UTXO明细
	// 2： 显示FTXO明细
	// 3： 全部显示
	Displaymode          int32    `protobuf:"varint,3,opt,name=displaymode,proto3" json:"displaymode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqPPrivacyAccount) Reset()         { *m = ReqPPrivacyAccount{} }
func (m *ReqPPrivacyAccount) String() string { return proto.CompactTextString(m) }
func (*ReqPPrivacyAccount) ProtoMessage()    {}
func (*ReqPPrivacyAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{50}
}

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

var xxx_messageInfo_ReqPPrivacyAccount proto.InternalMessageInfo

func (m *ReqPPrivacyAccount) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReqPPrivacyAccount) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *ReqPPrivacyAccount) GetDisplaymode() int32 {
	if m != nil {
		return m.Displaymode
	}
	return 0
}

// 请求隐私账户信息的应答
type ReplyPrivacyAccount struct {
	// 未花费的UTXO
	Utxos *UTXOs `protobuf:"bytes,1,opt,name=utxos,proto3" json:"utxos,omitempty"`
	// 冻结的UTXO
	Ftxos                *UTXOs   `protobuf:"bytes,2,opt,name=ftxos,proto3" json:"ftxos,omitempty"`
	Displaymode          int32    `protobuf:"varint,3,opt,name=displaymode,proto3" json:"displaymode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReplyPrivacyAccount) Reset()         { *m = ReplyPrivacyAccount{} }
func (m *ReplyPrivacyAccount) String() string { return proto.CompactTextString(m) }
func (*ReplyPrivacyAccount) ProtoMessage()    {}
func (*ReplyPrivacyAccount) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{51}
}

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

var xxx_messageInfo_ReplyPrivacyAccount proto.InternalMessageInfo

func (m *ReplyPrivacyAccount) GetUtxos() *UTXOs {
	if m != nil {
		return m.Utxos
	}
	return nil
}

func (m *ReplyPrivacyAccount) GetFtxos() *UTXOs {
	if m != nil {
		return m.Ftxos
	}
	return nil
}

func (m *ReplyPrivacyAccount) GetDisplaymode() int32 {
	if m != nil {
		return m.Displaymode
	}
	return 0
}

type ReqCreateCacheTxKey struct {
	Tokenname            string   `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	Hashkey              []byte   `protobuf:"bytes,2,opt,name=hashkey,proto3" json:"hashkey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqCreateCacheTxKey) Reset()         { *m = ReqCreateCacheTxKey{} }
func (m *ReqCreateCacheTxKey) String() string { return proto.CompactTextString(m) }
func (*ReqCreateCacheTxKey) ProtoMessage()    {}
func (*ReqCreateCacheTxKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{52}
}

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

var xxx_messageInfo_ReqCreateCacheTxKey proto.InternalMessageInfo

func (m *ReqCreateCacheTxKey) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ReqCreateCacheTxKey) GetHashkey() []byte {
	if m != nil {
		return m.Hashkey
	}
	return nil
}

// get privacy transaction list in wallet
type ReqPrivacyTransactionList struct {
	// support BTY
	Tokenname string `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	// 1:sendtx  2:recvtx
	SendRecvFlag         int32    `protobuf:"varint,2,opt,name=sendRecvFlag,proto3" json:"sendRecvFlag,omitempty"`
	Direction            int32    `protobuf:"varint,3,opt,name=direction,proto3" json:"direction,omitempty"`
	Count                int32    `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
	From                 string   `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
	Address              string   `protobuf:"bytes,6,opt,name=address,proto3" json:"address,omitempty"`
	Seedtxhash           []byte   `protobuf:"bytes,7,opt,name=seedtxhash,proto3" json:"seedtxhash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqPrivacyTransactionList) Reset()         { *m = ReqPrivacyTransactionList{} }
func (m *ReqPrivacyTransactionList) String() string { return proto.CompactTextString(m) }
func (*ReqPrivacyTransactionList) ProtoMessage()    {}
func (*ReqPrivacyTransactionList) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{53}
}

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

var xxx_messageInfo_ReqPrivacyTransactionList proto.InternalMessageInfo

func (m *ReqPrivacyTransactionList) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ReqPrivacyTransactionList) GetSendRecvFlag() int32 {
	if m != nil {
		return m.SendRecvFlag
	}
	return 0
}

func (m *ReqPrivacyTransactionList) GetDirection() int32 {
	if m != nil {
		return m.Direction
	}
	return 0
}

func (m *ReqPrivacyTransactionList) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *ReqPrivacyTransactionList) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

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

func (m *ReqPrivacyTransactionList) GetSeedtxhash() []byte {
	if m != nil {
		return m.Seedtxhash
	}
	return nil
}

type ReqRescanUtxos struct {
	Addrs                []string `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs,omitempty"`
	Flag                 int32    `protobuf:"varint,2,opt,name=flag,proto3" json:"flag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqRescanUtxos) Reset()         { *m = ReqRescanUtxos{} }
func (m *ReqRescanUtxos) String() string { return proto.CompactTextString(m) }
func (*ReqRescanUtxos) ProtoMessage()    {}
func (*ReqRescanUtxos) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{54}
}

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

var xxx_messageInfo_ReqRescanUtxos proto.InternalMessageInfo

func (m *ReqRescanUtxos) GetAddrs() []string {
	if m != nil {
		return m.Addrs
	}
	return nil
}

func (m *ReqRescanUtxos) GetFlag() int32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

type RepRescanResult struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Flag                 int32    `protobuf:"varint,2,opt,name=flag,proto3" json:"flag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RepRescanResult) Reset()         { *m = RepRescanResult{} }
func (m *RepRescanResult) String() string { return proto.CompactTextString(m) }
func (*RepRescanResult) ProtoMessage()    {}
func (*RepRescanResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{55}
}

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

var xxx_messageInfo_RepRescanResult proto.InternalMessageInfo

func (m *RepRescanResult) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *RepRescanResult) GetFlag() int32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

type RepRescanUtxos struct {
	Flag                 int32              `protobuf:"varint,1,opt,name=flag,proto3" json:"flag,omitempty"`
	RepRescanResults     []*RepRescanResult `protobuf:"bytes,2,rep,name=repRescanResults,proto3" json:"repRescanResults,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *RepRescanUtxos) Reset()         { *m = RepRescanUtxos{} }
func (m *RepRescanUtxos) String() string { return proto.CompactTextString(m) }
func (*RepRescanUtxos) ProtoMessage()    {}
func (*RepRescanUtxos) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{56}
}

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

var xxx_messageInfo_RepRescanUtxos proto.InternalMessageInfo

func (m *RepRescanUtxos) GetFlag() int32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

func (m *RepRescanUtxos) GetRepRescanResults() []*RepRescanResult {
	if m != nil {
		return m.RepRescanResults
	}
	return nil
}

type ReqEnablePrivacy struct {
	Addrs                []string `protobuf:"bytes,2,rep,name=addrs,proto3" json:"addrs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqEnablePrivacy) Reset()         { *m = ReqEnablePrivacy{} }
func (m *ReqEnablePrivacy) String() string { return proto.CompactTextString(m) }
func (*ReqEnablePrivacy) ProtoMessage()    {}
func (*ReqEnablePrivacy) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{57}
}

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

var xxx_messageInfo_ReqEnablePrivacy proto.InternalMessageInfo

func (m *ReqEnablePrivacy) GetAddrs() []string {
	if m != nil {
		return m.Addrs
	}
	return nil
}

type PriAddrResult struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	IsOK                 bool     `protobuf:"varint,2,opt,name=IsOK,proto3" json:"IsOK,omitempty"`
	Msg                  string   `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PriAddrResult) Reset()         { *m = PriAddrResult{} }
func (m *PriAddrResult) String() string { return proto.CompactTextString(m) }
func (*PriAddrResult) ProtoMessage()    {}
func (*PriAddrResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{58}
}

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

var xxx_messageInfo_PriAddrResult proto.InternalMessageInfo

func (m *PriAddrResult) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *PriAddrResult) GetIsOK() bool {
	if m != nil {
		return m.IsOK
	}
	return false
}

func (m *PriAddrResult) GetMsg() string {
	if m != nil {
		return m.Msg
	}
	return ""
}

type RepEnablePrivacy struct {
	Results              []*PriAddrResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *RepEnablePrivacy) Reset()         { *m = RepEnablePrivacy{} }
func (m *RepEnablePrivacy) String() string { return proto.CompactTextString(m) }
func (*RepEnablePrivacy) ProtoMessage()    {}
func (*RepEnablePrivacy) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{59}
}

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

var xxx_messageInfo_RepEnablePrivacy proto.InternalMessageInfo

func (m *RepEnablePrivacy) GetResults() []*PriAddrResult {
	if m != nil {
		return m.Results
	}
	return nil
}

// 隐私交易三步发送时，临时存储签名需要的数据信息结构
type PrivacySignatureParam struct {
	ActionType           int32           `protobuf:"varint,1,opt,name=actionType,proto3" json:"actionType,omitempty"`
	Utxobasics           []*UTXOBasics   `protobuf:"bytes,2,rep,name=utxobasics,proto3" json:"utxobasics,omitempty"`
	RealKeyInputs        []*RealKeyInput `protobuf:"bytes,3,rep,name=realKeyInputs,proto3" json:"realKeyInputs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *PrivacySignatureParam) Reset()         { *m = PrivacySignatureParam{} }
func (m *PrivacySignatureParam) String() string { return proto.CompactTextString(m) }
func (*PrivacySignatureParam) ProtoMessage()    {}
func (*PrivacySignatureParam) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{60}
}

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

var xxx_messageInfo_PrivacySignatureParam proto.InternalMessageInfo

func (m *PrivacySignatureParam) GetActionType() int32 {
	if m != nil {
		return m.ActionType
	}
	return 0
}

func (m *PrivacySignatureParam) GetUtxobasics() []*UTXOBasics {
	if m != nil {
		return m.Utxobasics
	}
	return nil
}

func (m *PrivacySignatureParam) GetRealKeyInputs() []*RealKeyInput {
	if m != nil {
		return m.RealKeyInputs
	}
	return nil
}

type WalletAccountPrivacy struct {
	ViewPubkey           []byte   `protobuf:"bytes,1,opt,name=viewPubkey,proto3" json:"viewPubkey,omitempty"`
	ViewPrivKey          []byte   `protobuf:"bytes,2,opt,name=viewPrivKey,proto3" json:"viewPrivKey,omitempty"`
	SpendPubkey          []byte   `protobuf:"bytes,3,opt,name=spendPubkey,proto3" json:"spendPubkey,omitempty"`
	SpendPrivKey         []byte   `protobuf:"bytes,4,opt,name=spendPrivKey,proto3" json:"spendPrivKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WalletAccountPrivacy) Reset()         { *m = WalletAccountPrivacy{} }
func (m *WalletAccountPrivacy) String() string { return proto.CompactTextString(m) }
func (*WalletAccountPrivacy) ProtoMessage()    {}
func (*WalletAccountPrivacy) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{61}
}

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

var xxx_messageInfo_WalletAccountPrivacy proto.InternalMessageInfo

func (m *WalletAccountPrivacy) GetViewPubkey() []byte {
	if m != nil {
		return m.ViewPubkey
	}
	return nil
}

func (m *WalletAccountPrivacy) GetViewPrivKey() []byte {
	if m != nil {
		return m.ViewPrivKey
	}
	return nil
}

func (m *WalletAccountPrivacy) GetSpendPubkey() []byte {
	if m != nil {
		return m.SpendPubkey
	}
	return nil
}

func (m *WalletAccountPrivacy) GetSpendPrivKey() []byte {
	if m != nil {
		return m.SpendPrivKey
	}
	return nil
}

// 创建隐私交易请求
type ReqCreatePrivacyTx struct {
	Tokenname string `protobuf:"bytes,1,opt,name=tokenname,proto3" json:"tokenname,omitempty"`
	// 构建交易类型
	// 1：隐私交易 公开->隐私
	// 2：隐私交易 隐私->隐私
	// 3：隐私交易 隐私->公开
	Type   int32  `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	Amount int64  `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	Note   string `protobuf:"bytes,4,opt,name=note,proto3" json:"note,omitempty"`
	// 普通交易的发送方
	From string `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
	// 普通交易的接收方
	To string `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
	// 隐私交易，接收方的公钥对
	Pubkeypair           string   `protobuf:"bytes,10,opt,name=pubkeypair,proto3" json:"pubkeypair,omitempty"`
	Mixcount             int32    `protobuf:"varint,11,opt,name=mixcount,proto3" json:"mixcount,omitempty"`
	Expire               int64    `protobuf:"varint,12,opt,name=expire,proto3" json:"expire,omitempty"`
	AssetExec            string   `protobuf:"bytes,13,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqCreatePrivacyTx) Reset()         { *m = ReqCreatePrivacyTx{} }
func (m *ReqCreatePrivacyTx) String() string { return proto.CompactTextString(m) }
func (*ReqCreatePrivacyTx) ProtoMessage()    {}
func (*ReqCreatePrivacyTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_dde03d4df7a6e99a, []int{62}
}

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

var xxx_messageInfo_ReqCreatePrivacyTx proto.InternalMessageInfo

func (m *ReqCreatePrivacyTx) GetTokenname() string {
	if m != nil {
		return m.Tokenname
	}
	return ""
}

func (m *ReqCreatePrivacyTx) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *ReqCreatePrivacyTx) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *ReqCreatePrivacyTx) GetNote() string {
	if m != nil {
		return m.Note
	}
	return ""
}

func (m *ReqCreatePrivacyTx) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

func (m *ReqCreatePrivacyTx) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *ReqCreatePrivacyTx) GetPubkeypair() string {
	if m != nil {
		return m.Pubkeypair
	}
	return ""
}

func (m *ReqCreatePrivacyTx) GetMixcount() int32 {
	if m != nil {
		return m.Mixcount
	}
	return 0
}

func (m *ReqCreatePrivacyTx) GetExpire() int64 {
	if m != nil {
		return m.Expire
	}
	return 0
}

func (m *ReqCreatePrivacyTx) GetAssetExec() string {
	if m != nil {
		return m.AssetExec
	}
	return ""
}

func init() {
	proto.RegisterType((*PrivacyAction)(nil), "types.PrivacyAction")
	proto.RegisterType((*Public2Privacy)(nil), "types.Public2Privacy")
	proto.RegisterType((*Privacy2Privacy)(nil), "types.Privacy2Privacy")
	proto.RegisterType((*Privacy2Public)(nil), "types.Privacy2Public")
	proto.RegisterType((*UTXOGlobalIndex)(nil), "types.UTXOGlobalIndex")
	proto.RegisterType((*KeyInput)(nil), "types.KeyInput")
	proto.RegisterType((*PrivacyInput)(nil), "types.PrivacyInput")
	proto.RegisterType((*KeyOutput)(nil), "types.keyOutput")
	proto.RegisterType((*PrivacyOutput)(nil), "types.PrivacyOutput")
	proto.RegisterType((*GroupUTXOGlobalIndex)(nil), "types.GroupUTXOGlobalIndex")
	proto.RegisterType((*LocalUTXOItem)(nil), "types.LocalUTXOItem")
	proto.RegisterType((*ReqUTXOPubKeys)(nil), "types.ReqUTXOPubKeys")
	proto.RegisterType((*PublicKeyData)(nil), "types.PublicKeyData")
	proto.RegisterType((*GroupUTXOPubKey)(nil), "types.GroupUTXOPubKey")
	proto.RegisterType((*ResUTXOPubKeys)(nil), "types.ResUTXOPubKeys")
	proto.RegisterType((*ReqPrivacyToken)(nil), "types.ReqPrivacyToken")
	proto.RegisterType((*AmountDetail)(nil), "types.AmountDetail")
	proto.RegisterType((*ReplyPrivacyAmounts)(nil), "types.ReplyPrivacyAmounts")
	proto.RegisterType((*ReplyUTXOsOfAmount)(nil), "types.replyUTXOsOfAmount")
	proto.RegisterType((*ReceiptPrivacyOutput)(nil), "types.ReceiptPrivacyOutput")
	proto.RegisterType((*AmountsOfUTXO)(nil), "types.AmountsOfUTXO")
	proto.RegisterMapType((map[int64]int64)(nil), "types.AmountsOfUTXO.AmountMapEntry")
	proto.RegisterType((*TokenNamesOfUTXO)(nil), "types.TokenNamesOfUTXO")
	proto.RegisterMapType((map[string]string)(nil), "types.TokenNamesOfUTXO.TokensMapEntry")
	proto.RegisterType((*UTXOGlobalIndex4Print)(nil), "types.UTXOGlobalIndex4Print")
	proto.RegisterType((*KeyInput4Print)(nil), "types.KeyInput4Print")
	proto.RegisterType((*KeyOutput4Print)(nil), "types.keyOutput4Print")
	proto.RegisterType((*PrivacyInput4Print)(nil), "types.PrivacyInput4Print")
	proto.RegisterType((*PrivacyOutput4Print)(nil), "types.PrivacyOutput4Print")
	proto.RegisterType((*Public2Privacy4Print)(nil), "types.Public2Privacy4Print")
	proto.RegisterType((*Privacy2Privacy4Print)(nil), "types.Privacy2Privacy4Print")
	proto.RegisterType((*Privacy2Public4Print)(nil), "types.Privacy2Public4Print")
	proto.RegisterType((*PrivacyAction4Print)(nil), "types.PrivacyAction4Print")
	proto.RegisterType((*ReplyPrivacyPkPair)(nil), "types.ReplyPrivacyPkPair")
	proto.RegisterType((*ReqPrivBal4AddrToken)(nil), "types.ReqPrivBal4AddrToken")
	proto.RegisterType((*ReplyPrivacyBalance)(nil), "types.ReplyPrivacyBalance")
	proto.RegisterType((*PrivacyDBStore)(nil), "types.PrivacyDBStore")
	proto.RegisterType((*UTXO)(nil), "types.UTXO")
	proto.RegisterType((*UTXOHaveTxHash)(nil), "types.UTXOHaveTxHash")
	proto.RegisterType((*UTXOs)(nil), "types.UTXOs")
	proto.RegisterType((*UTXOHaveTxHashs)(nil), "types.UTXOHaveTxHashs")
	proto.RegisterType((*ReqUTXOGlobalIndex)(nil), "types.ReqUTXOGlobalIndex")
	proto.RegisterType((*UTXOBasic)(nil), "types.UTXOBasic")
	proto.RegisterType((*UTXOIndex4Amount)(nil), "types.UTXOIndex4Amount")
	proto.RegisterType((*ResUTXOGlobalIndex)(nil), "types.ResUTXOGlobalIndex")
	proto.RegisterType((*FTXOsSTXOsInOneTx)(nil), "types.FTXOsSTXOsInOneTx")
	proto.RegisterType((*RealKeyInput)(nil), "types.RealKeyInput")
	proto.RegisterType((*UTXOBasics)(nil), "types.UTXOBasics")
	proto.RegisterType((*CreateTransactionCache)(nil), "types.CreateTransactionCache")
	proto.RegisterType((*ReqCacheTxList)(nil), "types.ReqCacheTxList")
	proto.RegisterType((*ReplyCacheTxList)(nil), "types.ReplyCacheTxList")
	proto.RegisterType((*ReqPrivacyAccount)(nil), "types.ReqPrivacyAccount")
	proto.RegisterType((*ReqPPrivacyAccount)(nil), "types.ReqPPrivacyAccount")
	proto.RegisterType((*ReplyPrivacyAccount)(nil), "types.ReplyPrivacyAccount")
	proto.RegisterType((*ReqCreateCacheTxKey)(nil), "types.ReqCreateCacheTxKey")
	proto.RegisterType((*ReqPrivacyTransactionList)(nil), "types.ReqPrivacyTransactionList")
	proto.RegisterType((*ReqRescanUtxos)(nil), "types.ReqRescanUtxos")
	proto.RegisterType((*RepRescanResult)(nil), "types.RepRescanResult")
	proto.RegisterType((*RepRescanUtxos)(nil), "types.RepRescanUtxos")
	proto.RegisterType((*ReqEnablePrivacy)(nil), "types.ReqEnablePrivacy")
	proto.RegisterType((*PriAddrResult)(nil), "types.PriAddrResult")
	proto.RegisterType((*RepEnablePrivacy)(nil), "types.RepEnablePrivacy")
	proto.RegisterType((*PrivacySignatureParam)(nil), "types.PrivacySignatureParam")
	proto.RegisterType((*WalletAccountPrivacy)(nil), "types.WalletAccountPrivacy")
	proto.RegisterType((*ReqCreatePrivacyTx)(nil), "types.ReqCreatePrivacyTx")
}

func init() { proto.RegisterFile("privacy.proto", fileDescriptor_dde03d4df7a6e99a) }

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

// PrivacyClient is the client API for Privacy service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PrivacyClient interface {
	// Privacy Trading
	// 显示指定地址的公钥对信息，可以作为后续交易参数
	ShowPrivacyKey(ctx context.Context, in *types.ReqString, opts ...grpc.CallOption) (*ReplyPrivacyPkPair, error)
	// 扫描UTXO以及获取扫描UTXO后的状态
	RescanUtxos(ctx context.Context, in *ReqRescanUtxos, opts ...grpc.CallOption) (*RepRescanUtxos, error)
	// 使能隐私账户
	EnablePrivacy(ctx context.Context, in *ReqEnablePrivacy, opts ...grpc.CallOption) (*RepEnablePrivacy, error)
	// 创建隐私交易
	CreateRawTransaction(ctx context.Context, in *ReqCreatePrivacyTx, opts ...grpc.CallOption) (*types.Transaction, error)
}

type privacyClient struct {
	cc *grpc.ClientConn
}

func NewPrivacyClient(cc *grpc.ClientConn) PrivacyClient {
	return &privacyClient{cc}
}

func (c *privacyClient) ShowPrivacyKey(ctx context.Context, in *types.ReqString, opts ...grpc.CallOption) (*ReplyPrivacyPkPair, error) {
	out := new(ReplyPrivacyPkPair)
	err := c.cc.Invoke(ctx, "/types.privacy/ShowPrivacyKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privacyClient) RescanUtxos(ctx context.Context, in *ReqRescanUtxos, opts ...grpc.CallOption) (*RepRescanUtxos, error) {
	out := new(RepRescanUtxos)
	err := c.cc.Invoke(ctx, "/types.privacy/RescanUtxos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privacyClient) EnablePrivacy(ctx context.Context, in *ReqEnablePrivacy, opts ...grpc.CallOption) (*RepEnablePrivacy, error) {
	out := new(RepEnablePrivacy)
	err := c.cc.Invoke(ctx, "/types.privacy/EnablePrivacy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *privacyClient) CreateRawTransaction(ctx context.Context, in *ReqCreatePrivacyTx, opts ...grpc.CallOption) (*types.Transaction, error) {
	out := new(types.Transaction)
	err := c.cc.Invoke(ctx, "/types.privacy/CreateRawTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PrivacyServer is the server API for Privacy service.
type PrivacyServer interface {
	// Privacy Trading
	// 显示指定地址的公钥对信息，可以作为后续交易参数
	ShowPrivacyKey(context.Context, *types.ReqString) (*ReplyPrivacyPkPair, error)
	// 扫描UTXO以及获取扫描UTXO后的状态
	RescanUtxos(context.Context, *ReqRescanUtxos) (*RepRescanUtxos, error)
	// 使能隐私账户
	EnablePrivacy(context.Context, *ReqEnablePrivacy) (*RepEnablePrivacy, error)
	// 创建隐私交易
	CreateRawTransaction(context.Context, *ReqCreatePrivacyTx) (*types.Transaction, error)
}

func RegisterPrivacyServer(s *grpc.Server, srv PrivacyServer) {
	s.RegisterService(&_Privacy_serviceDesc, srv)
}

func _Privacy_ShowPrivacyKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.ReqString)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivacyServer).ShowPrivacyKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.privacy/ShowPrivacyKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivacyServer).ShowPrivacyKey(ctx, req.(*types.ReqString))
	}
	return interceptor(ctx, in, info, handler)
}

func _Privacy_RescanUtxos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqRescanUtxos)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivacyServer).RescanUtxos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.privacy/RescanUtxos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivacyServer).RescanUtxos(ctx, req.(*ReqRescanUtxos))
	}
	return interceptor(ctx, in, info, handler)
}

func _Privacy_EnablePrivacy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqEnablePrivacy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivacyServer).EnablePrivacy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.privacy/EnablePrivacy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivacyServer).EnablePrivacy(ctx, req.(*ReqEnablePrivacy))
	}
	return interceptor(ctx, in, info, handler)
}

func _Privacy_CreateRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqCreatePrivacyTx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PrivacyServer).CreateRawTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.privacy/CreateRawTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PrivacyServer).CreateRawTransaction(ctx, req.(*ReqCreatePrivacyTx))
	}
	return interceptor(ctx, in, info, handler)
}

var _Privacy_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.privacy",
	HandlerType: (*PrivacyServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ShowPrivacyKey",
			Handler:    _Privacy_ShowPrivacyKey_Handler,
		},
		{
			MethodName: "RescanUtxos",
			Handler:    _Privacy_RescanUtxos_Handler,
		},
		{
			MethodName: "EnablePrivacy",
			Handler:    _Privacy_EnablePrivacy_Handler,
		},
		{
			MethodName: "CreateRawTransaction",
			Handler:    _Privacy_CreateRawTransaction_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "privacy.proto",
}
