// 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}
}

type MixConfigType int32

const (
	MixConfigType_Verify MixConfigType = 0
	//register unify authorize pubkey
	MixConfigType_Auth MixConfigType = 1
	//for spender's pay pubkey register,DH secret
	//spender注册自己的payment公钥, 用来生成DiffHellman秘钥
	MixConfigType_Payment MixConfigType = 2
)

var MixConfigType_name = map[int32]string{
	0: "Verify",
	1: "Auth",
	2: "Payment",
}

var MixConfigType_value = map[string]int32{
	"Verify":  0,
	"Auth":    1,
	"Payment": 2,
}

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

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

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{2}
}

type NoteStatus int32

const (
	NoteStatus_UNDEF    NoteStatus = 0
	NoteStatus_VALID    NoteStatus = 1
	NoteStatus_USED     NoteStatus = 2
	NoteStatus_FROZEN   NoteStatus = 3
	NoteStatus_UNFROZEN NoteStatus = 4
)

var NoteStatus_name = map[int32]string{
	0: "UNDEF",
	1: "VALID",
	2: "USED",
	3: "FROZEN",
	4: "UNFROZEN",
}

var NoteStatus_value = map[string]int32{
	"UNDEF":    0,
	"VALID":    1,
	"USED":     2,
	"FROZEN":   3,
	"UNFROZEN": 4,
}

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

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

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{4}
}

type ZkVerifyKey struct {
	Type                 VerifyType `protobuf:"varint,1,opt,name=type,proto3,enum=types.VerifyType" json:"type,omitempty"`
	Value                string     `protobuf:"bytes,2,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) 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 AuthKeys struct {
	Keys                 []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthKeys proto.InternalMessageInfo

func (m *AuthKeys) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

type PaymentKey struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	ReceiverKey          string   `protobuf:"bytes,2,opt,name=receiverKey,proto3" json:"receiverKey,omitempty"`
	EncryptKey           string   `protobuf:"bytes,3,opt,name=encryptKey,proto3" json:"encryptKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PaymentKey proto.InternalMessageInfo

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

func (m *PaymentKey) GetReceiverKey() string {
	if m != nil {
		return m.ReceiverKey
	}
	return ""
}

func (m *PaymentKey) GetEncryptKey() string {
	if m != nil {
		return m.EncryptKey
	}
	return ""
}

//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_AuthKey
	//	*MixConfigAction_PaymentKey
	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{4}
}

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_Verify
}

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_AuthKey struct {
	AuthKey string `protobuf:"bytes,4,opt,name=authKey,proto3,oneof"`
}

type MixConfigAction_PaymentKey struct {
	PaymentKey *PaymentKey `protobuf:"bytes,5,opt,name=paymentKey,proto3,oneof"`
}

func (*MixConfigAction_VerifyKey) isMixConfigAction_Value() {}

func (*MixConfigAction_AuthKey) isMixConfigAction_Value() {}

func (*MixConfigAction_PaymentKey) 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) GetAuthKey() string {
	if x, ok := m.GetValue().(*MixConfigAction_AuthKey); ok {
		return x.AuthKey
	}
	return ""
}

func (m *MixConfigAction) GetPaymentKey() *PaymentKey {
	if x, ok := m.GetValue().(*MixConfigAction_PaymentKey); ok {
		return x.PaymentKey
	}
	return nil
}

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

//DH one time pubkey with secret
type DHSecret struct {
	PeerKey              string   `protobuf:"bytes,1,opt,name=peerKey,proto3" json:"peerKey,omitempty"`
	Secret               string   `protobuf:"bytes,2,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{5}
}

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) GetPeerKey() string {
	if m != nil {
		return m.PeerKey
	}
	return ""
}

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

//Diff-Helman 加密group, for spender, returner, authorizer to decrypt
type DHSecretGroup struct {
	Receiver             string   `protobuf:"bytes,1,opt,name=receiver,proto3" json:"receiver,omitempty"`
	Returner             string   `protobuf:"bytes,2,opt,name=returner,proto3" json:"returner,omitempty"`
	Authorize            string   `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{6}
}

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) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

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

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

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"`
	Secrets              *DHSecretGroup `protobuf:"bytes,3,opt,name=secrets,proto3" json:"secrets,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{7}
}

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) GetSecrets() *DHSecretGroup {
	if m != nil {
		return m.Secrets
	}
	return nil
}

type MixDepositAction struct {
	Proofs               []*ZkProofInfo `protobuf:"bytes,1,rep,name=proofs,proto3" json:"proofs,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{8}
}

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) GetProofs() []*ZkProofInfo {
	if m != nil {
		return m.Proofs
	}
	return nil
}

type MixTransferAction struct {
	Inputs               []*ZkProofInfo `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
	Output               *ZkProofInfo   `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
	Change               *ZkProofInfo   `protobuf:"bytes,3,opt,name=change,proto3" json:"change,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{9}
}

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) GetInputs() []*ZkProofInfo {
	if m != nil {
		return m.Inputs
	}
	return nil
}

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

func (m *MixTransferAction) GetChange() *ZkProofInfo {
	if m != nil {
		return m.Change
	}
	return nil
}

type MixWithdrawAction struct {
	Amount               uint64         `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"`
	Proofs               []*ZkProofInfo `protobuf:"bytes,2,rep,name=proofs,proto3" json:"proofs,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{10}
}

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) GetProofs() []*ZkProofInfo {
	if m != nil {
		return m.Proofs
	}
	return nil
}

type MixAuthorizeAction struct {
	Proof                *ZkProofInfo `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,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{11}
}

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) GetProof() *ZkProofInfo {
	if m != nil {
		return m.Proof
	}
	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{12}
}

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{13}
}

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{14}
}

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 ""
}

type TransferInputPublicInput struct {
	TreeRootHash         string   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	ShieldAmountX        string   `protobuf:"bytes,2,opt,name=shieldAmountX,proto3" json:"shieldAmountX,omitempty"`
	ShieldAmountY        string   `protobuf:"bytes,3,opt,name=shieldAmountY,proto3" json:"shieldAmountY,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) GetShieldAmountX() string {
	if m != nil {
		return m.ShieldAmountX
	}
	return ""
}

func (m *TransferInputPublicInput) GetShieldAmountY() string {
	if m != nil {
		return m.ShieldAmountY
	}
	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"`
	ShieldAmountX        string   `protobuf:"bytes,2,opt,name=shieldAmountX,proto3" json:"shieldAmountX,omitempty"`
	ShieldAmountY        string   `protobuf:"bytes,3,opt,name=shieldAmountY,proto3" json:"shieldAmountY,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) GetShieldAmountX() string {
	if m != nil {
		return m.ShieldAmountX
	}
	return ""
}

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

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 ""
}

type VerifyProofInfo struct {
	Ty                   VerifyType   `protobuf:"varint,1,opt,name=ty,proto3,enum=types.VerifyType" json:"ty,omitempty"`
	Proof                *ZkProofInfo `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_VerifyProofInfo proto.InternalMessageInfo

func (m *VerifyProofInfo) GetTy() VerifyType {
	if m != nil {
		return m.Ty
	}
	return VerifyType_DEPOSIT
}

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

//nullifer 存在value
type ExistValue struct {
	Nullifier            string   `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
	Exist                bool     `protobuf:"varint,2,opt,name=exist,proto3" json:"exist,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{19}
}

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) GetNullifier() string {
	if m != nil {
		return m.Nullifier
	}
	return ""
}

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

type CommitTreeLeaves struct {
	Leaves               [][]byte `protobuf:"bytes,1,rep,name=leaves,proto3" json:"leaves,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{20}
}

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) GetLeaves() [][]byte {
	if m != nil {
		return m.Leaves
	}
	return nil
}

type CommitTreeRoots struct {
	Roots                [][]byte `protobuf:"bytes,1,rep,name=roots,proto3" json:"roots,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{21}
}

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) GetRoots() [][]byte {
	if m != nil {
		return m.Roots
	}
	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              []uint32 `protobuf:"varint,5,rep,packed,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{22}
}

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() []uint32 {
	if m != nil {
		return m.Helpers
	}
	return nil
}

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{23}
}

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 {
	Leaves               []string `protobuf:"bytes,1,rep,name=leaves,proto3" json:"leaves,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{24}
}

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) GetLeaves() []string {
	if m != nil {
		return m.Leaves
	}
	return nil
}

// mix wallet part
// receiverPubKey = hash(spendPriKey) for zk-snark note spend
type PaymentKeyPair struct {
	ReceiveKey           string   `protobuf:"bytes,1,opt,name=receiveKey,proto3" json:"receiveKey,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{25}
}

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) GetReceiveKey() string {
	if m != nil {
		return m.ReceiveKey
	}
	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 EncryptKeyPair struct {
	PrivKey              string   `protobuf:"bytes,1,opt,name=privKey,proto3" json:"privKey,omitempty"`
	PubKey               string   `protobuf:"bytes,2,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_EncryptKeyPair proto.InternalMessageInfo

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

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

//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"`
	EncryptKey           *EncryptKeyPair `protobuf:"bytes,2,opt,name=encryptKey,proto3" json:"encryptKey,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{27}
}

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) GetEncryptKey() *EncryptKeyPair {
	if m != nil {
		return m.EncryptKey
	}
	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{28}
}

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 {
	ReceiverKey          string   `protobuf:"bytes,1,opt,name=receiverKey,proto3" json:"receiverKey,omitempty"`
	ReturnKey            string   `protobuf:"bytes,2,opt,name=returnKey,proto3" json:"returnKey,omitempty"`
	AuthorizeKey         string   `protobuf:"bytes,3,opt,name=authorizeKey,proto3" json:"authorizeKey,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{29}
}

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) GetReceiverKey() string {
	if m != nil {
		return m.ReceiverKey
	}
	return ""
}

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

func (m *SecretData) GetAuthorizeKey() string {
	if m != nil {
		return m.AuthorizeKey
	}
	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 EncryptSecretData struct {
	Secret               string   `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	PeerKey              string   `protobuf:"bytes,2,opt,name=peerKey,proto3" json:"peerKey,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{30}
}

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) GetPeerKey() string {
	if m != nil {
		return m.PeerKey
	}
	return ""
}

type DecryptSecretData struct {
	Secret               string   `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,omitempty"`
	PriKey               string   `protobuf:"bytes,2,opt,name=priKey,proto3" json:"priKey,omitempty"`
	PeerKey              string   `protobuf:"bytes,3,opt,name=peerKey,proto3" json:"peerKey,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{31}
}

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) GetPriKey() string {
	if m != nil {
		return m.PriKey
	}
	return ""
}

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

//支持同时存入多个地址，多个地址具有相同的returnAddr和AuthorizeAddr,如果不同，则单个来存
type DepositInfo struct {
	ReceiverAddrs        string   `protobuf:"bytes,1,opt,name=receiverAddrs,proto3" json:"receiverAddrs,omitempty"`
	ReturnAddr           string   `protobuf:"bytes,2,opt,name=returnAddr,proto3" json:"returnAddr,omitempty"`
	AuthorizeAddr        string   `protobuf:"bytes,3,opt,name=authorizeAddr,proto3" json:"authorizeAddr,omitempty"`
	Amounts              string   `protobuf:"bytes,4,opt,name=amounts,proto3" json:"amounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DepositInfo proto.InternalMessageInfo

func (m *DepositInfo) GetReceiverAddrs() string {
	if m != nil {
		return m.ReceiverAddrs
	}
	return ""
}

func (m *DepositInfo) GetReturnAddr() string {
	if m != nil {
		return m.ReturnAddr
	}
	return ""
}

func (m *DepositInfo) GetAuthorizeAddr() string {
	if m != nil {
		return m.AuthorizeAddr
	}
	return ""
}

func (m *DepositInfo) GetAmounts() string {
	if m != nil {
		return m.Amounts
	}
	return ""
}

//钱包生成deposit tx
type DepositTxReq struct {
	Deposit              *DepositInfo `protobuf:"bytes,1,opt,name=deposit,proto3" json:"deposit,omitempty"`
	ZkPath               string       `protobuf:"bytes,2,opt,name=zkPath,proto3" json:"zkPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_DepositTxReq proto.InternalMessageInfo

func (m *DepositTxReq) GetDeposit() *DepositInfo {
	if m != nil {
		return m.Deposit
	}
	return nil
}

func (m *DepositTxReq) GetZkPath() string {
	if m != nil {
		return m.ZkPath
	}
	return ""
}

type DepositProofResp struct {
	NoteHash             string         `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	Proof                *SecretData    `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
	Secrets              *DHSecretGroup `protobuf:"bytes,3,opt,name=secrets,proto3" json:"secrets,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_DepositProofResp proto.InternalMessageInfo

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

func (m *DepositProofResp) GetProof() *SecretData {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *DepositProofResp) GetSecrets() *DHSecretGroup {
	if m != nil {
		return m.Secrets
	}
	return nil
}

type TreePathProof struct {
	TreeRootHash         string   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	TreePath             []string `protobuf:"bytes,2,rep,name=treePath,proto3" json:"treePath,omitempty"`
	Helpers              []uint32 `protobuf:"varint,3,rep,packed,name=helpers,proto3" json:"helpers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TreePathProof proto.InternalMessageInfo

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

func (m *TreePathProof) GetTreePath() []string {
	if m != nil {
		return m.TreePath
	}
	return nil
}

func (m *TreePathProof) GetHelpers() []uint32 {
	if m != nil {
		return m.Helpers
	}
	return nil
}

//可withdraw 多个note
type WithdrawTxReq struct {
	TotalAmount          uint64   `protobuf:"varint,1,opt,name=totalAmount,proto3" json:"totalAmount,omitempty"`
	NoteHashs            string   `protobuf:"bytes,2,opt,name=noteHashs,proto3" json:"noteHashs,omitempty"`
	ZkPath               string   `protobuf:"bytes,3,opt,name=zkPath,proto3" json:"zkPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_WithdrawTxReq proto.InternalMessageInfo

func (m *WithdrawTxReq) GetTotalAmount() uint64 {
	if m != nil {
		return m.TotalAmount
	}
	return 0
}

func (m *WithdrawTxReq) GetNoteHashs() string {
	if m != nil {
		return m.NoteHashs
	}
	return ""
}

func (m *WithdrawTxReq) GetZkPath() string {
	if m != nil {
		return m.ZkPath
	}
	return ""
}

type WithdrawProofRe struct {
	Secret               *SecretData    `protobuf:"bytes,1,opt,name=secret,proto3" json:"secret,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"`
	NoteHash             string         `protobuf:"bytes,4,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	SpendPrivKey         string         `protobuf:"bytes,5,opt,name=spendPrivKey,proto3" json:"spendPrivKey,omitempty"`
	SpendFlag            string         `protobuf:"bytes,6,opt,name=spendFlag,proto3" json:"spendFlag,omitempty"`
	AuthorizeFlag        string         `protobuf:"bytes,7,opt,name=authorizeFlag,proto3" json:"authorizeFlag,omitempty"`
	TreeProof            *TreePathProof `protobuf:"bytes,8,opt,name=treeProof,proto3" json:"treeProof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_WithdrawProofRe proto.InternalMessageInfo

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

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

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

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

func (m *WithdrawProofRe) GetSpendPrivKey() string {
	if m != nil {
		return m.SpendPrivKey
	}
	return ""
}

func (m *WithdrawProofRe) GetSpendFlag() string {
	if m != nil {
		return m.SpendFlag
	}
	return ""
}

func (m *WithdrawProofRe) GetAuthorizeFlag() string {
	if m != nil {
		return m.AuthorizeFlag
	}
	return ""
}

func (m *WithdrawProofRe) GetTreeProof() *TreePathProof {
	if m != nil {
		return m.TreeProof
	}
	return nil
}

//只授权一个note，超过一个，toAddr不好设置
type AuthTxReq struct {
	NoteHash             string   `protobuf:"bytes,1,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	AuthorizeToAddr      string   `protobuf:"bytes,3,opt,name=authorizeToAddr,proto3" json:"authorizeToAddr,omitempty"`
	ZkPath               string   `protobuf:"bytes,4,opt,name=zkPath,proto3" json:"zkPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthTxReq proto.InternalMessageInfo

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

func (m *AuthTxReq) GetAuthorizeToAddr() string {
	if m != nil {
		return m.AuthorizeToAddr
	}
	return ""
}

func (m *AuthTxReq) GetZkPath() string {
	if m != nil {
		return m.ZkPath
	}
	return ""
}

type AuthProofRe struct {
	Proof                *SecretData    `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	AuthPubKey           string         `protobuf:"bytes,2,opt,name=authPubKey,proto3" json:"authPubKey,omitempty"`
	AuthPrivKey          string         `protobuf:"bytes,3,opt,name=authPrivKey,proto3" json:"authPrivKey,omitempty"`
	AuthHash             string         `protobuf:"bytes,4,opt,name=authHash,proto3" json:"authHash,omitempty"`
	AuthorizeSpendHash   string         `protobuf:"bytes,5,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	NoteHash             string         `protobuf:"bytes,6,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	SpendFlag            string         `protobuf:"bytes,7,opt,name=spendFlag,proto3" json:"spendFlag,omitempty"`
	TreeProof            *TreePathProof `protobuf:"bytes,8,opt,name=treeProof,proto3" json:"treeProof,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_AuthProofRe proto.InternalMessageInfo

func (m *AuthProofRe) GetProof() *SecretData {
	if m != nil {
		return m.Proof
	}
	return nil
}

func (m *AuthProofRe) GetAuthPubKey() string {
	if m != nil {
		return m.AuthPubKey
	}
	return ""
}

func (m *AuthProofRe) GetAuthPrivKey() string {
	if m != nil {
		return m.AuthPrivKey
	}
	return ""
}

func (m *AuthProofRe) GetAuthHash() string {
	if m != nil {
		return m.AuthHash
	}
	return ""
}

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

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

func (m *AuthProofRe) GetSpendFlag() string {
	if m != nil {
		return m.SpendFlag
	}
	return ""
}

func (m *AuthProofRe) GetTreeProof() *TreePathProof {
	if m != nil {
		return m.TreeProof
	}
	return nil
}

type TransferInputTxReq struct {
	NoteHashs            string   `protobuf:"bytes,1,opt,name=noteHashs,proto3" json:"noteHashs,omitempty"`
	ZkPath               string   `protobuf:"bytes,2,opt,name=zkPath,proto3" json:"zkPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TransferInputTxReq proto.InternalMessageInfo

func (m *TransferInputTxReq) GetNoteHashs() string {
	if m != nil {
		return m.NoteHashs
	}
	return ""
}

func (m *TransferInputTxReq) GetZkPath() string {
	if m != nil {
		return m.ZkPath
	}
	return ""
}

type TransferOutputTxReq struct {
	Deposit              *DepositInfo `protobuf:"bytes,1,opt,name=deposit,proto3" json:"deposit,omitempty"`
	ZkPath               string       `protobuf:"bytes,2,opt,name=zkPath,proto3" json:"zkPath,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_TransferOutputTxReq proto.InternalMessageInfo

func (m *TransferOutputTxReq) GetDeposit() *DepositInfo {
	if m != nil {
		return m.Deposit
	}
	return nil
}

func (m *TransferOutputTxReq) GetZkPath() string {
	if m != nil {
		return m.ZkPath
	}
	return ""
}

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

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

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

var xxx_messageInfo_TransferTxReq proto.InternalMessageInfo

func (m *TransferTxReq) GetInput() *TransferInputTxReq {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *TransferTxReq) GetOutput() *TransferOutputTxReq {
	if m != nil {
		return m.Output
	}
	return nil
}

//加密了的input/output amount
type ShieldAmount 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 *ShieldAmount) Reset()         { *m = ShieldAmount{} }
func (m *ShieldAmount) String() string { return proto.CompactTextString(m) }
func (*ShieldAmount) ProtoMessage()    {}
func (*ShieldAmount) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{43}
}

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

var xxx_messageInfo_ShieldAmount proto.InternalMessageInfo

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

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

type TransferInputProof struct {
	Proof                *SecretData    `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,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"`
	NoteHash             string         `protobuf:"bytes,4,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	SpendPrivKey         string         `protobuf:"bytes,5,opt,name=spendPrivKey,proto3" json:"spendPrivKey,omitempty"`
	SpendFlag            string         `protobuf:"bytes,6,opt,name=spendFlag,proto3" json:"spendFlag,omitempty"`
	AuthorizeFlag        string         `protobuf:"bytes,7,opt,name=authorizeFlag,proto3" json:"authorizeFlag,omitempty"`
	TreeProof            *TreePathProof `protobuf:"bytes,8,opt,name=treeProof,proto3" json:"treeProof,omitempty"`
	ShieldAmount         *ShieldAmount  `protobuf:"bytes,9,opt,name=shieldAmount,proto3" json:"shieldAmount,omitempty"`
	AmountRandom         string         `protobuf:"bytes,10,opt,name=amountRandom,proto3" json:"amountRandom,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_TransferInputProof proto.InternalMessageInfo

func (m *TransferInputProof) GetProof() *SecretData {
	if m != nil {
		return m.Proof
	}
	return nil
}

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

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

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

func (m *TransferInputProof) GetSpendPrivKey() string {
	if m != nil {
		return m.SpendPrivKey
	}
	return ""
}

func (m *TransferInputProof) GetSpendFlag() string {
	if m != nil {
		return m.SpendFlag
	}
	return ""
}

func (m *TransferInputProof) GetAuthorizeFlag() string {
	if m != nil {
		return m.AuthorizeFlag
	}
	return ""
}

func (m *TransferInputProof) GetTreeProof() *TreePathProof {
	if m != nil {
		return m.TreeProof
	}
	return nil
}

func (m *TransferInputProof) GetShieldAmount() *ShieldAmount {
	if m != nil {
		return m.ShieldAmount
	}
	return nil
}

func (m *TransferInputProof) GetAmountRandom() string {
	if m != nil {
		return m.AmountRandom
	}
	return ""
}

type TransferOutputProof struct {
	Proof                *SecretData    `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"`
	NoteHash             string         `protobuf:"bytes,2,opt,name=noteHash,proto3" json:"noteHash,omitempty"`
	Secrets              *DHSecretGroup `protobuf:"bytes,3,opt,name=secrets,proto3" json:"secrets,omitempty"`
	ShieldAmount         *ShieldAmount  `protobuf:"bytes,4,opt,name=shieldAmount,proto3" json:"shieldAmount,omitempty"`
	AmountRandom         string         `protobuf:"bytes,5,opt,name=amountRandom,proto3" json:"amountRandom,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_TransferOutputProof proto.InternalMessageInfo

func (m *TransferOutputProof) GetProof() *SecretData {
	if m != nil {
		return m.Proof
	}
	return nil
}

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

func (m *TransferOutputProof) GetSecrets() *DHSecretGroup {
	if m != nil {
		return m.Secrets
	}
	return nil
}

func (m *TransferOutputProof) GetShieldAmount() *ShieldAmount {
	if m != nil {
		return m.ShieldAmount
	}
	return nil
}

func (m *TransferOutputProof) GetAmountRandom() string {
	if m != nil {
		return m.AmountRandom
	}
	return ""
}

type TransferProofResp struct {
	TransferInput        *TransferInputProof  `protobuf:"bytes,1,opt,name=transferInput,proto3" json:"transferInput,omitempty"`
	TargetOutput         *TransferOutputProof `protobuf:"bytes,2,opt,name=targetOutput,proto3" json:"targetOutput,omitempty"`
	ChangeOutput         *TransferOutputProof `protobuf:"bytes,3,opt,name=changeOutput,proto3" json:"changeOutput,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_TransferProofResp proto.InternalMessageInfo

func (m *TransferProofResp) GetTransferInput() *TransferInputProof {
	if m != nil {
		return m.TransferInput
	}
	return nil
}

func (m *TransferProofResp) GetTargetOutput() *TransferOutputProof {
	if m != nil {
		return m.TargetOutput
	}
	return nil
}

func (m *TransferProofResp) GetChangeOutput() *TransferOutputProof {
	if m != nil {
		return m.ChangeOutput
	}
	return nil
}

type ShieldAmountRst struct {
	InputRandoms         []string        `protobuf:"bytes,1,rep,name=inputRandoms,proto3" json:"inputRandoms,omitempty"`
	OutputRandom         string          `protobuf:"bytes,2,opt,name=outputRandom,proto3" json:"outputRandom,omitempty"`
	ChangeRandom         string          `protobuf:"bytes,3,opt,name=changeRandom,proto3" json:"changeRandom,omitempty"`
	Inputs               []*ShieldAmount `protobuf:"bytes,4,rep,name=inputs,proto3" json:"inputs,omitempty"`
	Output               *ShieldAmount   `protobuf:"bytes,5,opt,name=output,proto3" json:"output,omitempty"`
	Change               *ShieldAmount   `protobuf:"bytes,6,opt,name=change,proto3" json:"change,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_ShieldAmountRst proto.InternalMessageInfo

func (m *ShieldAmountRst) GetInputRandoms() []string {
	if m != nil {
		return m.InputRandoms
	}
	return nil
}

func (m *ShieldAmountRst) GetOutputRandom() string {
	if m != nil {
		return m.OutputRandom
	}
	return ""
}

func (m *ShieldAmountRst) GetChangeRandom() string {
	if m != nil {
		return m.ChangeRandom
	}
	return ""
}

func (m *ShieldAmountRst) GetInputs() []*ShieldAmount {
	if m != nil {
		return m.Inputs
	}
	return nil
}

func (m *ShieldAmountRst) GetOutput() *ShieldAmount {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *ShieldAmountRst) GetChange() *ShieldAmount {
	if m != nil {
		return m.Change
	}
	return nil
}

type CreateRawTxReq struct {
	ActionTy             int32    `protobuf:"varint,1,opt,name=actionTy,proto3" json:"actionTy,omitempty"`
	Data                 []byte   `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	AssetExec            string   `protobuf:"bytes,2,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	AssetToken           string   `protobuf:"bytes,3,opt,name=assetToken,proto3" json:"assetToken,omitempty"`
	Title                string   `protobuf:"bytes,6,opt,name=title,proto3" json:"title,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CreateRawTxReq proto.InternalMessageInfo

func (m *CreateRawTxReq) GetActionTy() int32 {
	if m != nil {
		return m.ActionTy
	}
	return 0
}

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

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

func (m *CreateRawTxReq) GetAssetToken() string {
	if m != nil {
		return m.AssetToken
	}
	return ""
}

func (m *CreateRawTxReq) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

type PaymentKeysReq struct {
	PrivKey              string   `protobuf:"bytes,1,opt,name=privKey,proto3" json:"privKey,omitempty"`
	Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	Detail               int32    `protobuf:"varint,3,opt,name=detail,proto3" json:"detail,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PaymentKeysReq proto.InternalMessageInfo

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

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

func (m *PaymentKeysReq) GetDetail() int32 {
	if m != nil {
		return m.Detail
	}
	return 0
}

type WalletNoteInfo 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"`
	AuthorizeSpendHash   string      `protobuf:"bytes,3,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	AuthorizeHash        string      `protobuf:"bytes,4,opt,name=authorizeHash,proto3" json:"authorizeHash,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 *WalletNoteInfo) Reset()         { *m = WalletNoteInfo{} }
func (m *WalletNoteInfo) String() string { return proto.CompactTextString(m) }
func (*WalletNoteInfo) ProtoMessage()    {}
func (*WalletNoteInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_5c21d519a9be369a, []int{50}
}

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

var xxx_messageInfo_WalletNoteInfo proto.InternalMessageInfo

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

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

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

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

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

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

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

type WalletDbMixInfo struct {
	Info                 *WalletNoteInfo `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{51}
}

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() *WalletNoteInfo {
	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"`
	AuthorizeSpendHash   string   `protobuf:"bytes,3,opt,name=authorizeSpendHash,proto3" json:"authorizeSpendHash,omitempty"`
	AuthorizeHash        string   `protobuf:"bytes,4,opt,name=authorizeHash,proto3" json:"authorizeHash,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{52}
}

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) GetAuthorizeSpendHash() string {
	if m != nil {
		return m.AuthorizeSpendHash
	}
	return ""
}

func (m *WalletMixIndexReq) GetAuthorizeHash() string {
	if m != nil {
		return m.AuthorizeHash
	}
	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 WalletNoteResp struct {
	Notes                []*WalletNoteInfo `protobuf:"bytes,1,rep,name=notes,proto3" json:"notes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_WalletNoteResp proto.InternalMessageInfo

func (m *WalletNoteResp) GetNotes() []*WalletNoteInfo {
	if m != nil {
		return m.Notes
	}
	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{54}
}

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 {
	Resps                []*WalletEnablePrivacyRst `protobuf:"bytes,1,rep,name=resps,proto3" json:"resps,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{55}
}

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) GetResps() []*WalletEnablePrivacyRst {
	if m != nil {
		return m.Resps
	}
	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{56}
}

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{57}
}

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{58}
}

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{59}
}

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{60}
}

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