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

package types

import (
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type MixConfigType int32

const (
	MixConfigType_VerifyKey  MixConfigType = 0
	MixConfigType_AuthPubKey MixConfigType = 1
)

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

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

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

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

type MixConfigAct int32

const (
	MixConfigAct_Add    MixConfigAct = 0
	MixConfigAct_Delete MixConfigAct = 1
)

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

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

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

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

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

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

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

var xxx_messageInfo_ZkVerifyKey proto.InternalMessageInfo

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

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

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

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

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

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

var xxx_messageInfo_ZkVerifyKeys proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_AuthPubKeys proto.InternalMessageInfo

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

type AuthorizePubKey struct {
	Value                string   `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AuthorizePubKey proto.InternalMessageInfo

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

//config verify parameter for proof
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
	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_VerifyKey
}

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

type isMixConfigAction_Value interface {
	isMixConfigAction_Value()
}

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

type MixConfigAction_AuthKey struct {
	AuthKey *AuthorizePubKey `protobuf:"bytes,4,opt,name=authKey,proto3,oneof"`
}

func (*MixConfigAction_VerifyKey) isMixConfigAction_Value() {}

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

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"`
	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{5}
}

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

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

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

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

var xxx_messageInfo_MixDepositAction proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_MixTransferAction proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_MixWithdrawAction proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_MixAuthorizeAction proto.InternalMessageInfo

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

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

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

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 {
	NodeHash             []byte   `protobuf:"bytes,1,opt,name=nodeHash,proto3" json:"nodeHash,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{11}
}

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

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

type WithdrawPublicInput struct {
	TreeRootHash         []byte   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	NullifierHash        []byte   `protobuf:"bytes,2,opt,name=nullifierHash,proto3" json:"nullifierHash,omitempty"`
	AuthorizeHash        []byte   `protobuf:"bytes,3,opt,name=authorizeHash,proto3" json:"authorizeHash,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{12}
}

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

func (m *WithdrawPublicInput) GetNullifierHash() []byte {
	if m != nil {
		return m.NullifierHash
	}
	return nil
}

func (m *WithdrawPublicInput) GetAuthorizeHash() []byte {
	if m != nil {
		return m.AuthorizeHash
	}
	return nil
}

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

type TransferInputPublicInput struct {
	TreeRootHash         []byte   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	CommitValueX         string   `protobuf:"bytes,2,opt,name=commitValueX,proto3" json:"commitValueX,omitempty"`
	CommitValueY         string   `protobuf:"bytes,3,opt,name=commitValueY,proto3" json:"commitValueY,omitempty"`
	AuthorizeHash        []byte   `protobuf:"bytes,4,opt,name=authorizeHash,proto3" json:"authorizeHash,omitempty"`
	NullifierHash        []byte   `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{13}
}

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

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

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

func (m *TransferInputPublicInput) GetAuthorizeHash() []byte {
	if m != nil {
		return m.AuthorizeHash
	}
	return nil
}

func (m *TransferInputPublicInput) GetNullifierHash() []byte {
	if m != nil {
		return m.NullifierHash
	}
	return nil
}

type TransferOutputPublicInput struct {
	NodeHash             []byte   `protobuf:"bytes,1,opt,name=nodeHash,proto3" json:"nodeHash,omitempty"`
	CommitValueX         string   `protobuf:"bytes,2,opt,name=commitValueX,proto3" json:"commitValueX,omitempty"`
	CommitValueY         string   `protobuf:"bytes,3,opt,name=commitValueY,proto3" json:"commitValueY,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{14}
}

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

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

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

type AuthorizePublicInput struct {
	TreeRootHash         []byte   `protobuf:"bytes,1,opt,name=treeRootHash,proto3" json:"treeRootHash,omitempty"`
	AuthorizePubKey      string   `protobuf:"bytes,2,opt,name=authorizePubKey,proto3" json:"authorizePubKey,omitempty"`
	AuthorizeHash        []byte   `protobuf:"bytes,3,opt,name=authorizeHash,proto3" json:"authorizeHash,omitempty"`
	AuthorizeSpendHash   []byte   `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{15}
}

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

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

func (m *AuthorizePublicInput) GetAuthorizeHash() []byte {
	if m != nil {
		return m.AuthorizeHash
	}
	return nil
}

func (m *AuthorizePublicInput) GetAuthorizeSpendHash() []byte {
	if m != nil {
		return m.AuthorizeSpendHash
	}
	return nil
}

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

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

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

var xxx_messageInfo_ExistValue proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_CommitTreeLeaves proto.InternalMessageInfo

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

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

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

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

var xxx_messageInfo_CommitTreeRoots proto.InternalMessageInfo

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

type CommitTreeProve struct {
	RootHash             string   `protobuf:"bytes,1,opt,name=rootHash,proto3" json:"rootHash,omitempty"`
	ProofSet             []string `protobuf:"bytes,2,rep,name=proofSet,proto3" json:"proofSet,omitempty"`
	ProofIndex           uint32   `protobuf:"varint,3,opt,name=proofIndex,proto3" json:"proofIndex,omitempty"`
	NumLeaves            uint32   `protobuf:"varint,4,opt,name=numLeaves,proto3" json:"numLeaves,omitempty"`
	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{19}
}

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 init() {
	proto.RegisterEnum("types.VerifyType", VerifyType_name, VerifyType_value)
	proto.RegisterEnum("types.ZkCurveId", ZkCurveId_name, ZkCurveId_value)
	proto.RegisterEnum("types.MixConfigType", MixConfigType_name, MixConfigType_value)
	proto.RegisterEnum("types.MixConfigAct", MixConfigAct_name, MixConfigAct_value)
	proto.RegisterType((*ZkVerifyKey)(nil), "types.ZkVerifyKey")
	proto.RegisterType((*ZkVerifyKeys)(nil), "types.ZkVerifyKeys")
	proto.RegisterType((*AuthPubKeys)(nil), "types.AuthPubKeys")
	proto.RegisterType((*AuthorizePubKey)(nil), "types.AuthorizePubKey")
	proto.RegisterType((*MixConfigAction)(nil), "types.MixConfigAction")
	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((*ExistValue)(nil), "types.ExistValue")
	proto.RegisterType((*CommitTreeLeaves)(nil), "types.CommitTreeLeaves")
	proto.RegisterType((*CommitTreeRoots)(nil), "types.CommitTreeRoots")
	proto.RegisterType((*CommitTreeProve)(nil), "types.CommitTreeProve")
}

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

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