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

package types

import (
	fmt "fmt"

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

	math "math"

	types "github.com/33cn/chain33/types"

	context "golang.org/x/net/context"

	grpc "google.golang.org/grpc"
)

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

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

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

func (m *ParacrossStatusDetails) Reset()         { *m = ParacrossStatusDetails{} }
func (m *ParacrossStatusDetails) String() string { return proto.CompactTextString(m) }
func (*ParacrossStatusDetails) ProtoMessage()    {}
func (*ParacrossStatusDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{0}
}
func (m *ParacrossStatusDetails) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossStatusDetails.Unmarshal(m, b)
}
func (m *ParacrossStatusDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossStatusDetails.Marshal(b, m, deterministic)
}
func (dst *ParacrossStatusDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatusDetails.Merge(dst, src)
}
func (m *ParacrossStatusDetails) XXX_Size() int {
	return xxx_messageInfo_ParacrossStatusDetails.Size(m)
}
func (m *ParacrossStatusDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossStatusDetails.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossStatusDetails proto.InternalMessageInfo

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

func (m *ParacrossStatusDetails) GetBlockHash() [][]byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

// 记录不同blockHash的详细数据
type ParacrossStatusBlockDetails struct {
	BlockHashs           [][]byte `protobuf:"bytes,1,rep,name=blockHashs,proto3" json:"blockHashs,omitempty"`
	TxResults            [][]byte `protobuf:"bytes,2,rep,name=txResults,proto3" json:"txResults,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossStatusBlockDetails) Reset()         { *m = ParacrossStatusBlockDetails{} }
func (m *ParacrossStatusBlockDetails) String() string { return proto.CompactTextString(m) }
func (*ParacrossStatusBlockDetails) ProtoMessage()    {}
func (*ParacrossStatusBlockDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{1}
}
func (m *ParacrossStatusBlockDetails) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossStatusBlockDetails.Unmarshal(m, b)
}
func (m *ParacrossStatusBlockDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossStatusBlockDetails.Marshal(b, m, deterministic)
}
func (dst *ParacrossStatusBlockDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatusBlockDetails.Merge(dst, src)
}
func (m *ParacrossStatusBlockDetails) XXX_Size() int {
	return xxx_messageInfo_ParacrossStatusBlockDetails.Size(m)
}
func (m *ParacrossStatusBlockDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossStatusBlockDetails.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossStatusBlockDetails proto.InternalMessageInfo

func (m *ParacrossStatusBlockDetails) GetBlockHashs() [][]byte {
	if m != nil {
		return m.BlockHashs
	}
	return nil
}

func (m *ParacrossStatusBlockDetails) GetTxResults() [][]byte {
	if m != nil {
		return m.TxResults
	}
	return nil
}

type ParacrossHeightStatus struct {
	// ing, done
	Status               int32                        `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Title                string                       `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64                        `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	Details              *ParacrossStatusDetails      `protobuf:"bytes,4,opt,name=details,proto3" json:"details,omitempty"`
	MainHeight           int64                        `protobuf:"varint,5,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	MainHash             []byte                       `protobuf:"bytes,6,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	BlockDetails         *ParacrossStatusBlockDetails `protobuf:"bytes,7,opt,name=blockDetails,proto3" json:"blockDetails,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *ParacrossHeightStatus) Reset()         { *m = ParacrossHeightStatus{} }
func (m *ParacrossHeightStatus) String() string { return proto.CompactTextString(m) }
func (*ParacrossHeightStatus) ProtoMessage()    {}
func (*ParacrossHeightStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{2}
}
func (m *ParacrossHeightStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossHeightStatus.Unmarshal(m, b)
}
func (m *ParacrossHeightStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossHeightStatus.Marshal(b, m, deterministic)
}
func (dst *ParacrossHeightStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossHeightStatus.Merge(dst, src)
}
func (m *ParacrossHeightStatus) XXX_Size() int {
	return xxx_messageInfo_ParacrossHeightStatus.Size(m)
}
func (m *ParacrossHeightStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossHeightStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossHeightStatus proto.InternalMessageInfo

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

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

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

func (m *ParacrossHeightStatus) GetDetails() *ParacrossStatusDetails {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *ParacrossHeightStatus) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParacrossHeightStatus) GetMainHash() []byte {
	if m != nil {
		return m.MainHash
	}
	return nil
}

func (m *ParacrossHeightStatus) GetBlockDetails() *ParacrossStatusBlockDetails {
	if m != nil {
		return m.BlockDetails
	}
	return nil
}

type ParacrossHeightStatusRsp struct {
	Status               int32    `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Title                string   `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	MainHeight           int64    `protobuf:"varint,4,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	MainHash             string   `protobuf:"bytes,5,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	CommitAddrs          []string `protobuf:"bytes,6,rep,name=commitAddrs,proto3" json:"commitAddrs,omitempty"`
	CommitBlockHash      []string `protobuf:"bytes,7,rep,name=commitBlockHash,proto3" json:"commitBlockHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossHeightStatusRsp) Reset()         { *m = ParacrossHeightStatusRsp{} }
func (m *ParacrossHeightStatusRsp) String() string { return proto.CompactTextString(m) }
func (*ParacrossHeightStatusRsp) ProtoMessage()    {}
func (*ParacrossHeightStatusRsp) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{3}
}
func (m *ParacrossHeightStatusRsp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossHeightStatusRsp.Unmarshal(m, b)
}
func (m *ParacrossHeightStatusRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossHeightStatusRsp.Marshal(b, m, deterministic)
}
func (dst *ParacrossHeightStatusRsp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossHeightStatusRsp.Merge(dst, src)
}
func (m *ParacrossHeightStatusRsp) XXX_Size() int {
	return xxx_messageInfo_ParacrossHeightStatusRsp.Size(m)
}
func (m *ParacrossHeightStatusRsp) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossHeightStatusRsp.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossHeightStatusRsp proto.InternalMessageInfo

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

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

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

func (m *ParacrossHeightStatusRsp) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParacrossHeightStatusRsp) GetMainHash() string {
	if m != nil {
		return m.MainHash
	}
	return ""
}

func (m *ParacrossHeightStatusRsp) GetCommitAddrs() []string {
	if m != nil {
		return m.CommitAddrs
	}
	return nil
}

func (m *ParacrossHeightStatusRsp) GetCommitBlockHash() []string {
	if m != nil {
		return m.CommitBlockHash
	}
	return nil
}

type ParacrossStatus struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	BlockHash            []byte   `protobuf:"bytes,3,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	MainHeight           int64    `protobuf:"varint,4,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	MainHash             []byte   `protobuf:"bytes,5,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossStatus) Reset()         { *m = ParacrossStatus{} }
func (m *ParacrossStatus) String() string { return proto.CompactTextString(m) }
func (*ParacrossStatus) ProtoMessage()    {}
func (*ParacrossStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{4}
}
func (m *ParacrossStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossStatus.Unmarshal(m, b)
}
func (m *ParacrossStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossStatus.Marshal(b, m, deterministic)
}
func (dst *ParacrossStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatus.Merge(dst, src)
}
func (m *ParacrossStatus) XXX_Size() int {
	return xxx_messageInfo_ParacrossStatus.Size(m)
}
func (m *ParacrossStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossStatus proto.InternalMessageInfo

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

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

func (m *ParacrossStatus) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *ParacrossStatus) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParacrossStatus) GetMainHash() []byte {
	if m != nil {
		return m.MainHash
	}
	return nil
}

type ParacrossConsensusStatus struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	ChainHeight          int64    `protobuf:"varint,2,opt,name=chainHeight,proto3" json:"chainHeight,omitempty"`
	ConsensHeight        int64    `protobuf:"varint,3,opt,name=consensHeight,proto3" json:"consensHeight,omitempty"`
	ConsensBlockHash     string   `protobuf:"bytes,4,opt,name=consensBlockHash,proto3" json:"consensBlockHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossConsensusStatus) Reset()         { *m = ParacrossConsensusStatus{} }
func (m *ParacrossConsensusStatus) String() string { return proto.CompactTextString(m) }
func (*ParacrossConsensusStatus) ProtoMessage()    {}
func (*ParacrossConsensusStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{5}
}
func (m *ParacrossConsensusStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossConsensusStatus.Unmarshal(m, b)
}
func (m *ParacrossConsensusStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossConsensusStatus.Marshal(b, m, deterministic)
}
func (dst *ParacrossConsensusStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossConsensusStatus.Merge(dst, src)
}
func (m *ParacrossConsensusStatus) XXX_Size() int {
	return xxx_messageInfo_ParacrossConsensusStatus.Size(m)
}
func (m *ParacrossConsensusStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossConsensusStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossConsensusStatus proto.InternalMessageInfo

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

func (m *ParacrossConsensusStatus) GetChainHeight() int64 {
	if m != nil {
		return m.ChainHeight
	}
	return 0
}

func (m *ParacrossConsensusStatus) GetConsensHeight() int64 {
	if m != nil {
		return m.ConsensHeight
	}
	return 0
}

func (m *ParacrossConsensusStatus) GetConsensBlockHash() string {
	if m != nil {
		return m.ConsensBlockHash
	}
	return ""
}

type ParaNodeAddrConfig struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Op                   uint32   `protobuf:"varint,2,opt,name=op,proto3" json:"op,omitempty"`
	Id                   string   `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	Addr                 string   `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
	Value                uint32   `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"`
	CoinsFrozen          int64    `protobuf:"varint,6,opt,name=coinsFrozen,proto3" json:"coinsFrozen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaNodeAddrConfig) Reset()         { *m = ParaNodeAddrConfig{} }
func (m *ParaNodeAddrConfig) String() string { return proto.CompactTextString(m) }
func (*ParaNodeAddrConfig) ProtoMessage()    {}
func (*ParaNodeAddrConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{6}
}
func (m *ParaNodeAddrConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeAddrConfig.Unmarshal(m, b)
}
func (m *ParaNodeAddrConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeAddrConfig.Marshal(b, m, deterministic)
}
func (dst *ParaNodeAddrConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeAddrConfig.Merge(dst, src)
}
func (m *ParaNodeAddrConfig) XXX_Size() int {
	return xxx_messageInfo_ParaNodeAddrConfig.Size(m)
}
func (m *ParaNodeAddrConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeAddrConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeAddrConfig proto.InternalMessageInfo

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

func (m *ParaNodeAddrConfig) GetOp() uint32 {
	if m != nil {
		return m.Op
	}
	return 0
}

func (m *ParaNodeAddrConfig) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

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

func (m *ParaNodeAddrConfig) GetCoinsFrozen() int64 {
	if m != nil {
		return m.CoinsFrozen
	}
	return 0
}

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

func (m *ParaNodeVoteDetail) Reset()         { *m = ParaNodeVoteDetail{} }
func (m *ParaNodeVoteDetail) String() string { return proto.CompactTextString(m) }
func (*ParaNodeVoteDetail) ProtoMessage()    {}
func (*ParaNodeVoteDetail) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{7}
}
func (m *ParaNodeVoteDetail) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeVoteDetail.Unmarshal(m, b)
}
func (m *ParaNodeVoteDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeVoteDetail.Marshal(b, m, deterministic)
}
func (dst *ParaNodeVoteDetail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeVoteDetail.Merge(dst, src)
}
func (m *ParaNodeVoteDetail) XXX_Size() int {
	return xxx_messageInfo_ParaNodeVoteDetail.Size(m)
}
func (m *ParaNodeVoteDetail) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeVoteDetail.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeVoteDetail proto.InternalMessageInfo

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

func (m *ParaNodeVoteDetail) GetVotes() []string {
	if m != nil {
		return m.Votes
	}
	return nil
}

type ParaNodeAddrIdStatus struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	ProposalId           string   `protobuf:"bytes,2,opt,name=proposalId,proto3" json:"proposalId,omitempty"`
	QuitId               string   `protobuf:"bytes,3,opt,name=quitId,proto3" json:"quitId,omitempty"`
	Status               int32    `protobuf:"varint,4,opt,name=status,proto3" json:"status,omitempty"`
	Title                string   `protobuf:"bytes,5,opt,name=title,proto3" json:"title,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaNodeAddrIdStatus) Reset()         { *m = ParaNodeAddrIdStatus{} }
func (m *ParaNodeAddrIdStatus) String() string { return proto.CompactTextString(m) }
func (*ParaNodeAddrIdStatus) ProtoMessage()    {}
func (*ParaNodeAddrIdStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{8}
}
func (m *ParaNodeAddrIdStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeAddrIdStatus.Unmarshal(m, b)
}
func (m *ParaNodeAddrIdStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeAddrIdStatus.Marshal(b, m, deterministic)
}
func (dst *ParaNodeAddrIdStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeAddrIdStatus.Merge(dst, src)
}
func (m *ParaNodeAddrIdStatus) XXX_Size() int {
	return xxx_messageInfo_ParaNodeAddrIdStatus.Size(m)
}
func (m *ParaNodeAddrIdStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeAddrIdStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeAddrIdStatus proto.InternalMessageInfo

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

func (m *ParaNodeAddrIdStatus) GetProposalId() string {
	if m != nil {
		return m.ProposalId
	}
	return ""
}

func (m *ParaNodeAddrIdStatus) GetQuitId() string {
	if m != nil {
		return m.QuitId
	}
	return ""
}

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

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

type ParaNodeIdStatus struct {
	Id                   string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status               int32               `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Title                string              `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	TargetAddr           string              `protobuf:"bytes,4,opt,name=targetAddr,proto3" json:"targetAddr,omitempty"`
	CoinsFrozen          int64               `protobuf:"varint,5,opt,name=coinsFrozen,proto3" json:"coinsFrozen,omitempty"`
	Votes                *ParaNodeVoteDetail `protobuf:"bytes,6,opt,name=votes,proto3" json:"votes,omitempty"`
	FromAddr             string              `protobuf:"bytes,7,opt,name=fromAddr,proto3" json:"fromAddr,omitempty"`
	Height               int64               `protobuf:"varint,8,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ParaNodeIdStatus) Reset()         { *m = ParaNodeIdStatus{} }
func (m *ParaNodeIdStatus) String() string { return proto.CompactTextString(m) }
func (*ParaNodeIdStatus) ProtoMessage()    {}
func (*ParaNodeIdStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{9}
}
func (m *ParaNodeIdStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeIdStatus.Unmarshal(m, b)
}
func (m *ParaNodeIdStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeIdStatus.Marshal(b, m, deterministic)
}
func (dst *ParaNodeIdStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeIdStatus.Merge(dst, src)
}
func (m *ParaNodeIdStatus) XXX_Size() int {
	return xxx_messageInfo_ParaNodeIdStatus.Size(m)
}
func (m *ParaNodeIdStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeIdStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeIdStatus proto.InternalMessageInfo

func (m *ParaNodeIdStatus) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

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

func (m *ParaNodeIdStatus) GetTargetAddr() string {
	if m != nil {
		return m.TargetAddr
	}
	return ""
}

func (m *ParaNodeIdStatus) GetCoinsFrozen() int64 {
	if m != nil {
		return m.CoinsFrozen
	}
	return 0
}

func (m *ParaNodeIdStatus) GetVotes() *ParaNodeVoteDetail {
	if m != nil {
		return m.Votes
	}
	return nil
}

func (m *ParaNodeIdStatus) GetFromAddr() string {
	if m != nil {
		return m.FromAddr
	}
	return ""
}

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

type ReceiptParaNodeConfig struct {
	Addr                 string              `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Config               *ParaNodeAddrConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	Prev                 *ParaNodeIdStatus   `protobuf:"bytes,3,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *ParaNodeIdStatus   `protobuf:"bytes,4,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *ReceiptParaNodeConfig) Reset()         { *m = ReceiptParaNodeConfig{} }
func (m *ReceiptParaNodeConfig) String() string { return proto.CompactTextString(m) }
func (*ReceiptParaNodeConfig) ProtoMessage()    {}
func (*ReceiptParaNodeConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{10}
}
func (m *ReceiptParaNodeConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParaNodeConfig.Unmarshal(m, b)
}
func (m *ReceiptParaNodeConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParaNodeConfig.Marshal(b, m, deterministic)
}
func (dst *ReceiptParaNodeConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeConfig.Merge(dst, src)
}
func (m *ReceiptParaNodeConfig) XXX_Size() int {
	return xxx_messageInfo_ReceiptParaNodeConfig.Size(m)
}
func (m *ReceiptParaNodeConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParaNodeConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParaNodeConfig proto.InternalMessageInfo

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

func (m *ReceiptParaNodeConfig) GetConfig() *ParaNodeAddrConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *ReceiptParaNodeConfig) GetPrev() *ParaNodeIdStatus {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParaNodeConfig) GetCurrent() *ParaNodeIdStatus {
	if m != nil {
		return m.Current
	}
	return nil
}

type ReceiptParaNodeAddrStatUpdate struct {
	FromAddr             string                `protobuf:"bytes,1,opt,name=fromAddr,proto3" json:"fromAddr,omitempty"`
	Prev                 *ParaNodeAddrIdStatus `protobuf:"bytes,2,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *ParaNodeAddrIdStatus `protobuf:"bytes,3,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *ReceiptParaNodeAddrStatUpdate) Reset()         { *m = ReceiptParaNodeAddrStatUpdate{} }
func (m *ReceiptParaNodeAddrStatUpdate) String() string { return proto.CompactTextString(m) }
func (*ReceiptParaNodeAddrStatUpdate) ProtoMessage()    {}
func (*ReceiptParaNodeAddrStatUpdate) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{11}
}
func (m *ReceiptParaNodeAddrStatUpdate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.Unmarshal(m, b)
}
func (m *ReceiptParaNodeAddrStatUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.Marshal(b, m, deterministic)
}
func (dst *ReceiptParaNodeAddrStatUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.Merge(dst, src)
}
func (m *ReceiptParaNodeAddrStatUpdate) XXX_Size() int {
	return xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.Size(m)
}
func (m *ReceiptParaNodeAddrStatUpdate) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParaNodeAddrStatUpdate proto.InternalMessageInfo

func (m *ReceiptParaNodeAddrStatUpdate) GetFromAddr() string {
	if m != nil {
		return m.FromAddr
	}
	return ""
}

func (m *ReceiptParaNodeAddrStatUpdate) GetPrev() *ParaNodeAddrIdStatus {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParaNodeAddrStatUpdate) GetCurrent() *ParaNodeAddrIdStatus {
	if m != nil {
		return m.Current
	}
	return nil
}

type ReceiptParaNodeVoteDone struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Title                string   `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	TargetAddr           string   `protobuf:"bytes,3,opt,name=targetAddr,proto3" json:"targetAddr,omitempty"`
	TotalNodes           int32    `protobuf:"varint,4,opt,name=totalNodes,proto3" json:"totalNodes,omitempty"`
	TotalVote            int32    `protobuf:"varint,5,opt,name=totalVote,proto3" json:"totalVote,omitempty"`
	MostVote             int32    `protobuf:"varint,6,opt,name=mostVote,proto3" json:"mostVote,omitempty"`
	VoteRst              string   `protobuf:"bytes,7,opt,name=voteRst,proto3" json:"voteRst,omitempty"`
	DoneStatus           int32    `protobuf:"varint,8,opt,name=doneStatus,proto3" json:"doneStatus,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReceiptParaNodeVoteDone) Reset()         { *m = ReceiptParaNodeVoteDone{} }
func (m *ReceiptParaNodeVoteDone) String() string { return proto.CompactTextString(m) }
func (*ReceiptParaNodeVoteDone) ProtoMessage()    {}
func (*ReceiptParaNodeVoteDone) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{12}
}
func (m *ReceiptParaNodeVoteDone) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParaNodeVoteDone.Unmarshal(m, b)
}
func (m *ReceiptParaNodeVoteDone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParaNodeVoteDone.Marshal(b, m, deterministic)
}
func (dst *ReceiptParaNodeVoteDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeVoteDone.Merge(dst, src)
}
func (m *ReceiptParaNodeVoteDone) XXX_Size() int {
	return xxx_messageInfo_ReceiptParaNodeVoteDone.Size(m)
}
func (m *ReceiptParaNodeVoteDone) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParaNodeVoteDone.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParaNodeVoteDone proto.InternalMessageInfo

func (m *ReceiptParaNodeVoteDone) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *ReceiptParaNodeVoteDone) GetTargetAddr() string {
	if m != nil {
		return m.TargetAddr
	}
	return ""
}

func (m *ReceiptParaNodeVoteDone) GetTotalNodes() int32 {
	if m != nil {
		return m.TotalNodes
	}
	return 0
}

func (m *ReceiptParaNodeVoteDone) GetTotalVote() int32 {
	if m != nil {
		return m.TotalVote
	}
	return 0
}

func (m *ReceiptParaNodeVoteDone) GetMostVote() int32 {
	if m != nil {
		return m.MostVote
	}
	return 0
}

func (m *ReceiptParaNodeVoteDone) GetVoteRst() string {
	if m != nil {
		return m.VoteRst
	}
	return ""
}

func (m *ReceiptParaNodeVoteDone) GetDoneStatus() int32 {
	if m != nil {
		return m.DoneStatus
	}
	return 0
}

type ParaNodeGroupConfig struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Op                   uint32   `protobuf:"varint,2,opt,name=op,proto3" json:"op,omitempty"`
	Id                   string   `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
	Addrs                string   `protobuf:"bytes,4,opt,name=addrs,proto3" json:"addrs,omitempty"`
	CoinsFrozen          int64    `protobuf:"varint,5,opt,name=coinsFrozen,proto3" json:"coinsFrozen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaNodeGroupConfig) Reset()         { *m = ParaNodeGroupConfig{} }
func (m *ParaNodeGroupConfig) String() string { return proto.CompactTextString(m) }
func (*ParaNodeGroupConfig) ProtoMessage()    {}
func (*ParaNodeGroupConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{13}
}
func (m *ParaNodeGroupConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeGroupConfig.Unmarshal(m, b)
}
func (m *ParaNodeGroupConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeGroupConfig.Marshal(b, m, deterministic)
}
func (dst *ParaNodeGroupConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeGroupConfig.Merge(dst, src)
}
func (m *ParaNodeGroupConfig) XXX_Size() int {
	return xxx_messageInfo_ParaNodeGroupConfig.Size(m)
}
func (m *ParaNodeGroupConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeGroupConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeGroupConfig proto.InternalMessageInfo

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

func (m *ParaNodeGroupConfig) GetOp() uint32 {
	if m != nil {
		return m.Op
	}
	return 0
}

func (m *ParaNodeGroupConfig) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ParaNodeGroupConfig) GetAddrs() string {
	if m != nil {
		return m.Addrs
	}
	return ""
}

func (m *ParaNodeGroupConfig) GetCoinsFrozen() int64 {
	if m != nil {
		return m.CoinsFrozen
	}
	return 0
}

type ParaNodeGroupStatus struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status               int32    `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Title                string   `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	TargetAddrs          string   `protobuf:"bytes,4,opt,name=targetAddrs,proto3" json:"targetAddrs,omitempty"`
	CoinsFrozen          int64    `protobuf:"varint,5,opt,name=coinsFrozen,proto3" json:"coinsFrozen,omitempty"`
	FromAddr             string   `protobuf:"bytes,6,opt,name=fromAddr,proto3" json:"fromAddr,omitempty"`
	Height               int64    `protobuf:"varint,7,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaNodeGroupStatus) Reset()         { *m = ParaNodeGroupStatus{} }
func (m *ParaNodeGroupStatus) String() string { return proto.CompactTextString(m) }
func (*ParaNodeGroupStatus) ProtoMessage()    {}
func (*ParaNodeGroupStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{14}
}
func (m *ParaNodeGroupStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaNodeGroupStatus.Unmarshal(m, b)
}
func (m *ParaNodeGroupStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaNodeGroupStatus.Marshal(b, m, deterministic)
}
func (dst *ParaNodeGroupStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeGroupStatus.Merge(dst, src)
}
func (m *ParaNodeGroupStatus) XXX_Size() int {
	return xxx_messageInfo_ParaNodeGroupStatus.Size(m)
}
func (m *ParaNodeGroupStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaNodeGroupStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParaNodeGroupStatus proto.InternalMessageInfo

func (m *ParaNodeGroupStatus) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

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

func (m *ParaNodeGroupStatus) GetTargetAddrs() string {
	if m != nil {
		return m.TargetAddrs
	}
	return ""
}

func (m *ParaNodeGroupStatus) GetCoinsFrozen() int64 {
	if m != nil {
		return m.CoinsFrozen
	}
	return 0
}

func (m *ParaNodeGroupStatus) GetFromAddr() string {
	if m != nil {
		return m.FromAddr
	}
	return ""
}

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

type ReceiptParaNodeGroupConfig struct {
	Addr                 string               `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Config               *ParaNodeGroupConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	Prev                 *ParaNodeGroupStatus `protobuf:"bytes,3,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *ParaNodeGroupStatus `protobuf:"bytes,4,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ReceiptParaNodeGroupConfig) Reset()         { *m = ReceiptParaNodeGroupConfig{} }
func (m *ReceiptParaNodeGroupConfig) String() string { return proto.CompactTextString(m) }
func (*ReceiptParaNodeGroupConfig) ProtoMessage()    {}
func (*ReceiptParaNodeGroupConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{15}
}
func (m *ReceiptParaNodeGroupConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParaNodeGroupConfig.Unmarshal(m, b)
}
func (m *ReceiptParaNodeGroupConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParaNodeGroupConfig.Marshal(b, m, deterministic)
}
func (dst *ReceiptParaNodeGroupConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeGroupConfig.Merge(dst, src)
}
func (m *ReceiptParaNodeGroupConfig) XXX_Size() int {
	return xxx_messageInfo_ReceiptParaNodeGroupConfig.Size(m)
}
func (m *ReceiptParaNodeGroupConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParaNodeGroupConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParaNodeGroupConfig proto.InternalMessageInfo

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

func (m *ReceiptParaNodeGroupConfig) GetConfig() *ParaNodeGroupConfig {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *ReceiptParaNodeGroupConfig) GetPrev() *ParaNodeGroupStatus {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParaNodeGroupConfig) GetCurrent() *ParaNodeGroupStatus {
	if m != nil {
		return m.Current
	}
	return nil
}

// node query
type ReqParacrossNodeInfo struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Addr                 string   `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"`
	Status               int32    `protobuf:"varint,4,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqParacrossNodeInfo) Reset()         { *m = ReqParacrossNodeInfo{} }
func (m *ReqParacrossNodeInfo) String() string { return proto.CompactTextString(m) }
func (*ReqParacrossNodeInfo) ProtoMessage()    {}
func (*ReqParacrossNodeInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{16}
}
func (m *ReqParacrossNodeInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqParacrossNodeInfo.Unmarshal(m, b)
}
func (m *ReqParacrossNodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqParacrossNodeInfo.Marshal(b, m, deterministic)
}
func (dst *ReqParacrossNodeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossNodeInfo.Merge(dst, src)
}
func (m *ReqParacrossNodeInfo) XXX_Size() int {
	return xxx_messageInfo_ReqParacrossNodeInfo.Size(m)
}
func (m *ReqParacrossNodeInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqParacrossNodeInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ReqParacrossNodeInfo proto.InternalMessageInfo

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

func (m *ReqParacrossNodeInfo) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

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

type RespParacrossNodeAddrs struct {
	Ids                  []*ParaNodeIdStatus `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *RespParacrossNodeAddrs) Reset()         { *m = RespParacrossNodeAddrs{} }
func (m *RespParacrossNodeAddrs) String() string { return proto.CompactTextString(m) }
func (*RespParacrossNodeAddrs) ProtoMessage()    {}
func (*RespParacrossNodeAddrs) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{17}
}
func (m *RespParacrossNodeAddrs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RespParacrossNodeAddrs.Unmarshal(m, b)
}
func (m *RespParacrossNodeAddrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RespParacrossNodeAddrs.Marshal(b, m, deterministic)
}
func (dst *RespParacrossNodeAddrs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossNodeAddrs.Merge(dst, src)
}
func (m *RespParacrossNodeAddrs) XXX_Size() int {
	return xxx_messageInfo_RespParacrossNodeAddrs.Size(m)
}
func (m *RespParacrossNodeAddrs) XXX_DiscardUnknown() {
	xxx_messageInfo_RespParacrossNodeAddrs.DiscardUnknown(m)
}

var xxx_messageInfo_RespParacrossNodeAddrs proto.InternalMessageInfo

func (m *RespParacrossNodeAddrs) GetIds() []*ParaNodeIdStatus {
	if m != nil {
		return m.Ids
	}
	return nil
}

type RespParacrossNodeGroups struct {
	Ids                  []*ParaNodeGroupStatus `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *RespParacrossNodeGroups) Reset()         { *m = RespParacrossNodeGroups{} }
func (m *RespParacrossNodeGroups) String() string { return proto.CompactTextString(m) }
func (*RespParacrossNodeGroups) ProtoMessage()    {}
func (*RespParacrossNodeGroups) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{18}
}
func (m *RespParacrossNodeGroups) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RespParacrossNodeGroups.Unmarshal(m, b)
}
func (m *RespParacrossNodeGroups) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RespParacrossNodeGroups.Marshal(b, m, deterministic)
}
func (dst *RespParacrossNodeGroups) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossNodeGroups.Merge(dst, src)
}
func (m *RespParacrossNodeGroups) XXX_Size() int {
	return xxx_messageInfo_RespParacrossNodeGroups.Size(m)
}
func (m *RespParacrossNodeGroups) XXX_DiscardUnknown() {
	xxx_messageInfo_RespParacrossNodeGroups.DiscardUnknown(m)
}

var xxx_messageInfo_RespParacrossNodeGroups proto.InternalMessageInfo

func (m *RespParacrossNodeGroups) GetIds() []*ParaNodeGroupStatus {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ParaBlock2MainMap struct {
	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	BlockHash            string   `protobuf:"bytes,2,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	MainHeight           int64    `protobuf:"varint,3,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	MainHash             string   `protobuf:"bytes,4,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaBlock2MainMap) Reset()         { *m = ParaBlock2MainMap{} }
func (m *ParaBlock2MainMap) String() string { return proto.CompactTextString(m) }
func (*ParaBlock2MainMap) ProtoMessage()    {}
func (*ParaBlock2MainMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{19}
}
func (m *ParaBlock2MainMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaBlock2MainMap.Unmarshal(m, b)
}
func (m *ParaBlock2MainMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaBlock2MainMap.Marshal(b, m, deterministic)
}
func (dst *ParaBlock2MainMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaBlock2MainMap.Merge(dst, src)
}
func (m *ParaBlock2MainMap) XXX_Size() int {
	return xxx_messageInfo_ParaBlock2MainMap.Size(m)
}
func (m *ParaBlock2MainMap) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaBlock2MainMap.DiscardUnknown(m)
}

var xxx_messageInfo_ParaBlock2MainMap proto.InternalMessageInfo

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

func (m *ParaBlock2MainMap) GetBlockHash() string {
	if m != nil {
		return m.BlockHash
	}
	return ""
}

func (m *ParaBlock2MainMap) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParaBlock2MainMap) GetMainHash() string {
	if m != nil {
		return m.MainHash
	}
	return ""
}

type ParaBlock2MainInfo struct {
	Items                []*ParaBlock2MainMap `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ParaBlock2MainInfo) Reset()         { *m = ParaBlock2MainInfo{} }
func (m *ParaBlock2MainInfo) String() string { return proto.CompactTextString(m) }
func (*ParaBlock2MainInfo) ProtoMessage()    {}
func (*ParaBlock2MainInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{20}
}
func (m *ParaBlock2MainInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaBlock2MainInfo.Unmarshal(m, b)
}
func (m *ParaBlock2MainInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaBlock2MainInfo.Marshal(b, m, deterministic)
}
func (dst *ParaBlock2MainInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaBlock2MainInfo.Merge(dst, src)
}
func (m *ParaBlock2MainInfo) XXX_Size() int {
	return xxx_messageInfo_ParaBlock2MainInfo.Size(m)
}
func (m *ParaBlock2MainInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaBlock2MainInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ParaBlock2MainInfo proto.InternalMessageInfo

func (m *ParaBlock2MainInfo) GetItems() []*ParaBlock2MainMap {
	if m != nil {
		return m.Items
	}
	return nil
}

// action
type ParacrossNodeStatus struct {
	MainBlockHash        []byte   `protobuf:"bytes,1,opt,name=mainBlockHash,proto3" json:"mainBlockHash,omitempty"`
	MainBlockHeight      int64    `protobuf:"varint,2,opt,name=mainBlockHeight,proto3" json:"mainBlockHeight,omitempty"`
	Title                string   `protobuf:"bytes,3,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,4,opt,name=height,proto3" json:"height,omitempty"`
	PreBlockHash         []byte   `protobuf:"bytes,5,opt,name=preBlockHash,proto3" json:"preBlockHash,omitempty"`
	BlockHash            []byte   `protobuf:"bytes,6,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	PreStateHash         []byte   `protobuf:"bytes,7,opt,name=preStateHash,proto3" json:"preStateHash,omitempty"`
	StateHash            []byte   `protobuf:"bytes,8,opt,name=stateHash,proto3" json:"stateHash,omitempty"`
	TxCounts             uint32   `protobuf:"varint,9,opt,name=txCounts,proto3" json:"txCounts,omitempty"`
	TxResult             []byte   `protobuf:"bytes,10,opt,name=txResult,proto3" json:"txResult,omitempty"`
	TxHashs              [][]byte `protobuf:"bytes,11,rep,name=txHashs,proto3" json:"txHashs,omitempty"`
	CrossTxResult        []byte   `protobuf:"bytes,12,opt,name=crossTxResult,proto3" json:"crossTxResult,omitempty"`
	CrossTxHashs         [][]byte `protobuf:"bytes,13,rep,name=crossTxHashs,proto3" json:"crossTxHashs,omitempty"`
	NonCommitTxCounts    uint32   `protobuf:"varint,14,opt,name=nonCommitTxCounts,proto3" json:"nonCommitTxCounts,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossNodeStatus) Reset()         { *m = ParacrossNodeStatus{} }
func (m *ParacrossNodeStatus) String() string { return proto.CompactTextString(m) }
func (*ParacrossNodeStatus) ProtoMessage()    {}
func (*ParacrossNodeStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{21}
}
func (m *ParacrossNodeStatus) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossNodeStatus.Unmarshal(m, b)
}
func (m *ParacrossNodeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossNodeStatus.Marshal(b, m, deterministic)
}
func (dst *ParacrossNodeStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossNodeStatus.Merge(dst, src)
}
func (m *ParacrossNodeStatus) XXX_Size() int {
	return xxx_messageInfo_ParacrossNodeStatus.Size(m)
}
func (m *ParacrossNodeStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossNodeStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossNodeStatus proto.InternalMessageInfo

func (m *ParacrossNodeStatus) GetMainBlockHash() []byte {
	if m != nil {
		return m.MainBlockHash
	}
	return nil
}

func (m *ParacrossNodeStatus) GetMainBlockHeight() int64 {
	if m != nil {
		return m.MainBlockHeight
	}
	return 0
}

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

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

func (m *ParacrossNodeStatus) GetPreBlockHash() []byte {
	if m != nil {
		return m.PreBlockHash
	}
	return nil
}

func (m *ParacrossNodeStatus) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *ParacrossNodeStatus) GetPreStateHash() []byte {
	if m != nil {
		return m.PreStateHash
	}
	return nil
}

func (m *ParacrossNodeStatus) GetStateHash() []byte {
	if m != nil {
		return m.StateHash
	}
	return nil
}

func (m *ParacrossNodeStatus) GetTxCounts() uint32 {
	if m != nil {
		return m.TxCounts
	}
	return 0
}

func (m *ParacrossNodeStatus) GetTxResult() []byte {
	if m != nil {
		return m.TxResult
	}
	return nil
}

func (m *ParacrossNodeStatus) GetTxHashs() [][]byte {
	if m != nil {
		return m.TxHashs
	}
	return nil
}

func (m *ParacrossNodeStatus) GetCrossTxResult() []byte {
	if m != nil {
		return m.CrossTxResult
	}
	return nil
}

func (m *ParacrossNodeStatus) GetCrossTxHashs() [][]byte {
	if m != nil {
		return m.CrossTxHashs
	}
	return nil
}

func (m *ParacrossNodeStatus) GetNonCommitTxCounts() uint32 {
	if m != nil {
		return m.NonCommitTxCounts
	}
	return 0
}

type ParacrossCommitAction struct {
	Status               *ParacrossNodeStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ParacrossCommitAction) Reset()         { *m = ParacrossCommitAction{} }
func (m *ParacrossCommitAction) String() string { return proto.CompactTextString(m) }
func (*ParacrossCommitAction) ProtoMessage()    {}
func (*ParacrossCommitAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{22}
}
func (m *ParacrossCommitAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossCommitAction.Unmarshal(m, b)
}
func (m *ParacrossCommitAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossCommitAction.Marshal(b, m, deterministic)
}
func (dst *ParacrossCommitAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossCommitAction.Merge(dst, src)
}
func (m *ParacrossCommitAction) XXX_Size() int {
	return xxx_messageInfo_ParacrossCommitAction.Size(m)
}
func (m *ParacrossCommitAction) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossCommitAction.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossCommitAction proto.InternalMessageInfo

func (m *ParacrossCommitAction) GetStatus() *ParacrossNodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type ParacrossMinerAction struct {
	Status               *ParacrossNodeStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	IsSelfConsensus      bool                 `protobuf:"varint,2,opt,name=isSelfConsensus,proto3" json:"isSelfConsensus,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ParacrossMinerAction) Reset()         { *m = ParacrossMinerAction{} }
func (m *ParacrossMinerAction) String() string { return proto.CompactTextString(m) }
func (*ParacrossMinerAction) ProtoMessage()    {}
func (*ParacrossMinerAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{23}
}
func (m *ParacrossMinerAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossMinerAction.Unmarshal(m, b)
}
func (m *ParacrossMinerAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossMinerAction.Marshal(b, m, deterministic)
}
func (dst *ParacrossMinerAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossMinerAction.Merge(dst, src)
}
func (m *ParacrossMinerAction) XXX_Size() int {
	return xxx_messageInfo_ParacrossMinerAction.Size(m)
}
func (m *ParacrossMinerAction) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossMinerAction.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossMinerAction proto.InternalMessageInfo

func (m *ParacrossMinerAction) GetStatus() *ParacrossNodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ParacrossMinerAction) GetIsSelfConsensus() bool {
	if m != nil {
		return m.IsSelfConsensus
	}
	return false
}

type ParacrossAction struct {
	// Types that are valid to be assigned to Value:
	//	*ParacrossAction_Commit
	//	*ParacrossAction_Miner
	//	*ParacrossAction_AssetTransfer
	//	*ParacrossAction_AssetWithdraw
	//	*ParacrossAction_Transfer
	//	*ParacrossAction_Withdraw
	//	*ParacrossAction_TransferToExec
	//	*ParacrossAction_NodeConfig
	//	*ParacrossAction_NodeGroupConfig
	Value                isParacrossAction_Value `protobuf_oneof:"value"`
	Ty                   int32                   `protobuf:"varint,2,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *ParacrossAction) Reset()         { *m = ParacrossAction{} }
func (m *ParacrossAction) String() string { return proto.CompactTextString(m) }
func (*ParacrossAction) ProtoMessage()    {}
func (*ParacrossAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{24}
}
func (m *ParacrossAction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossAction.Unmarshal(m, b)
}
func (m *ParacrossAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossAction.Marshal(b, m, deterministic)
}
func (dst *ParacrossAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossAction.Merge(dst, src)
}
func (m *ParacrossAction) XXX_Size() int {
	return xxx_messageInfo_ParacrossAction.Size(m)
}
func (m *ParacrossAction) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossAction.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossAction proto.InternalMessageInfo

type isParacrossAction_Value interface {
	isParacrossAction_Value()
}

type ParacrossAction_Commit struct {
	Commit *ParacrossCommitAction `protobuf:"bytes,1,opt,name=commit,proto3,oneof"`
}

type ParacrossAction_Miner struct {
	Miner *ParacrossMinerAction `protobuf:"bytes,3,opt,name=miner,proto3,oneof"`
}

type ParacrossAction_AssetTransfer struct {
	AssetTransfer *types.AssetsTransfer `protobuf:"bytes,4,opt,name=assetTransfer,proto3,oneof"`
}

type ParacrossAction_AssetWithdraw struct {
	AssetWithdraw *types.AssetsWithdraw `protobuf:"bytes,5,opt,name=assetWithdraw,proto3,oneof"`
}

type ParacrossAction_Transfer struct {
	Transfer *types.AssetsTransfer `protobuf:"bytes,6,opt,name=transfer,proto3,oneof"`
}

type ParacrossAction_Withdraw struct {
	Withdraw *types.AssetsWithdraw `protobuf:"bytes,7,opt,name=withdraw,proto3,oneof"`
}

type ParacrossAction_TransferToExec struct {
	TransferToExec *types.AssetsTransferToExec `protobuf:"bytes,8,opt,name=transferToExec,proto3,oneof"`
}

type ParacrossAction_NodeConfig struct {
	NodeConfig *ParaNodeAddrConfig `protobuf:"bytes,9,opt,name=nodeConfig,proto3,oneof"`
}

type ParacrossAction_NodeGroupConfig struct {
	NodeGroupConfig *ParaNodeGroupConfig `protobuf:"bytes,10,opt,name=nodeGroupConfig,proto3,oneof"`
}

func (*ParacrossAction_Commit) isParacrossAction_Value() {}

func (*ParacrossAction_Miner) isParacrossAction_Value() {}

func (*ParacrossAction_AssetTransfer) isParacrossAction_Value() {}

func (*ParacrossAction_AssetWithdraw) isParacrossAction_Value() {}

func (*ParacrossAction_Transfer) isParacrossAction_Value() {}

func (*ParacrossAction_Withdraw) isParacrossAction_Value() {}

func (*ParacrossAction_TransferToExec) isParacrossAction_Value() {}

func (*ParacrossAction_NodeConfig) isParacrossAction_Value() {}

func (*ParacrossAction_NodeGroupConfig) isParacrossAction_Value() {}

func (m *ParacrossAction) GetValue() isParacrossAction_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ParacrossAction) GetCommit() *ParacrossCommitAction {
	if x, ok := m.GetValue().(*ParacrossAction_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *ParacrossAction) GetMiner() *ParacrossMinerAction {
	if x, ok := m.GetValue().(*ParacrossAction_Miner); ok {
		return x.Miner
	}
	return nil
}

func (m *ParacrossAction) GetAssetTransfer() *types.AssetsTransfer {
	if x, ok := m.GetValue().(*ParacrossAction_AssetTransfer); ok {
		return x.AssetTransfer
	}
	return nil
}

func (m *ParacrossAction) GetAssetWithdraw() *types.AssetsWithdraw {
	if x, ok := m.GetValue().(*ParacrossAction_AssetWithdraw); ok {
		return x.AssetWithdraw
	}
	return nil
}

func (m *ParacrossAction) GetTransfer() *types.AssetsTransfer {
	if x, ok := m.GetValue().(*ParacrossAction_Transfer); ok {
		return x.Transfer
	}
	return nil
}

func (m *ParacrossAction) GetWithdraw() *types.AssetsWithdraw {
	if x, ok := m.GetValue().(*ParacrossAction_Withdraw); ok {
		return x.Withdraw
	}
	return nil
}

func (m *ParacrossAction) GetTransferToExec() *types.AssetsTransferToExec {
	if x, ok := m.GetValue().(*ParacrossAction_TransferToExec); ok {
		return x.TransferToExec
	}
	return nil
}

func (m *ParacrossAction) GetNodeConfig() *ParaNodeAddrConfig {
	if x, ok := m.GetValue().(*ParacrossAction_NodeConfig); ok {
		return x.NodeConfig
	}
	return nil
}

func (m *ParacrossAction) GetNodeGroupConfig() *ParaNodeGroupConfig {
	if x, ok := m.GetValue().(*ParacrossAction_NodeGroupConfig); ok {
		return x.NodeGroupConfig
	}
	return nil
}

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

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ParacrossAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ParacrossAction_OneofMarshaler, _ParacrossAction_OneofUnmarshaler, _ParacrossAction_OneofSizer, []interface{}{
		(*ParacrossAction_Commit)(nil),
		(*ParacrossAction_Miner)(nil),
		(*ParacrossAction_AssetTransfer)(nil),
		(*ParacrossAction_AssetWithdraw)(nil),
		(*ParacrossAction_Transfer)(nil),
		(*ParacrossAction_Withdraw)(nil),
		(*ParacrossAction_TransferToExec)(nil),
		(*ParacrossAction_NodeConfig)(nil),
		(*ParacrossAction_NodeGroupConfig)(nil),
	}
}

func _ParacrossAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ParacrossAction)
	// value
	switch x := m.Value.(type) {
	case *ParacrossAction_Commit:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Commit); err != nil {
			return err
		}
	case *ParacrossAction_Miner:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Miner); err != nil {
			return err
		}
	case *ParacrossAction_AssetTransfer:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AssetTransfer); err != nil {
			return err
		}
	case *ParacrossAction_AssetWithdraw:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.AssetWithdraw); err != nil {
			return err
		}
	case *ParacrossAction_Transfer:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Transfer); err != nil {
			return err
		}
	case *ParacrossAction_Withdraw:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Withdraw); err != nil {
			return err
		}
	case *ParacrossAction_TransferToExec:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TransferToExec); err != nil {
			return err
		}
	case *ParacrossAction_NodeConfig:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NodeConfig); err != nil {
			return err
		}
	case *ParacrossAction_NodeGroupConfig:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NodeGroupConfig); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ParacrossAction.Value has unexpected type %T", x)
	}
	return nil
}

func _ParacrossAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ParacrossAction)
	switch tag {
	case 1: // value.commit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ParacrossCommitAction)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_Commit{msg}
		return true, err
	case 3: // value.miner
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ParacrossMinerAction)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_Miner{msg}
		return true, err
	case 4: // value.assetTransfer
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.AssetsTransfer)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_AssetTransfer{msg}
		return true, err
	case 5: // value.assetWithdraw
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.AssetsWithdraw)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_AssetWithdraw{msg}
		return true, err
	case 6: // value.transfer
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.AssetsTransfer)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_Transfer{msg}
		return true, err
	case 7: // value.withdraw
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.AssetsWithdraw)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_Withdraw{msg}
		return true, err
	case 8: // value.transferToExec
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(types.AssetsTransferToExec)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_TransferToExec{msg}
		return true, err
	case 9: // value.nodeConfig
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ParaNodeAddrConfig)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_NodeConfig{msg}
		return true, err
	case 10: // value.nodeGroupConfig
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ParaNodeGroupConfig)
		err := b.DecodeMessage(msg)
		m.Value = &ParacrossAction_NodeGroupConfig{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ParacrossAction_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ParacrossAction)
	// value
	switch x := m.Value.(type) {
	case *ParacrossAction_Commit:
		s := proto.Size(x.Commit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_Miner:
		s := proto.Size(x.Miner)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_AssetTransfer:
		s := proto.Size(x.AssetTransfer)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_AssetWithdraw:
		s := proto.Size(x.AssetWithdraw)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_Transfer:
		s := proto.Size(x.Transfer)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_Withdraw:
		s := proto.Size(x.Withdraw)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_TransferToExec:
		s := proto.Size(x.TransferToExec)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_NodeConfig:
		s := proto.Size(x.NodeConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ParacrossAction_NodeGroupConfig:
		s := proto.Size(x.NodeGroupConfig)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// logs
type ReceiptParacrossCommit struct {
	Addr                 string                 `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Status               *ParacrossNodeStatus   `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	Prev                 *ParacrossHeightStatus `protobuf:"bytes,3,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *ParacrossHeightStatus `protobuf:"bytes,4,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *ReceiptParacrossCommit) Reset()         { *m = ReceiptParacrossCommit{} }
func (m *ReceiptParacrossCommit) String() string { return proto.CompactTextString(m) }
func (*ReceiptParacrossCommit) ProtoMessage()    {}
func (*ReceiptParacrossCommit) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{25}
}
func (m *ReceiptParacrossCommit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParacrossCommit.Unmarshal(m, b)
}
func (m *ReceiptParacrossCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParacrossCommit.Marshal(b, m, deterministic)
}
func (dst *ReceiptParacrossCommit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossCommit.Merge(dst, src)
}
func (m *ReceiptParacrossCommit) XXX_Size() int {
	return xxx_messageInfo_ReceiptParacrossCommit.Size(m)
}
func (m *ReceiptParacrossCommit) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParacrossCommit.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParacrossCommit proto.InternalMessageInfo

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

func (m *ReceiptParacrossCommit) GetStatus() *ParacrossNodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ReceiptParacrossCommit) GetPrev() *ParacrossHeightStatus {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParacrossCommit) GetCurrent() *ParacrossHeightStatus {
	if m != nil {
		return m.Current
	}
	return nil
}

type ReceiptParacrossMiner struct {
	Status               *ParacrossNodeStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ReceiptParacrossMiner) Reset()         { *m = ReceiptParacrossMiner{} }
func (m *ReceiptParacrossMiner) String() string { return proto.CompactTextString(m) }
func (*ReceiptParacrossMiner) ProtoMessage()    {}
func (*ReceiptParacrossMiner) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{26}
}
func (m *ReceiptParacrossMiner) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParacrossMiner.Unmarshal(m, b)
}
func (m *ReceiptParacrossMiner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParacrossMiner.Marshal(b, m, deterministic)
}
func (dst *ReceiptParacrossMiner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossMiner.Merge(dst, src)
}
func (m *ReceiptParacrossMiner) XXX_Size() int {
	return xxx_messageInfo_ReceiptParacrossMiner.Size(m)
}
func (m *ReceiptParacrossMiner) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParacrossMiner.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParacrossMiner proto.InternalMessageInfo

func (m *ReceiptParacrossMiner) GetStatus() *ParacrossNodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type ReceiptParacrossDone struct {
	TotalNodes           int32    `protobuf:"varint,1,opt,name=totalNodes,proto3" json:"totalNodes,omitempty"`
	TotalCommit          int32    `protobuf:"varint,2,opt,name=totalCommit,proto3" json:"totalCommit,omitempty"`
	MostSameCommit       int32    `protobuf:"varint,3,opt,name=mostSameCommit,proto3" json:"mostSameCommit,omitempty"`
	Title                string   `protobuf:"bytes,4,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,5,opt,name=height,proto3" json:"height,omitempty"`
	StateHash            []byte   `protobuf:"bytes,6,opt,name=stateHash,proto3" json:"stateHash,omitempty"`
	TxCounts             uint32   `protobuf:"varint,7,opt,name=txCounts,proto3" json:"txCounts,omitempty"`
	TxResult             []byte   `protobuf:"bytes,8,opt,name=txResult,proto3" json:"txResult,omitempty"`
	BlockHash            []byte   `protobuf:"bytes,9,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	TxHashs              [][]byte `protobuf:"bytes,10,rep,name=txHashs,proto3" json:"txHashs,omitempty"`
	CrossTxResult        []byte   `protobuf:"bytes,11,opt,name=crossTxResult,proto3" json:"crossTxResult,omitempty"`
	CrossTxHashs         [][]byte `protobuf:"bytes,12,rep,name=crossTxHashs,proto3" json:"crossTxHashs,omitempty"`
	MainBlockHash        []byte   `protobuf:"bytes,13,opt,name=mainBlockHash,proto3" json:"mainBlockHash,omitempty"`
	MainBlockHeight      int64    `protobuf:"varint,14,opt,name=mainBlockHeight,proto3" json:"mainBlockHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReceiptParacrossDone) Reset()         { *m = ReceiptParacrossDone{} }
func (m *ReceiptParacrossDone) String() string { return proto.CompactTextString(m) }
func (*ReceiptParacrossDone) ProtoMessage()    {}
func (*ReceiptParacrossDone) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{27}
}
func (m *ReceiptParacrossDone) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParacrossDone.Unmarshal(m, b)
}
func (m *ReceiptParacrossDone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParacrossDone.Marshal(b, m, deterministic)
}
func (dst *ReceiptParacrossDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossDone.Merge(dst, src)
}
func (m *ReceiptParacrossDone) XXX_Size() int {
	return xxx_messageInfo_ReceiptParacrossDone.Size(m)
}
func (m *ReceiptParacrossDone) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParacrossDone.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParacrossDone proto.InternalMessageInfo

func (m *ReceiptParacrossDone) GetTotalNodes() int32 {
	if m != nil {
		return m.TotalNodes
	}
	return 0
}

func (m *ReceiptParacrossDone) GetTotalCommit() int32 {
	if m != nil {
		return m.TotalCommit
	}
	return 0
}

func (m *ReceiptParacrossDone) GetMostSameCommit() int32 {
	if m != nil {
		return m.MostSameCommit
	}
	return 0
}

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

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

func (m *ReceiptParacrossDone) GetStateHash() []byte {
	if m != nil {
		return m.StateHash
	}
	return nil
}

func (m *ReceiptParacrossDone) GetTxCounts() uint32 {
	if m != nil {
		return m.TxCounts
	}
	return 0
}

func (m *ReceiptParacrossDone) GetTxResult() []byte {
	if m != nil {
		return m.TxResult
	}
	return nil
}

func (m *ReceiptParacrossDone) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

func (m *ReceiptParacrossDone) GetTxHashs() [][]byte {
	if m != nil {
		return m.TxHashs
	}
	return nil
}

func (m *ReceiptParacrossDone) GetCrossTxResult() []byte {
	if m != nil {
		return m.CrossTxResult
	}
	return nil
}

func (m *ReceiptParacrossDone) GetCrossTxHashs() [][]byte {
	if m != nil {
		return m.CrossTxHashs
	}
	return nil
}

func (m *ReceiptParacrossDone) GetMainBlockHash() []byte {
	if m != nil {
		return m.MainBlockHash
	}
	return nil
}

func (m *ReceiptParacrossDone) GetMainBlockHeight() int64 {
	if m != nil {
		return m.MainBlockHeight
	}
	return 0
}

type ReceiptParacrossRecord struct {
	Addr                 string               `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Status               *ParacrossNodeStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ReceiptParacrossRecord) Reset()         { *m = ReceiptParacrossRecord{} }
func (m *ReceiptParacrossRecord) String() string { return proto.CompactTextString(m) }
func (*ReceiptParacrossRecord) ProtoMessage()    {}
func (*ReceiptParacrossRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{28}
}
func (m *ReceiptParacrossRecord) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReceiptParacrossRecord.Unmarshal(m, b)
}
func (m *ReceiptParacrossRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReceiptParacrossRecord.Marshal(b, m, deterministic)
}
func (dst *ReceiptParacrossRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossRecord.Merge(dst, src)
}
func (m *ReceiptParacrossRecord) XXX_Size() int {
	return xxx_messageInfo_ReceiptParacrossRecord.Size(m)
}
func (m *ReceiptParacrossRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ReceiptParacrossRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ReceiptParacrossRecord proto.InternalMessageInfo

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

func (m *ReceiptParacrossRecord) GetStatus() *ParacrossNodeStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

// LocalDB
// title-height-addr : txHash
type ParacrossTx struct {
	TxHash               string   `protobuf:"bytes,1,opt,name=txHash,proto3" json:"txHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossTx) Reset()         { *m = ParacrossTx{} }
func (m *ParacrossTx) String() string { return proto.CompactTextString(m) }
func (*ParacrossTx) ProtoMessage()    {}
func (*ParacrossTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{29}
}
func (m *ParacrossTx) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossTx.Unmarshal(m, b)
}
func (m *ParacrossTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossTx.Marshal(b, m, deterministic)
}
func (dst *ParacrossTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossTx.Merge(dst, src)
}
func (m *ParacrossTx) XXX_Size() int {
	return xxx_messageInfo_ParacrossTx.Size(m)
}
func (m *ParacrossTx) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossTx.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossTx proto.InternalMessageInfo

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

// query
type ReqParacrossTitleHeight struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqParacrossTitleHeight) Reset()         { *m = ReqParacrossTitleHeight{} }
func (m *ReqParacrossTitleHeight) String() string { return proto.CompactTextString(m) }
func (*ReqParacrossTitleHeight) ProtoMessage()    {}
func (*ReqParacrossTitleHeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{30}
}
func (m *ReqParacrossTitleHeight) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqParacrossTitleHeight.Unmarshal(m, b)
}
func (m *ReqParacrossTitleHeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqParacrossTitleHeight.Marshal(b, m, deterministic)
}
func (dst *ReqParacrossTitleHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossTitleHeight.Merge(dst, src)
}
func (m *ReqParacrossTitleHeight) XXX_Size() int {
	return xxx_messageInfo_ReqParacrossTitleHeight.Size(m)
}
func (m *ReqParacrossTitleHeight) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqParacrossTitleHeight.DiscardUnknown(m)
}

var xxx_messageInfo_ReqParacrossTitleHeight proto.InternalMessageInfo

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

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

type RespParacrossDone struct {
	TotalNodes           int32    `protobuf:"varint,1,opt,name=totalNodes,proto3" json:"totalNodes,omitempty"`
	TotalCommit          int32    `protobuf:"varint,2,opt,name=totalCommit,proto3" json:"totalCommit,omitempty"`
	MostSameCommit       int32    `protobuf:"varint,3,opt,name=mostSameCommit,proto3" json:"mostSameCommit,omitempty"`
	Title                string   `protobuf:"bytes,4,opt,name=title,proto3" json:"title,omitempty"`
	Height               int64    `protobuf:"varint,5,opt,name=height,proto3" json:"height,omitempty"`
	StateHash            string   `protobuf:"bytes,6,opt,name=stateHash,proto3" json:"stateHash,omitempty"`
	TxCounts             uint32   `protobuf:"varint,7,opt,name=txCounts,proto3" json:"txCounts,omitempty"`
	TxResult             string   `protobuf:"bytes,8,opt,name=txResult,proto3" json:"txResult,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RespParacrossDone) Reset()         { *m = RespParacrossDone{} }
func (m *RespParacrossDone) String() string { return proto.CompactTextString(m) }
func (*RespParacrossDone) ProtoMessage()    {}
func (*RespParacrossDone) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{31}
}
func (m *RespParacrossDone) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RespParacrossDone.Unmarshal(m, b)
}
func (m *RespParacrossDone) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RespParacrossDone.Marshal(b, m, deterministic)
}
func (dst *RespParacrossDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossDone.Merge(dst, src)
}
func (m *RespParacrossDone) XXX_Size() int {
	return xxx_messageInfo_RespParacrossDone.Size(m)
}
func (m *RespParacrossDone) XXX_DiscardUnknown() {
	xxx_messageInfo_RespParacrossDone.DiscardUnknown(m)
}

var xxx_messageInfo_RespParacrossDone proto.InternalMessageInfo

func (m *RespParacrossDone) GetTotalNodes() int32 {
	if m != nil {
		return m.TotalNodes
	}
	return 0
}

func (m *RespParacrossDone) GetTotalCommit() int32 {
	if m != nil {
		return m.TotalCommit
	}
	return 0
}

func (m *RespParacrossDone) GetMostSameCommit() int32 {
	if m != nil {
		return m.MostSameCommit
	}
	return 0
}

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

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

func (m *RespParacrossDone) GetStateHash() string {
	if m != nil {
		return m.StateHash
	}
	return ""
}

func (m *RespParacrossDone) GetTxCounts() uint32 {
	if m != nil {
		return m.TxCounts
	}
	return 0
}

func (m *RespParacrossDone) GetTxResult() string {
	if m != nil {
		return m.TxResult
	}
	return ""
}

type RespParacrossTitles struct {
	Titles               []*RespParacrossDone `protobuf:"bytes,1,rep,name=titles,proto3" json:"titles,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *RespParacrossTitles) Reset()         { *m = RespParacrossTitles{} }
func (m *RespParacrossTitles) String() string { return proto.CompactTextString(m) }
func (*RespParacrossTitles) ProtoMessage()    {}
func (*RespParacrossTitles) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{32}
}
func (m *RespParacrossTitles) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RespParacrossTitles.Unmarshal(m, b)
}
func (m *RespParacrossTitles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RespParacrossTitles.Marshal(b, m, deterministic)
}
func (dst *RespParacrossTitles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossTitles.Merge(dst, src)
}
func (m *RespParacrossTitles) XXX_Size() int {
	return xxx_messageInfo_RespParacrossTitles.Size(m)
}
func (m *RespParacrossTitles) XXX_DiscardUnknown() {
	xxx_messageInfo_RespParacrossTitles.DiscardUnknown(m)
}

var xxx_messageInfo_RespParacrossTitles proto.InternalMessageInfo

func (m *RespParacrossTitles) GetTitles() []*RespParacrossDone {
	if m != nil {
		return m.Titles
	}
	return nil
}

type ReqParacrossTitleHash struct {
	Title                string   `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	BlockHash            []byte   `protobuf:"bytes,2,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReqParacrossTitleHash) Reset()         { *m = ReqParacrossTitleHash{} }
func (m *ReqParacrossTitleHash) String() string { return proto.CompactTextString(m) }
func (*ReqParacrossTitleHash) ProtoMessage()    {}
func (*ReqParacrossTitleHash) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{33}
}
func (m *ReqParacrossTitleHash) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReqParacrossTitleHash.Unmarshal(m, b)
}
func (m *ReqParacrossTitleHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReqParacrossTitleHash.Marshal(b, m, deterministic)
}
func (dst *ReqParacrossTitleHash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossTitleHash.Merge(dst, src)
}
func (m *ReqParacrossTitleHash) XXX_Size() int {
	return xxx_messageInfo_ReqParacrossTitleHash.Size(m)
}
func (m *ReqParacrossTitleHash) XXX_DiscardUnknown() {
	xxx_messageInfo_ReqParacrossTitleHash.DiscardUnknown(m)
}

var xxx_messageInfo_ReqParacrossTitleHash proto.InternalMessageInfo

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

func (m *ReqParacrossTitleHash) GetBlockHash() []byte {
	if m != nil {
		return m.BlockHash
	}
	return nil
}

// 跨链转账相关
type ParacrossAsset struct {
	// input
	From       string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	To         string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
	IsWithdraw bool   `protobuf:"varint,3,opt,name=isWithdraw,proto3" json:"isWithdraw,omitempty"`
	TxHash     []byte `protobuf:"bytes,4,opt,name=txHash,proto3" json:"txHash,omitempty"`
	Amount     int64  `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty"`
	Exec       string `protobuf:"bytes,6,opt,name=exec,proto3" json:"exec,omitempty"`
	Symbol     string `protobuf:"bytes,7,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// 主链部分
	Height int64 `protobuf:"varint,10,opt,name=height,proto3" json:"height,omitempty"`
	// 平行链部分
	CommitDoneHeight     int64    `protobuf:"varint,21,opt,name=commitDoneHeight,proto3" json:"commitDoneHeight,omitempty"`
	ParaHeight           int64    `protobuf:"varint,22,opt,name=paraHeight,proto3" json:"paraHeight,omitempty"`
	Success              bool     `protobuf:"varint,23,opt,name=success,proto3" json:"success,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParacrossAsset) Reset()         { *m = ParacrossAsset{} }
func (m *ParacrossAsset) String() string { return proto.CompactTextString(m) }
func (*ParacrossAsset) ProtoMessage()    {}
func (*ParacrossAsset) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{34}
}
func (m *ParacrossAsset) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParacrossAsset.Unmarshal(m, b)
}
func (m *ParacrossAsset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParacrossAsset.Marshal(b, m, deterministic)
}
func (dst *ParacrossAsset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossAsset.Merge(dst, src)
}
func (m *ParacrossAsset) XXX_Size() int {
	return xxx_messageInfo_ParacrossAsset.Size(m)
}
func (m *ParacrossAsset) XXX_DiscardUnknown() {
	xxx_messageInfo_ParacrossAsset.DiscardUnknown(m)
}

var xxx_messageInfo_ParacrossAsset proto.InternalMessageInfo

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

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

func (m *ParacrossAsset) GetIsWithdraw() bool {
	if m != nil {
		return m.IsWithdraw
	}
	return false
}

func (m *ParacrossAsset) GetTxHash() []byte {
	if m != nil {
		return m.TxHash
	}
	return nil
}

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

func (m *ParacrossAsset) GetExec() string {
	if m != nil {
		return m.Exec
	}
	return ""
}

func (m *ParacrossAsset) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

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

func (m *ParacrossAsset) GetCommitDoneHeight() int64 {
	if m != nil {
		return m.CommitDoneHeight
	}
	return 0
}

func (m *ParacrossAsset) GetParaHeight() int64 {
	if m != nil {
		return m.ParaHeight
	}
	return 0
}

func (m *ParacrossAsset) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

type ParaLocalDbBlock struct {
	Height               int64                `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	MainHash             []byte               `protobuf:"bytes,2,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	MainHeight           int64                `protobuf:"varint,3,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	ParentMainHash       []byte               `protobuf:"bytes,4,opt,name=parentMainHash,proto3" json:"parentMainHash,omitempty"`
	BlockTime            int64                `protobuf:"varint,5,opt,name=blockTime,proto3" json:"blockTime,omitempty"`
	Txs                  []*types.Transaction `protobuf:"bytes,6,rep,name=txs,proto3" json:"txs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *ParaLocalDbBlock) Reset()         { *m = ParaLocalDbBlock{} }
func (m *ParaLocalDbBlock) String() string { return proto.CompactTextString(m) }
func (*ParaLocalDbBlock) ProtoMessage()    {}
func (*ParaLocalDbBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{35}
}
func (m *ParaLocalDbBlock) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaLocalDbBlock.Unmarshal(m, b)
}
func (m *ParaLocalDbBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaLocalDbBlock.Marshal(b, m, deterministic)
}
func (dst *ParaLocalDbBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaLocalDbBlock.Merge(dst, src)
}
func (m *ParaLocalDbBlock) XXX_Size() int {
	return xxx_messageInfo_ParaLocalDbBlock.Size(m)
}
func (m *ParaLocalDbBlock) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaLocalDbBlock.DiscardUnknown(m)
}

var xxx_messageInfo_ParaLocalDbBlock proto.InternalMessageInfo

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

func (m *ParaLocalDbBlock) GetMainHash() []byte {
	if m != nil {
		return m.MainHash
	}
	return nil
}

func (m *ParaLocalDbBlock) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParaLocalDbBlock) GetParentMainHash() []byte {
	if m != nil {
		return m.ParentMainHash
	}
	return nil
}

func (m *ParaLocalDbBlock) GetBlockTime() int64 {
	if m != nil {
		return m.BlockTime
	}
	return 0
}

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

type ParaLocalDbBlockInfo struct {
	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	MainHash             string   `protobuf:"bytes,2,opt,name=mainHash,proto3" json:"mainHash,omitempty"`
	MainHeight           int64    `protobuf:"varint,3,opt,name=mainHeight,proto3" json:"mainHeight,omitempty"`
	ParentMainHash       string   `protobuf:"bytes,4,opt,name=parentMainHash,proto3" json:"parentMainHash,omitempty"`
	BlockTime            int64    `protobuf:"varint,5,opt,name=blockTime,proto3" json:"blockTime,omitempty"`
	Txs                  []string `protobuf:"bytes,6,rep,name=txs,proto3" json:"txs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParaLocalDbBlockInfo) Reset()         { *m = ParaLocalDbBlockInfo{} }
func (m *ParaLocalDbBlockInfo) String() string { return proto.CompactTextString(m) }
func (*ParaLocalDbBlockInfo) ProtoMessage()    {}
func (*ParaLocalDbBlockInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_paracross_dcd1b923b8f04760, []int{36}
}
func (m *ParaLocalDbBlockInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParaLocalDbBlockInfo.Unmarshal(m, b)
}
func (m *ParaLocalDbBlockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParaLocalDbBlockInfo.Marshal(b, m, deterministic)
}
func (dst *ParaLocalDbBlockInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaLocalDbBlockInfo.Merge(dst, src)
}
func (m *ParaLocalDbBlockInfo) XXX_Size() int {
	return xxx_messageInfo_ParaLocalDbBlockInfo.Size(m)
}
func (m *ParaLocalDbBlockInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ParaLocalDbBlockInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ParaLocalDbBlockInfo proto.InternalMessageInfo

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

func (m *ParaLocalDbBlockInfo) GetMainHash() string {
	if m != nil {
		return m.MainHash
	}
	return ""
}

func (m *ParaLocalDbBlockInfo) GetMainHeight() int64 {
	if m != nil {
		return m.MainHeight
	}
	return 0
}

func (m *ParaLocalDbBlockInfo) GetParentMainHash() string {
	if m != nil {
		return m.ParentMainHash
	}
	return ""
}

func (m *ParaLocalDbBlockInfo) GetBlockTime() int64 {
	if m != nil {
		return m.BlockTime
	}
	return 0
}

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

func init() {
	proto.RegisterType((*ParacrossStatusDetails)(nil), "types.ParacrossStatusDetails")
	proto.RegisterType((*ParacrossStatusBlockDetails)(nil), "types.ParacrossStatusBlockDetails")
	proto.RegisterType((*ParacrossHeightStatus)(nil), "types.ParacrossHeightStatus")
	proto.RegisterType((*ParacrossHeightStatusRsp)(nil), "types.ParacrossHeightStatusRsp")
	proto.RegisterType((*ParacrossStatus)(nil), "types.ParacrossStatus")
	proto.RegisterType((*ParacrossConsensusStatus)(nil), "types.ParacrossConsensusStatus")
	proto.RegisterType((*ParaNodeAddrConfig)(nil), "types.ParaNodeAddrConfig")
	proto.RegisterType((*ParaNodeVoteDetail)(nil), "types.ParaNodeVoteDetail")
	proto.RegisterType((*ParaNodeAddrIdStatus)(nil), "types.ParaNodeAddrIdStatus")
	proto.RegisterType((*ParaNodeIdStatus)(nil), "types.ParaNodeIdStatus")
	proto.RegisterType((*ReceiptParaNodeConfig)(nil), "types.ReceiptParaNodeConfig")
	proto.RegisterType((*ReceiptParaNodeAddrStatUpdate)(nil), "types.ReceiptParaNodeAddrStatUpdate")
	proto.RegisterType((*ReceiptParaNodeVoteDone)(nil), "types.ReceiptParaNodeVoteDone")
	proto.RegisterType((*ParaNodeGroupConfig)(nil), "types.ParaNodeGroupConfig")
	proto.RegisterType((*ParaNodeGroupStatus)(nil), "types.ParaNodeGroupStatus")
	proto.RegisterType((*ReceiptParaNodeGroupConfig)(nil), "types.ReceiptParaNodeGroupConfig")
	proto.RegisterType((*ReqParacrossNodeInfo)(nil), "types.ReqParacrossNodeInfo")
	proto.RegisterType((*RespParacrossNodeAddrs)(nil), "types.RespParacrossNodeAddrs")
	proto.RegisterType((*RespParacrossNodeGroups)(nil), "types.RespParacrossNodeGroups")
	proto.RegisterType((*ParaBlock2MainMap)(nil), "types.ParaBlock2MainMap")
	proto.RegisterType((*ParaBlock2MainInfo)(nil), "types.ParaBlock2MainInfo")
	proto.RegisterType((*ParacrossNodeStatus)(nil), "types.ParacrossNodeStatus")
	proto.RegisterType((*ParacrossCommitAction)(nil), "types.ParacrossCommitAction")
	proto.RegisterType((*ParacrossMinerAction)(nil), "types.ParacrossMinerAction")
	proto.RegisterType((*ParacrossAction)(nil), "types.ParacrossAction")
	proto.RegisterType((*ReceiptParacrossCommit)(nil), "types.ReceiptParacrossCommit")
	proto.RegisterType((*ReceiptParacrossMiner)(nil), "types.ReceiptParacrossMiner")
	proto.RegisterType((*ReceiptParacrossDone)(nil), "types.ReceiptParacrossDone")
	proto.RegisterType((*ReceiptParacrossRecord)(nil), "types.ReceiptParacrossRecord")
	proto.RegisterType((*ParacrossTx)(nil), "types.ParacrossTx")
	proto.RegisterType((*ReqParacrossTitleHeight)(nil), "types.ReqParacrossTitleHeight")
	proto.RegisterType((*RespParacrossDone)(nil), "types.RespParacrossDone")
	proto.RegisterType((*RespParacrossTitles)(nil), "types.RespParacrossTitles")
	proto.RegisterType((*ReqParacrossTitleHash)(nil), "types.ReqParacrossTitleHash")
	proto.RegisterType((*ParacrossAsset)(nil), "types.ParacrossAsset")
	proto.RegisterType((*ParaLocalDbBlock)(nil), "types.ParaLocalDbBlock")
	proto.RegisterType((*ParaLocalDbBlockInfo)(nil), "types.ParaLocalDbBlockInfo")
}

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

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

// ParacrossClient is the client API for Paracross service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ParacrossClient interface {
	GetTitle(ctx context.Context, in *types.ReqString, opts ...grpc.CallOption) (*ParacrossConsensusStatus, error)
	ListTitles(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*RespParacrossTitles, error)
	GetDoneTitleHeight(ctx context.Context, in *ReqParacrossTitleHeight, opts ...grpc.CallOption) (*RespParacrossDone, error)
	GetTitleHeight(ctx context.Context, in *ReqParacrossTitleHeight, opts ...grpc.CallOption) (*ParacrossHeightStatusRsp, error)
	GetAssetTxResult(ctx context.Context, in *types.ReqHash, opts ...grpc.CallOption) (*ParacrossAsset, error)
	IsSync(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.IsCaughtUp, error)
}

type paracrossClient struct {
	cc *grpc.ClientConn
}

func NewParacrossClient(cc *grpc.ClientConn) ParacrossClient {
	return &paracrossClient{cc}
}

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

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

func (c *paracrossClient) GetDoneTitleHeight(ctx context.Context, in *ReqParacrossTitleHeight, opts ...grpc.CallOption) (*RespParacrossDone, error) {
	out := new(RespParacrossDone)
	err := c.cc.Invoke(ctx, "/types.paracross/GetDoneTitleHeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *paracrossClient) GetTitleHeight(ctx context.Context, in *ReqParacrossTitleHeight, opts ...grpc.CallOption) (*ParacrossHeightStatusRsp, error) {
	out := new(ParacrossHeightStatusRsp)
	err := c.cc.Invoke(ctx, "/types.paracross/GetTitleHeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *paracrossClient) GetAssetTxResult(ctx context.Context, in *types.ReqHash, opts ...grpc.CallOption) (*ParacrossAsset, error) {
	out := new(ParacrossAsset)
	err := c.cc.Invoke(ctx, "/types.paracross/GetAssetTxResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

// ParacrossServer is the server API for Paracross service.
type ParacrossServer interface {
	GetTitle(context.Context, *types.ReqString) (*ParacrossConsensusStatus, error)
	ListTitles(context.Context, *types.ReqNil) (*RespParacrossTitles, error)
	GetDoneTitleHeight(context.Context, *ReqParacrossTitleHeight) (*RespParacrossDone, error)
	GetTitleHeight(context.Context, *ReqParacrossTitleHeight) (*ParacrossHeightStatusRsp, error)
	GetAssetTxResult(context.Context, *types.ReqHash) (*ParacrossAsset, error)
	IsSync(context.Context, *types.ReqNil) (*types.IsCaughtUp, error)
}

func RegisterParacrossServer(s *grpc.Server, srv ParacrossServer) {
	s.RegisterService(&_Paracross_serviceDesc, srv)
}

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

func _Paracross_ListTitles_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.(ParacrossServer).ListTitles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.paracross/ListTitles",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParacrossServer).ListTitles(ctx, req.(*types.ReqNil))
	}
	return interceptor(ctx, in, info, handler)
}

func _Paracross_GetDoneTitleHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqParacrossTitleHeight)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParacrossServer).GetDoneTitleHeight(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.paracross/GetDoneTitleHeight",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParacrossServer).GetDoneTitleHeight(ctx, req.(*ReqParacrossTitleHeight))
	}
	return interceptor(ctx, in, info, handler)
}

func _Paracross_GetTitleHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReqParacrossTitleHeight)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParacrossServer).GetTitleHeight(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.paracross/GetTitleHeight",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParacrossServer).GetTitleHeight(ctx, req.(*ReqParacrossTitleHeight))
	}
	return interceptor(ctx, in, info, handler)
}

func _Paracross_GetAssetTxResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.ReqHash)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ParacrossServer).GetAssetTxResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.paracross/GetAssetTxResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParacrossServer).GetAssetTxResult(ctx, req.(*types.ReqHash))
	}
	return interceptor(ctx, in, info, handler)
}

func _Paracross_IsSync_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.(ParacrossServer).IsSync(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.paracross/IsSync",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ParacrossServer).IsSync(ctx, req.(*types.ReqNil))
	}
	return interceptor(ctx, in, info, handler)
}

var _Paracross_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.paracross",
	HandlerType: (*ParacrossServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetTitle",
			Handler:    _Paracross_GetTitle_Handler,
		},
		{
			MethodName: "ListTitles",
			Handler:    _Paracross_ListTitles_Handler,
		},
		{
			MethodName: "GetDoneTitleHeight",
			Handler:    _Paracross_GetDoneTitleHeight_Handler,
		},
		{
			MethodName: "GetTitleHeight",
			Handler:    _Paracross_GetTitleHeight_Handler,
		},
		{
			MethodName: "GetAssetTxResult",
			Handler:    _Paracross_GetAssetTxResult_Handler,
		},
		{
			MethodName: "IsSync",
			Handler:    _Paracross_IsSync_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "paracross.proto",
}

func init() { proto.RegisterFile("paracross.proto", fileDescriptor_paracross_dcd1b923b8f04760) }

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