// Code generated by protoc-gen-go. DO NOT EDIT.
// source: mix.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"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

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

//区分不同的验证电路
type VerifyType int32

const (
	VerifyType_DEPOSIT        VerifyType = 0
	VerifyType_WITHDRAW       VerifyType = 1
	VerifyType_TRANSFERINPUT  VerifyType = 2
	VerifyType_TRANSFEROUTPUT VerifyType = 3
	VerifyType_AUTHORIZE      VerifyType = 4
)

var VerifyType_name = map[int32]string{
	0: "DEPOSIT",
	1: "WITHDRAW",
	2: "TRANSFERINPUT",
	3: "TRANSFEROUTPUT",
	4: "AUTHORIZE",
}

var VerifyType_value = map[string]int32{
	"DEPOSIT":        0,
	"WITHDRAW":       1,
	"TRANSFERINPUT":  2,
	"TRANSFEROUTPUT": 3,
	"AUTHORIZE":      4,
}

func (x VerifyType) String() string {
	return proto.EnumName(VerifyType_name, int32(x))
}

func (VerifyType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{0}
}

//区分zk 所选取的曲线，需要和gnark保持一致
type ZkCurveId int32

const (
	ZkCurveId_UNKNOWN ZkCurveId = 0
	ZkCurveId_BLS377  ZkCurveId = 1
	ZkCurveId_BLS381  ZkCurveId = 2
	ZkCurveId_BN256   ZkCurveId = 3
)

var ZkCurveId_name = map[int32]string{
	0: "UNKNOWN",
	1: "BLS377",
	2: "BLS381",
	3: "BN256",
}

var ZkCurveId_value = map[string]int32{
	"UNKNOWN": 0,
	"BLS377":  1,
	"BLS381":  2,
	"BN256":   3,
}

func (x ZkCurveId) String() string {
	return proto.EnumName(ZkCurveId_name, int32(x))
}

func (ZkCurveId) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{1}
}

type MixConfigType int32

const (
	MixConfigType_VerifyKey MixConfigType = 0
	//register unify authorize pubkey
	MixConfigType_AuthPubKey MixConfigType = 1
	//for spender's pay pubkey register,DH secret
	MixConfigType_PaymentPubKey MixConfigType = 2
)

var MixConfigType_name = map[int32]string{
	0: "VerifyKey",
	1: "AuthPubKey",
	2: "PaymentPubKey",
}

var MixConfigType_value = map[string]int32{
	"VerifyKey":     0,
	"AuthPubKey":    1,
	"PaymentPubKey": 2,
}

func (x MixConfigType) String() string {
	return proto.EnumName(MixConfigType_name, int32(x))
}

func (MixConfigType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{2}
}

type MixConfigAct int32

const (
	MixConfigAct_Add    MixConfigAct = 0
	MixConfigAct_Delete MixConfigAct = 1
)

var MixConfigAct_name = map[int32]string{
	0: "Add",
	1: "Delete",
}

var MixConfigAct_value = map[string]int32{
	"Add":    0,
	"Delete": 1,
}

func (x MixConfigAct) String() string {
	return proto.EnumName(MixConfigAct_name, int32(x))
}

func (MixConfigAct) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{3}
}

type NoteStatus int32

const (
	NoteStatus_UNDEF  NoteStatus = 0
	NoteStatus_FROZEN NoteStatus = 1
	NoteStatus_OPEN   NoteStatus = 2
	NoteStatus_CLOSE  NoteStatus = 3
)

var NoteStatus_name = map[int32]string{
	0: "UNDEF",
	1: "FROZEN",
	2: "OPEN",
	3: "CLOSE",
}

var NoteStatus_value = map[string]int32{
	"UNDEF":  0,
	"FROZEN": 1,
	"OPEN":   2,
	"CLOSE":  3,
}

func (x NoteStatus) String() string {
	return proto.EnumName(NoteStatus_name, int32(x))
}

func (NoteStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{4}
}

type MixWalletRescanStatus int32

const (
	MixWalletRescanStatus_IDLE     MixWalletRescanStatus = 0
	MixWalletRescanStatus_SCANNING MixWalletRescanStatus = 1
	MixWalletRescanStatus_FINISHED MixWalletRescanStatus = 2
)

var MixWalletRescanStatus_name = map[int32]string{
	0: "IDLE",
	1: "SCANNING",
	2: "FINISHED",
}

var MixWalletRescanStatus_value = map[string]int32{
	"IDLE":     0,
	"SCANNING": 1,
	"FINISHED": 2,
}

func (x MixWalletRescanStatus) String() string {
	return proto.EnumName(MixWalletRescanStatus_name, int32(x))
}

func (MixWalletRescanStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{5}
}

type ZkVerifyKey struct {
	CurveId              ZkCurveId  `protobuf:"varint,1,opt,name=curveId,proto3,enum=types.ZkCurveId" json:"curveId,omitempty"`
	Type                 VerifyType `protobuf:"varint,2,opt,name=type,proto3,enum=types.VerifyType" json:"type,omitempty"`
	Value                string     `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_ZkVerifyKey proto.InternalMessageInfo

func (m *ZkVerifyKey) GetCurveId() ZkCurveId {
	if m != nil {
		return m.CurveId
	}
	return ZkCurveId_UNKNOWN
}

func (m *ZkVerifyKey) GetType() VerifyType {
	if m != nil {
		return m.Type
	}
	return VerifyType_DEPOSIT
}

func (m *ZkVerifyKey) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type ZkVerifyKeys struct {
	Data                 []*ZkVerifyKey `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_ZkVerifyKeys proto.InternalMessageInfo

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

type AuthPubKeys struct {
	Data                 []string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthPubKeys proto.InternalMessageInfo

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

//config verify parameter for proof
//当前authPk=mimc_hash(prikey),没有X,Y值
type MixConfigAction struct {
	Ty     MixConfigType `protobuf:"varint,1,opt,name=Ty,proto3,enum=types.MixConfigType" json:"Ty,omitempty"`
	Action MixConfigAct  `protobuf:"varint,2,opt,name=Action,proto3,enum=types.MixConfigAct" json:"Action,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*MixConfigAction_VerifyKey
	//	*MixConfigAction_AuthPk
	//	*MixConfigAction_PaymentPk
	Value                isMixConfigAction_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_MixConfigAction proto.InternalMessageInfo

func (m *MixConfigAction) GetTy() MixConfigType {
	if m != nil {
		return m.Ty
	}
	return MixConfigType_VerifyKey
}

func (m *MixConfigAction) GetAction() MixConfigAct {
	if m != nil {
		return m.Action
	}
	return MixConfigAct_Add
}

type isMixConfigAction_Value interface {
	isMixConfigAction_Value()
}

type MixConfigAction_VerifyKey struct {
	VerifyKey *ZkVerifyKey `protobuf:"bytes,3,opt,name=verifyKey,proto3,oneof"`
}

type MixConfigAction_AuthPk struct {
	AuthPk string `protobuf:"bytes,4,opt,name=authPk,proto3,oneof"`
}

type MixConfigAction_PaymentPk struct {
	PaymentPk *PubKey `protobuf:"bytes,5,opt,name=paymentPk,proto3,oneof"`
}

func (*MixConfigAction_VerifyKey) isMixConfigAction_Value() {}

func (*MixConfigAction_AuthPk) isMixConfigAction_Value() {}

func (*MixConfigAction_PaymentPk) isMixConfigAction_Value() {}

func (m *MixConfigAction) GetValue() isMixConfigAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *MixConfigAction) GetVerifyKey() *ZkVerifyKey {
	if x, ok := m.GetValue().(*MixConfigAction_VerifyKey); ok {
		return x.VerifyKey
	}
	return nil
}

func (m *MixConfigAction) GetAuthPk() string {
	if x, ok := m.GetValue().(*MixConfigAction_AuthPk); ok {
		return x.AuthPk
	}
	return ""
}

func (m *MixConfigAction) GetPaymentPk() *PubKey {
	if x, ok := m.GetValue().(*MixConfigAction_PaymentPk); ok {
		return x.PaymentPk
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MixConfigAction) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MixConfigAction_VerifyKey)(nil),
		(*MixConfigAction_AuthPk)(nil),
		(*MixConfigAction_PaymentPk)(nil),
	}
}

//DH one time pubkey with secret
type DHSecret struct {
	Epk                  *PubKey  `protobuf:"bytes,1,opt,name=epk,proto3" json:"epk,omitempty"`
	Secret               string   `protobuf:"bytes,3,opt,name=secret,proto3" json:"secret,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DHSecret proto.InternalMessageInfo

func (m *DHSecret) GetEpk() *PubKey {
	if m != nil {
		return m.Epk
	}
	return nil
}

func (m *DHSecret) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

//Diff-Helman 加密group, for spender, returner, authorizer to decrypt
type DHSecretGroup struct {
	Spender              *DHSecret `protobuf:"bytes,1,opt,name=spender,proto3" json:"spender,omitempty"`
	Returner             *DHSecret `protobuf:"bytes,2,opt,name=returner,proto3" json:"returner,omitempty"`
	Authorize            *DHSecret `protobuf:"bytes,3,opt,name=authorize,proto3" json:"authorize,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_DHSecretGroup proto.InternalMessageInfo

func (m *DHSecretGroup) GetSpender() *DHSecret {
	if m != nil {
		return m.Spender
	}
	return nil
}

func (m *DHSecretGroup) GetReturner() *DHSecret {
	if m != nil {
		return m.Returner
	}
	return nil
}

func (m *DHSecretGroup) GetAuthorize() *DHSecret {
	if m != nil {
		return m.Authorize
	}
	return nil
}

type ZkProofInfo struct {
	Proof                string         `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	PublicInput          string         `protobuf:"bytes,2,opt,name=publicInput,proto3" json:"publicInput,omitempty"`
	Group                *DHSecretGroup `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_ZkProofInfo proto.InternalMessageInfo

func (m *ZkProofInfo) GetProof() string {
	if m != nil {
		return m.Proof
	}
	return ""
}

func (m *ZkProofInfo) GetPublicInput() string {
	if m != nil {
		return m.PublicInput
	}
	return ""
}

func (m *ZkProofInfo) GetGroup() *DHSecretGroup {
	if m != nil {
		return m.Group
	}
	return nil
}

type MixDepositAction struct {
	Amount               uint64         `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	NewCommits           []*ZkProofInfo `protobuf:"bytes,2,rep,name=newCommits,proto3" json:"newCommits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_MixDepositAction proto.InternalMessageInfo

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

func (m *MixDepositAction) GetNewCommits() []*ZkProofInfo {
	if m != nil {
		return m.NewCommits
	}
	return nil
}

type MixTransferAction struct {
	Input                []*ZkProofInfo `protobuf:"bytes,1,rep,name=input,proto3" json:"input,omitempty"`
	Output               []*ZkProofInfo `protobuf:"bytes,2,rep,name=output,proto3" json:"output,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_MixTransferAction proto.InternalMessageInfo

func (m *MixTransferAction) GetInput() []*ZkProofInfo {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *MixTransferAction) GetOutput() []*ZkProofInfo {
	if m != nil {
		return m.Output
	}
	return nil
}

type MixWithdrawAction struct {
	Amount               uint64         `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	SpendCommits         []*ZkProofInfo `protobuf:"bytes,2,rep,name=spendCommits,proto3" json:"spendCommits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_MixWithdrawAction proto.InternalMessageInfo

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

func (m *MixWithdrawAction) GetSpendCommits() []*ZkProofInfo {
	if m != nil {
		return m.SpendCommits
	}
	return nil
}

type MixAuthorizeAction struct {
	AuthCommits          []*ZkProofInfo `protobuf:"bytes,1,rep,name=authCommits,proto3" json:"authCommits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_MixAuthorizeAction proto.InternalMessageInfo

func (m *MixAuthorizeAction) GetAuthCommits() []*ZkProofInfo {
	if m != nil {
		return m.AuthCommits
	}
	return nil
}

type MixAction struct {
	Ty int32 `protobuf:"varint,1,opt,name=ty,proto3" json:"ty,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*MixAction_Config
	//	*MixAction_Deposit
	//	*MixAction_Withdraw
	//	*MixAction_Transfer
	//	*MixAction_Authorize
	Value                isMixAction_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_MixAction proto.InternalMessageInfo

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

type isMixAction_Value interface {
	isMixAction_Value()
}

type MixAction_Config struct {
	Config *MixConfigAction `protobuf:"bytes,2,opt,name=config,proto3,oneof"`
}

type MixAction_Deposit struct {
	Deposit *MixDepositAction `protobuf:"bytes,3,opt,name=deposit,proto3,oneof"`
}

type MixAction_Withdraw struct {
	Withdraw *MixWithdrawAction `protobuf:"bytes,4,opt,name=withdraw,proto3,oneof"`
}

type MixAction_Transfer struct {
	Transfer *MixTransferAction `protobuf:"bytes,5,opt,name=transfer,proto3,oneof"`
}

type MixAction_Authorize struct {
	Authorize *MixAuthorizeAction `protobuf:"bytes,6,opt,name=authorize,proto3,oneof"`
}

func (*MixAction_Config) isMixAction_Value() {}

func (*MixAction_Deposit) isMixAction_Value() {}

func (*MixAction_Withdraw) isMixAction_Value() {}

func (*MixAction_Transfer) isMixAction_Value() {}

func (*MixAction_Authorize) isMixAction_Value() {}

func (m *MixAction) GetValue() isMixAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *MixAction) GetConfig() *MixConfigAction {
	if x, ok := m.GetValue().(*MixAction_Config); ok {
		return x.Config
	}
	return nil
}

func (m *MixAction) GetDeposit() *MixDepositAction {
	if x, ok := m.GetValue().(*MixAction_Deposit); ok {
		return x.Deposit
	}
	return nil
}

func (m *MixAction) GetWithdraw() *MixWithdrawAction {
	if x, ok := m.GetValue().(*MixAction_Withdraw); ok {
		return x.Withdraw
	}
	return nil
}

func (m *MixAction) GetTransfer() *MixTransferAction {
	if x, ok := m.GetValue().(*MixAction_Transfer); ok {
		return x.Transfer
	}
	return nil
}

func (m *MixAction) GetAuthorize() *MixAuthorizeAction {
	if x, ok := m.GetValue().(*MixAction_Authorize); ok {
		return x.Authorize
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MixAction) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MixAction_Config)(nil),
		(*MixAction_Deposit)(nil),
		(*MixAction_Withdraw)(nil),
		(*MixAction_Transfer)(nil),
		(*MixAction_Authorize)(nil),
	}
}

type DepositPublicInput struct {
	NoteHash             string   `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	Amount               string   `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DepositPublicInput proto.InternalMessageInfo

func (m *DepositPublicInput) GetNoteHash() string {
	if m != nil {
		return m.NoteHash
	}
	return ""
}

func (m *DepositPublicInput) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

type WithdrawPublicInput struct {
	TreeRootHash         string   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	NullifierHash        string   `protobuf:"bytes,2,opt,name=nullifierHash,proto3" json:"nullifierHash,omitempty"`
	AuthorizeSpendHash   string   `protobuf:"bytes,3,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	Amount               string   `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_WithdrawPublicInput proto.InternalMessageInfo

func (m *WithdrawPublicInput) GetTreeRootHash() string {
	if m != nil {
		return m.TreeRootHash
	}
	return ""
}

func (m *WithdrawPublicInput) GetNullifierHash() string {
	if m != nil {
		return m.NullifierHash
	}
	return ""
}

func (m *WithdrawPublicInput) GetAuthorizeSpendHash() string {
	if m != nil {
		return m.AuthorizeSpendHash
	}
	return ""
}

func (m *WithdrawPublicInput) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

//加密了的input/output amount
type CommitAmount struct {
	X                    string   `protobuf:"bytes,1,opt,name=X,proto3" json:"X,omitempty"`
	Y                    string   `protobuf:"bytes,2,opt,name=Y,proto3" json:"Y,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CommitAmount proto.InternalMessageInfo

func (m *CommitAmount) GetX() string {
	if m != nil {
		return m.X
	}
	return ""
}

func (m *CommitAmount) GetY() string {
	if m != nil {
		return m.Y
	}
	return ""
}

type TransferInputPublicInput struct {
	TreeRootHash         string   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	AmountX              string   `protobuf:"bytes,2,opt,name=amountX,proto3" json:"amountX,omitempty"`
	AmountY              string   `protobuf:"bytes,3,opt,name=amountY,proto3" json:"amountY,omitempty"`
	AuthorizeSpendHash   string   `protobuf:"bytes,4,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	NullifierHash        string   `protobuf:"bytes,5,opt,name=nullifierHash,proto3" json:"nullifierHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TransferInputPublicInput proto.InternalMessageInfo

func (m *TransferInputPublicInput) GetTreeRootHash() string {
	if m != nil {
		return m.TreeRootHash
	}
	return ""
}

func (m *TransferInputPublicInput) GetAmountX() string {
	if m != nil {
		return m.AmountX
	}
	return ""
}

func (m *TransferInputPublicInput) GetAmountY() string {
	if m != nil {
		return m.AmountY
	}
	return ""
}

func (m *TransferInputPublicInput) GetAuthorizeSpendHash() string {
	if m != nil {
		return m.AuthorizeSpendHash
	}
	return ""
}

func (m *TransferInputPublicInput) GetNullifierHash() string {
	if m != nil {
		return m.NullifierHash
	}
	return ""
}

type TransferOutputPublicInput struct {
	NoteHash             string         `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	AmountX              string         `protobuf:"bytes,2,opt,name=amountX,proto3" json:"amountX,omitempty"`
	AmountY              string         `protobuf:"bytes,3,opt,name=amountY,proto3" json:"amountY,omitempty"`
	DhSecrets            *DHSecretGroup `protobuf:"bytes,4,opt,name=dhSecrets,proto3" json:"dhSecrets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_TransferOutputPublicInput proto.InternalMessageInfo

func (m *TransferOutputPublicInput) GetNoteHash() string {
	if m != nil {
		return m.NoteHash
	}
	return ""
}

func (m *TransferOutputPublicInput) GetAmountX() string {
	if m != nil {
		return m.AmountX
	}
	return ""
}

func (m *TransferOutputPublicInput) GetAmountY() string {
	if m != nil {
		return m.AmountY
	}
	return ""
}

func (m *TransferOutputPublicInput) GetDhSecrets() *DHSecretGroup {
	if m != nil {
		return m.DhSecrets
	}
	return nil
}

type AuthorizePublicInput struct {
	TreeRootHash         string   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	AuthorizePubKey      string   `protobuf:"bytes,2,opt,name=authorizePubKey,proto3" json:"authorizePubKey,omitempty"`
	AuthorizeHash        string   `protobuf:"bytes,3,opt,name=authorizeHash,proto3" json:"authorizeHash,omitempty"`
	AuthorizeSpendHash   string   `protobuf:"bytes,4,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthorizePublicInput proto.InternalMessageInfo

func (m *AuthorizePublicInput) GetTreeRootHash() string {
	if m != nil {
		return m.TreeRootHash
	}
	return ""
}

func (m *AuthorizePublicInput) GetAuthorizePubKey() string {
	if m != nil {
		return m.AuthorizePubKey
	}
	return ""
}

func (m *AuthorizePublicInput) GetAuthorizeHash() string {
	if m != nil {
		return m.AuthorizeHash
	}
	return ""
}

func (m *AuthorizePublicInput) GetAuthorizeSpendHash() string {
	if m != nil {
		return m.AuthorizeSpendHash
	}
	return ""
}

//nullifer 存在value
type ExistValue struct {
	Data                 bool     `protobuf:"varint,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ExistValue proto.InternalMessageInfo

func (m *ExistValue) GetData() bool {
	if m != nil {
		return m.Data
	}
	return false
}

type CommitTreeLeaves 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 *CommitTreeLeaves) Reset()         { *m = CommitTreeLeaves{} }
func (m *CommitTreeLeaves) String() string { return proto.CompactTextString(m) }
func (*CommitTreeLeaves) ProtoMessage()    {}
func (*CommitTreeLeaves) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{19}
}

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

var xxx_messageInfo_CommitTreeLeaves proto.InternalMessageInfo

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

type CommitTreeRoots 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 *CommitTreeRoots) Reset()         { *m = CommitTreeRoots{} }
func (m *CommitTreeRoots) String() string { return proto.CompactTextString(m) }
func (*CommitTreeRoots) ProtoMessage()    {}
func (*CommitTreeRoots) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{20}
}

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

var xxx_messageInfo_CommitTreeRoots proto.InternalMessageInfo

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

type CommitTreeProve struct {
	RootHash             string   `protobuf:"bytes,1,opt,name=rootHash,proto3" json:"rootHash,omitempty"`
	ProofSet             []string `protobuf:"bytes,2,rep,name=proofSet,proto3" json:"proofSet,omitempty"`
	ProofIndex           uint32   `protobuf:"varint,3,opt,name=proofIndex,proto3" json:"proofIndex,omitempty"`
	NumLeaves            uint32   `protobuf:"varint,4,opt,name=numLeaves,proto3" json:"numLeaves,omitempty"`
	Helpers              string   `protobuf:"bytes,5,opt,name=helpers,proto3" json:"helpers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CommitTreeProve proto.InternalMessageInfo

func (m *CommitTreeProve) GetRootHash() string {
	if m != nil {
		return m.RootHash
	}
	return ""
}

func (m *CommitTreeProve) GetProofSet() []string {
	if m != nil {
		return m.ProofSet
	}
	return nil
}

func (m *CommitTreeProve) GetProofIndex() uint32 {
	if m != nil {
		return m.ProofIndex
	}
	return 0
}

func (m *CommitTreeProve) GetNumLeaves() uint32 {
	if m != nil {
		return m.NumLeaves
	}
	return 0
}

func (m *CommitTreeProve) GetHelpers() string {
	if m != nil {
		return m.Helpers
	}
	return ""
}

type TreeInfoReq struct {
	RootHash             string   `protobuf:"bytes,1,opt,name=rootHash,proto3" json:"rootHash,omitempty"`
	LeafHash             string   `protobuf:"bytes,2,opt,name=leafHash,proto3" json:"leafHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TreeInfoReq proto.InternalMessageInfo

func (m *TreeInfoReq) GetRootHash() string {
	if m != nil {
		return m.RootHash
	}
	return ""
}

func (m *TreeInfoReq) GetLeafHash() string {
	if m != nil {
		return m.LeafHash
	}
	return ""
}

type TreeListResp struct {
	Datas                []string `protobuf:"bytes,1,rep,name=datas,proto3" json:"datas,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TreeListResp proto.InternalMessageInfo

func (m *TreeListResp) GetDatas() []string {
	if m != nil {
		return m.Datas
	}
	return nil
}

// mix wallet part
// payKey = hash(spendKey) for zk-snark note spend
// 用在note内部的payment key
type PaymentKeyPair struct {
	PayKey               string   `protobuf:"bytes,1,opt,name=payKey,proto3" json:"payKey,omitempty"`
	SpendKey             string   `protobuf:"bytes,2,opt,name=spendKey,proto3" json:"spendKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PaymentKeyPair proto.InternalMessageInfo

func (m *PaymentKeyPair) GetPayKey() string {
	if m != nil {
		return m.PayKey
	}
	return ""
}

func (m *PaymentKeyPair) GetSpendKey() string {
	if m != nil {
		return m.SpendKey
	}
	return ""
}

// pub = priv*G for diff-helman crypto
// out: take spender's tempPrikey*pubkey as password, tempPubkey show in note
// spender: take self prikey*tempPubkey as password to decode
type PubKey struct {
	X                    string   `protobuf:"bytes,1,opt,name=X,proto3" json:"X,omitempty"`
	Y                    string   `protobuf:"bytes,2,opt,name=Y,proto3" json:"Y,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PubKey proto.InternalMessageInfo

func (m *PubKey) GetX() string {
	if m != nil {
		return m.X
	}
	return ""
}

func (m *PubKey) GetY() string {
	if m != nil {
		return m.Y
	}
	return ""
}

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

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

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

var xxx_messageInfo_PrivKey proto.InternalMessageInfo

func (m *PrivKey) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

type ShareSecretKeyPair struct {
	PrivKey              *PrivKey `protobuf:"bytes,1,opt,name=privKey,proto3" json:"privKey,omitempty"`
	ReceivingPk          *PubKey  `protobuf:"bytes,2,opt,name=receivingPk,proto3" json:"receivingPk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ShareSecretKeyPair proto.InternalMessageInfo

func (m *ShareSecretKeyPair) GetPrivKey() *PrivKey {
	if m != nil {
		return m.PrivKey
	}
	return nil
}

func (m *ShareSecretKeyPair) GetReceivingPk() *PubKey {
	if m != nil {
		return m.ReceivingPk
	}
	return nil
}

//spend pair for note proof
//crypt pair for DH crypt/decrypt
type AccountPrivacyKey struct {
	PaymentKey           *PaymentKeyPair     `protobuf:"bytes,1,opt,name=paymentKey,proto3" json:"paymentKey,omitempty"`
	ShareSecretKey       *ShareSecretKeyPair `protobuf:"bytes,2,opt,name=shareSecretKey,proto3" json:"shareSecretKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_AccountPrivacyKey proto.InternalMessageInfo

func (m *AccountPrivacyKey) GetPaymentKey() *PaymentKeyPair {
	if m != nil {
		return m.PaymentKey
	}
	return nil
}

func (m *AccountPrivacyKey) GetShareSecretKey() *ShareSecretKeyPair {
	if m != nil {
		return m.ShareSecretKey
	}
	return nil
}

type WalletAddrPrivacy struct {
	Privacy              *AccountPrivacyKey `protobuf:"bytes,1,opt,name=privacy,proto3" json:"privacy,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 *WalletAddrPrivacy) Reset()         { *m = WalletAddrPrivacy{} }
func (m *WalletAddrPrivacy) String() string { return proto.CompactTextString(m) }
func (*WalletAddrPrivacy) ProtoMessage()    {}
func (*WalletAddrPrivacy) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{29}
}

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

var xxx_messageInfo_WalletAddrPrivacy proto.InternalMessageInfo

func (m *WalletAddrPrivacy) GetPrivacy() *AccountPrivacyKey {
	if m != nil {
		return m.Privacy
	}
	return nil
}

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

type SecretData struct {
	PaymentPubKey        string   `protobuf:"bytes,1,opt,name=paymentPubKey,proto3" json:"paymentPubKey,omitempty"`
	ReturnPubKey         string   `protobuf:"bytes,2,opt,name=returnPubKey,proto3" json:"returnPubKey,omitempty"`
	AuthorizePubKey      string   `protobuf:"bytes,3,opt,name=authorizePubKey,proto3" json:"authorizePubKey,omitempty"`
	Amount               string   `protobuf:"bytes,4,opt,name=amount,proto3" json:"amount,omitempty"`
	NoteRandom           string   `protobuf:"bytes,5,opt,name=noteRandom,proto3" json:"noteRandom,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SecretData proto.InternalMessageInfo

func (m *SecretData) GetPaymentPubKey() string {
	if m != nil {
		return m.PaymentPubKey
	}
	return ""
}

func (m *SecretData) GetReturnPubKey() string {
	if m != nil {
		return m.ReturnPubKey
	}
	return ""
}

func (m *SecretData) GetAuthorizePubKey() string {
	if m != nil {
		return m.AuthorizePubKey
	}
	return ""
}

func (m *SecretData) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func (m *SecretData) GetNoteRandom() string {
	if m != nil {
		return m.NoteRandom
	}
	return ""
}

type EncodedSecretData struct {
	Encoded              string      `protobuf:"bytes,1,opt,name=encoded,proto3" json:"encoded,omitempty"`
	RawData              *SecretData `protobuf:"bytes,2,opt,name=rawData,proto3" json:"rawData,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_EncodedSecretData proto.InternalMessageInfo

func (m *EncodedSecretData) GetEncoded() string {
	if m != nil {
		return m.Encoded
	}
	return ""
}

func (m *EncodedSecretData) GetRawData() *SecretData {
	if m != nil {
		return m.RawData
	}
	return nil
}

type EncryptSecretData struct {
	Secret               string   `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	ReceivingPk          *PubKey  `protobuf:"bytes,2,opt,name=receivingPk,proto3" json:"receivingPk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_EncryptSecretData proto.InternalMessageInfo

func (m *EncryptSecretData) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

func (m *EncryptSecretData) GetReceivingPk() *PubKey {
	if m != nil {
		return m.ReceivingPk
	}
	return nil
}

type DecryptSecretData struct {
	Secret               string   `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	ReceivingPriKey      *PrivKey `protobuf:"bytes,2,opt,name=receivingPriKey,proto3" json:"receivingPriKey,omitempty"`
	Epk                  *PubKey  `protobuf:"bytes,3,opt,name=epk,proto3" json:"epk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DecryptSecretData proto.InternalMessageInfo

func (m *DecryptSecretData) GetSecret() string {
	if m != nil {
		return m.Secret
	}
	return ""
}

func (m *DecryptSecretData) GetReceivingPriKey() *PrivKey {
	if m != nil {
		return m.ReceivingPriKey
	}
	return nil
}

func (m *DecryptSecretData) GetEpk() *PubKey {
	if m != nil {
		return m.Epk
	}
	return nil
}

type WalletIndexInfo struct {
	NoteHash             string      `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	Nullifier            string      `protobuf:"bytes,2,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
	AuthSpendHash        string      `protobuf:"bytes,3,opt,name=authSpendHash,proto3" json:"authSpendHash,omitempty"`
	Spender              string      `protobuf:"bytes,4,opt,name=spender,proto3" json:"spender,omitempty"`
	Account              string      `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	Status               NoteStatus  `protobuf:"varint,6,opt,name=status,proto3,enum=types.NoteStatus" json:"status,omitempty"`
	Secret               *SecretData `protobuf:"bytes,7,opt,name=secret,proto3" json:"secret,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_WalletIndexInfo proto.InternalMessageInfo

func (m *WalletIndexInfo) GetNoteHash() string {
	if m != nil {
		return m.NoteHash
	}
	return ""
}

func (m *WalletIndexInfo) GetNullifier() string {
	if m != nil {
		return m.Nullifier
	}
	return ""
}

func (m *WalletIndexInfo) GetAuthSpendHash() string {
	if m != nil {
		return m.AuthSpendHash
	}
	return ""
}

func (m *WalletIndexInfo) GetSpender() string {
	if m != nil {
		return m.Spender
	}
	return ""
}

func (m *WalletIndexInfo) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *WalletIndexInfo) GetStatus() NoteStatus {
	if m != nil {
		return m.Status
	}
	return NoteStatus_UNDEF
}

func (m *WalletIndexInfo) GetSecret() *SecretData {
	if m != nil {
		return m.Secret
	}
	return nil
}

type WalletDbMixInfo struct {
	Info                 *WalletIndexInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	TxIndex              string           `protobuf:"bytes,2,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_WalletDbMixInfo proto.InternalMessageInfo

func (m *WalletDbMixInfo) GetInfo() *WalletIndexInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *WalletDbMixInfo) GetTxIndex() string {
	if m != nil {
		return m.TxIndex
	}
	return ""
}

type WalletMixIndexReq struct {
	NoteHash             string   `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	Nullifier            string   `protobuf:"bytes,2,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
	AuthSpendHash        string   `protobuf:"bytes,3,opt,name=authSpendHash,proto3" json:"authSpendHash,omitempty"`
	Spender              string   `protobuf:"bytes,4,opt,name=spender,proto3" json:"spender,omitempty"`
	Account              string   `protobuf:"bytes,5,opt,name=account,proto3" json:"account,omitempty"`
	Status               int32    `protobuf:"varint,6,opt,name=status,proto3" json:"status,omitempty"`
	Count                int32    `protobuf:"varint,7,opt,name=count,proto3" json:"count,omitempty"`
	Direction            int32    `protobuf:"varint,8,opt,name=direction,proto3" json:"direction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_WalletMixIndexReq proto.InternalMessageInfo

func (m *WalletMixIndexReq) GetNoteHash() string {
	if m != nil {
		return m.NoteHash
	}
	return ""
}

func (m *WalletMixIndexReq) GetNullifier() string {
	if m != nil {
		return m.Nullifier
	}
	return ""
}

func (m *WalletMixIndexReq) GetAuthSpendHash() string {
	if m != nil {
		return m.AuthSpendHash
	}
	return ""
}

func (m *WalletMixIndexReq) GetSpender() string {
	if m != nil {
		return m.Spender
	}
	return ""
}

func (m *WalletMixIndexReq) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

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

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

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

type WalletIndexResp struct {
	Datas                []*WalletIndexInfo `protobuf:"bytes,1,rep,name=datas,proto3" json:"datas,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_WalletIndexResp proto.InternalMessageInfo

func (m *WalletIndexResp) GetDatas() []*WalletIndexInfo {
	if m != nil {
		return m.Datas
	}
	return nil
}

type WalletReqAddrs struct {
	Data                 []string `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_WalletReqAddrs proto.InternalMessageInfo

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

type WalletEnablePrivacyRst 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 *WalletEnablePrivacyRst) Reset()         { *m = WalletEnablePrivacyRst{} }
func (m *WalletEnablePrivacyRst) String() string { return proto.CompactTextString(m) }
func (*WalletEnablePrivacyRst) ProtoMessage()    {}
func (*WalletEnablePrivacyRst) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{39}
}

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

var xxx_messageInfo_WalletEnablePrivacyRst proto.InternalMessageInfo

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

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

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

type WalletEnablePrivacyResp struct {
	Data                 []*WalletEnablePrivacyRst `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

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

var xxx_messageInfo_WalletEnablePrivacyResp proto.InternalMessageInfo

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

type LocalMixTx struct {
	Hash                 string   `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Height               int64    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	Index                int64    `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LocalMixTx proto.InternalMessageInfo

func (m *LocalMixTx) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

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

func (m *LocalMixTx) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

type MixTxListReq struct {
	TxIndex              string   `protobuf:"bytes,1,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
	Hash                 string   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	Height               int64    `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Index                int64    `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
	Count                int32    `protobuf:"varint,5,opt,name=count,proto3" json:"count,omitempty"`
	Direction            int32    `protobuf:"varint,6,opt,name=direction,proto3" json:"direction,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_MixTxListReq proto.InternalMessageInfo

func (m *MixTxListReq) GetTxIndex() string {
	if m != nil {
		return m.TxIndex
	}
	return ""
}

func (m *MixTxListReq) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

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

func (m *MixTxListReq) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

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

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

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

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

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

var xxx_messageInfo_MixTxListResp proto.InternalMessageInfo

func (m *MixTxListResp) GetTxs() []*LocalMixTx {
	if m != nil {
		return m.Txs
	}
	return nil
}

type PrivacyAddrResult 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 *PrivacyAddrResult) Reset()         { *m = PrivacyAddrResult{} }
func (m *PrivacyAddrResult) String() string { return proto.CompactTextString(m) }
func (*PrivacyAddrResult) ProtoMessage()    {}
func (*PrivacyAddrResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{44}
}

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

var xxx_messageInfo_PrivacyAddrResult proto.InternalMessageInfo

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

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

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

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

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

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

var xxx_messageInfo_ReqEnablePrivacyRst proto.InternalMessageInfo

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

func init() {
	proto.RegisterEnum("types.VerifyType", VerifyType_name, VerifyType_value)
	proto.RegisterEnum("types.ZkCurveId", ZkCurveId_name, ZkCurveId_value)
	proto.RegisterEnum("types.MixConfigType", MixConfigType_name, MixConfigType_value)
	proto.RegisterEnum("types.MixConfigAct", MixConfigAct_name, MixConfigAct_value)
	proto.RegisterEnum("types.NoteStatus", NoteStatus_name, NoteStatus_value)
	proto.RegisterEnum("types.MixWalletRescanStatus", MixWalletRescanStatus_name, MixWalletRescanStatus_value)
	proto.RegisterType((*ZkVerifyKey)(nil), "types.ZkVerifyKey")
	proto.RegisterType((*ZkVerifyKeys)(nil), "types.ZkVerifyKeys")
	proto.RegisterType((*AuthPubKeys)(nil), "types.AuthPubKeys")
	proto.RegisterType((*MixConfigAction)(nil), "types.MixConfigAction")
	proto.RegisterType((*DHSecret)(nil), "types.DHSecret")
	proto.RegisterType((*DHSecretGroup)(nil), "types.DHSecretGroup")
	proto.RegisterType((*ZkProofInfo)(nil), "types.ZkProofInfo")
	proto.RegisterType((*MixDepositAction)(nil), "types.MixDepositAction")
	proto.RegisterType((*MixTransferAction)(nil), "types.MixTransferAction")
	proto.RegisterType((*MixWithdrawAction)(nil), "types.MixWithdrawAction")
	proto.RegisterType((*MixAuthorizeAction)(nil), "types.MixAuthorizeAction")
	proto.RegisterType((*MixAction)(nil), "types.MixAction")
	proto.RegisterType((*DepositPublicInput)(nil), "types.DepositPublicInput")
	proto.RegisterType((*WithdrawPublicInput)(nil), "types.WithdrawPublicInput")
	proto.RegisterType((*CommitAmount)(nil), "types.commitAmount")
	proto.RegisterType((*TransferInputPublicInput)(nil), "types.TransferInputPublicInput")
	proto.RegisterType((*TransferOutputPublicInput)(nil), "types.TransferOutputPublicInput")
	proto.RegisterType((*AuthorizePublicInput)(nil), "types.AuthorizePublicInput")
	proto.RegisterType((*ExistValue)(nil), "types.ExistValue")
	proto.RegisterType((*CommitTreeLeaves)(nil), "types.CommitTreeLeaves")
	proto.RegisterType((*CommitTreeRoots)(nil), "types.CommitTreeRoots")
	proto.RegisterType((*CommitTreeProve)(nil), "types.CommitTreeProve")
	proto.RegisterType((*TreeInfoReq)(nil), "types.TreeInfoReq")
	proto.RegisterType((*TreeListResp)(nil), "types.TreeListResp")
	proto.RegisterType((*PaymentKeyPair)(nil), "types.PaymentKeyPair")
	proto.RegisterType((*PubKey)(nil), "types.PubKey")
	proto.RegisterType((*PrivKey)(nil), "types.PrivKey")
	proto.RegisterType((*ShareSecretKeyPair)(nil), "types.ShareSecretKeyPair")
	proto.RegisterType((*AccountPrivacyKey)(nil), "types.AccountPrivacyKey")
	proto.RegisterType((*WalletAddrPrivacy)(nil), "types.WalletAddrPrivacy")
	proto.RegisterType((*SecretData)(nil), "types.SecretData")
	proto.RegisterType((*EncodedSecretData)(nil), "types.EncodedSecretData")
	proto.RegisterType((*EncryptSecretData)(nil), "types.EncryptSecretData")
	proto.RegisterType((*DecryptSecretData)(nil), "types.DecryptSecretData")
	proto.RegisterType((*WalletIndexInfo)(nil), "types.WalletIndexInfo")
	proto.RegisterType((*WalletDbMixInfo)(nil), "types.WalletDbMixInfo")
	proto.RegisterType((*WalletMixIndexReq)(nil), "types.WalletMixIndexReq")
	proto.RegisterType((*WalletIndexResp)(nil), "types.WalletIndexResp")
	proto.RegisterType((*WalletReqAddrs)(nil), "types.WalletReqAddrs")
	proto.RegisterType((*WalletEnablePrivacyRst)(nil), "types.WalletEnablePrivacyRst")
	proto.RegisterType((*WalletEnablePrivacyResp)(nil), "types.WalletEnablePrivacyResp")
	proto.RegisterType((*LocalMixTx)(nil), "types.LocalMixTx")
	proto.RegisterType((*MixTxListReq)(nil), "types.MixTxListReq")
	proto.RegisterType((*MixTxListResp)(nil), "types.MixTxListResp")
	proto.RegisterType((*PrivacyAddrResult)(nil), "types.PrivacyAddrResult")
	proto.RegisterType((*ReqEnablePrivacyRst)(nil), "types.ReqEnablePrivacyRst")
}

func init() {
	proto.RegisterFile("mix.proto", fileDescriptor_5c21d519a9be369a)
}

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

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

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

// MixPrivacyClient is the client API for MixPrivacy service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MixPrivacyClient interface {
	// 扫描UTXO以及获取扫描UTXO后的状态
	GetRescanStatus(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.ReqString, error)
	// 使能隐私账户
	RescanNotes(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.ReqString, error)
	// 创建隐私交易
	EnablePrivacy(ctx context.Context, in *types.ReqAddrs, opts ...grpc.CallOption) (*ReqEnablePrivacyRst, error)
}

type mixPrivacyClient struct {
	cc grpc.ClientConnInterface
}

func NewMixPrivacyClient(cc grpc.ClientConnInterface) MixPrivacyClient {
	return &mixPrivacyClient{cc}
}

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

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

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

// MixPrivacyServer is the server API for MixPrivacy service.
type MixPrivacyServer interface {
	// 扫描UTXO以及获取扫描UTXO后的状态
	GetRescanStatus(context.Context, *types.ReqNil) (*types.ReqString, error)
	// 使能隐私账户
	RescanNotes(context.Context, *types.ReqNil) (*types.ReqString, error)
	// 创建隐私交易
	EnablePrivacy(context.Context, *types.ReqAddrs) (*ReqEnablePrivacyRst, error)
}

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

func (*UnimplementedMixPrivacyServer) GetRescanStatus(ctx context.Context, req *types.ReqNil) (*types.ReqString, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRescanStatus not implemented")
}
func (*UnimplementedMixPrivacyServer) RescanNotes(ctx context.Context, req *types.ReqNil) (*types.ReqString, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RescanNotes not implemented")
}
func (*UnimplementedMixPrivacyServer) EnablePrivacy(ctx context.Context, req *types.ReqAddrs) (*ReqEnablePrivacyRst, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnablePrivacy not implemented")
}

func RegisterMixPrivacyServer(s *grpc.Server, srv MixPrivacyServer) {
	s.RegisterService(&_MixPrivacy_serviceDesc, srv)
}

func _MixPrivacy_GetRescanStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.ReqNil)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MixPrivacyServer).GetRescanStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.mixPrivacy/GetRescanStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MixPrivacyServer).GetRescanStatus(ctx, req.(*types.ReqNil))
	}
	return interceptor(ctx, in, info, handler)
}

func _MixPrivacy_RescanNotes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.ReqNil)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MixPrivacyServer).RescanNotes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.mixPrivacy/RescanNotes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MixPrivacyServer).RescanNotes(ctx, req.(*types.ReqNil))
	}
	return interceptor(ctx, in, info, handler)
}

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

var _MixPrivacy_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.mixPrivacy",
	HandlerType: (*MixPrivacyServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRescanStatus",
			Handler:    _MixPrivacy_GetRescanStatus_Handler,
		},
		{
			MethodName: "RescanNotes",
			Handler:    _MixPrivacy_RescanNotes_Handler,
		},
		{
			MethodName: "EnablePrivacy",
			Handler:    _MixPrivacy_EnablePrivacy_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "mix.proto",
}
