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

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/33cn/chain33/types"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

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

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

// 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_6a397e38c9ea6747, []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 (m *ParacrossStatusDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatusDetails.Merge(m, 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_6a397e38c9ea6747, []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 (m *ParacrossStatusBlockDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatusBlockDetails.Merge(m, 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"`
	SupervisionDetails   *ParacrossStatusDetails      `protobuf:"bytes,8,opt,name=supervisionDetails,proto3" json:"supervisionDetails,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_6a397e38c9ea6747, []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 (m *ParacrossHeightStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossHeightStatus.Merge(m, 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
}

func (m *ParacrossHeightStatus) GetSupervisionDetails() *ParacrossStatusDetails {
	if m != nil {
		return m.SupervisionDetails
	}
	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"`
	CommitSupervisionAddrs     []string `protobuf:"bytes,8,rep,name=commitSupervisionAddrs,proto3" json:"commitSupervisionAddrs,omitempty"`
	CommitSupervisionBlockHash []string `protobuf:"bytes,9,rep,name=commitSupervisionBlockHash,proto3" json:"commitSupervisionBlockHash,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_6a397e38c9ea6747, []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 (m *ParacrossHeightStatusRsp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossHeightStatusRsp.Merge(m, 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
}

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

func (m *ParacrossHeightStatusRsp) GetCommitSupervisionBlockHash() []string {
	if m != nil {
		return m.CommitSupervisionBlockHash
	}
	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_6a397e38c9ea6747, []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 (m *ParacrossStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossStatus.Merge(m, 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_6a397e38c9ea6747, []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 (m *ParacrossConsensusStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossConsensusStatus.Merge(m, 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"`
	BlsPubKey            string   `protobuf:"bytes,7,opt,name=blsPubKey,proto3" json:"blsPubKey,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_6a397e38c9ea6747, []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 (m *ParaNodeAddrConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeAddrConfig.Merge(m, 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
}

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

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_6a397e38c9ea6747, []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 (m *ParaNodeVoteDetail) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeVoteDetail.Merge(m, 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"`
	BlsPubKey            string   `protobuf:"bytes,6,opt,name=blsPubKey,proto3" json:"blsPubKey,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_6a397e38c9ea6747, []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 (m *ParaNodeAddrIdStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeAddrIdStatus.Merge(m, 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 ""
}

func (m *ParaNodeAddrIdStatus) GetBlsPubKey() string {
	if m != nil {
		return m.BlsPubKey
	}
	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"`
	BlsPubKey            string              `protobuf:"bytes,9,opt,name=blsPubKey,proto3" json:"blsPubKey,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_6a397e38c9ea6747, []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 (m *ParaNodeIdStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeIdStatus.Merge(m, 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
}

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

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_6a397e38c9ea6747, []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 (m *ReceiptParaNodeConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeConfig.Merge(m, 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_6a397e38c9ea6747, []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 (m *ReceiptParaNodeAddrStatUpdate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeAddrStatUpdate.Merge(m, 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_6a397e38c9ea6747, []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 (m *ReceiptParaNodeVoteDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeVoteDone.Merge(m, 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"`
	BlsPubKeys           string   `protobuf:"bytes,6,opt,name=blsPubKeys,proto3" json:"blsPubKeys,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_6a397e38c9ea6747, []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 (m *ParaNodeGroupConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeGroupConfig.Merge(m, 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
}

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

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"`
	BlsPubKeys           string   `protobuf:"bytes,8,opt,name=blsPubKeys,proto3" json:"blsPubKeys,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_6a397e38c9ea6747, []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 (m *ParaNodeGroupStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaNodeGroupStatus.Merge(m, 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
}

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

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_6a397e38c9ea6747, []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 (m *ReceiptParaNodeGroupConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParaNodeGroupConfig.Merge(m, 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"`
	BlsPubKey            string   `protobuf:"bytes,5,opt,name=blsPubKey,proto3" json:"blsPubKey,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_6a397e38c9ea6747, []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 (m *ReqParacrossNodeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossNodeInfo.Merge(m, 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
}

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

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_6a397e38c9ea6747, []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 (m *RespParacrossNodeAddrs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossNodeAddrs.Merge(m, 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_6a397e38c9ea6747, []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 (m *RespParacrossNodeGroups) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossNodeGroups.Merge(m, 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
}

//para bind miner
type ParaBindMinerCmd struct {
	BindAction           int32    `protobuf:"varint,1,opt,name=bindAction,proto3" json:"bindAction,omitempty"`
	BindCoins            int64    `protobuf:"varint,2,opt,name=bindCoins,proto3" json:"bindCoins,omitempty"`
	TargetNode           string   `protobuf:"bytes,3,opt,name=targetNode,proto3" json:"targetNode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParaBindMinerCmd proto.InternalMessageInfo

func (m *ParaBindMinerCmd) GetBindAction() int32 {
	if m != nil {
		return m.BindAction
	}
	return 0
}

func (m *ParaBindMinerCmd) GetBindCoins() int64 {
	if m != nil {
		return m.BindCoins
	}
	return 0
}

func (m *ParaBindMinerCmd) GetTargetNode() string {
	if m != nil {
		return m.TargetNode
	}
	return ""
}

type ParaBindMinerInfo struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	BindStatus           int32    `protobuf:"varint,2,opt,name=bindStatus,proto3" json:"bindStatus,omitempty"`
	BindCoins            int64    `protobuf:"varint,3,opt,name=bindCoins,proto3" json:"bindCoins,omitempty"`
	TargetNode           string   `protobuf:"bytes,4,opt,name=targetNode,proto3" json:"targetNode,omitempty"`
	BlockTime            int64    `protobuf:"varint,5,opt,name=blockTime,proto3" json:"blockTime,omitempty"`
	BlockHeight          int64    `protobuf:"varint,6,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParaBindMinerInfo proto.InternalMessageInfo

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

func (m *ParaBindMinerInfo) GetBindStatus() int32 {
	if m != nil {
		return m.BindStatus
	}
	return 0
}

func (m *ParaBindMinerInfo) GetBindCoins() int64 {
	if m != nil {
		return m.BindCoins
	}
	return 0
}

func (m *ParaBindMinerInfo) GetTargetNode() string {
	if m != nil {
		return m.TargetNode
	}
	return ""
}

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

func (m *ParaBindMinerInfo) GetBlockHeight() int64 {
	if m != nil {
		return m.BlockHeight
	}
	return 0
}

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

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

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

var xxx_messageInfo_ReceiptParaBindMinerInfo proto.InternalMessageInfo

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

func (m *ReceiptParaBindMinerInfo) GetPrev() *ParaBindMinerInfo {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParaBindMinerInfo) GetCurrent() *ParaBindMinerInfo {
	if m != nil {
		return m.Current
	}
	return nil
}

type ParaNodeBindOne struct {
	SuperNode            string   `protobuf:"bytes,1,opt,name=superNode,proto3" json:"superNode,omitempty"`
	Miner                string   `protobuf:"bytes,2,opt,name=miner,proto3" json:"miner,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParaNodeBindOne proto.InternalMessageInfo

func (m *ParaNodeBindOne) GetSuperNode() string {
	if m != nil {
		return m.SuperNode
	}
	return ""
}

func (m *ParaNodeBindOne) GetMiner() string {
	if m != nil {
		return m.Miner
	}
	return ""
}

type ParaNodeBindList struct {
	Title                string             `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Miners               []*ParaNodeBindOne `protobuf:"bytes,2,rep,name=miners,proto3" json:"miners,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_ParaNodeBindList proto.InternalMessageInfo

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

func (m *ParaNodeBindList) GetMiners() []*ParaNodeBindOne {
	if m != nil {
		return m.Miners
	}
	return nil
}

type ReceiptParaNodeBindListUpdate struct {
	Prev                 *ParaNodeBindList `protobuf:"bytes,1,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *ParaNodeBindList `protobuf:"bytes,2,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_ReceiptParaNodeBindListUpdate proto.InternalMessageInfo

func (m *ReceiptParaNodeBindListUpdate) GetPrev() *ParaNodeBindList {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptParaNodeBindListUpdate) GetCurrent() *ParaNodeBindList {
	if m != nil {
		return m.Current
	}
	return nil
}

type RespParaNodeBindList struct {
	List                 *ParaNodeBindList    `protobuf:"bytes,1,opt,name=list,proto3" json:"list,omitempty"`
	Details              []*ParaBindMinerInfo `protobuf:"bytes,2,rep,name=details,proto3" json:"details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_RespParaNodeBindList proto.InternalMessageInfo

func (m *RespParaNodeBindList) GetList() *ParaNodeBindList {
	if m != nil {
		return m.List
	}
	return nil
}

func (m *RespParaNodeBindList) GetDetails() []*ParaBindMinerInfo {
	if m != nil {
		return m.Details
	}
	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_6a397e38c9ea6747, []int{26}
}

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 (m *ParaBlock2MainMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaBlock2MainMap.Merge(m, 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_6a397e38c9ea6747, []int{27}
}

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 (m *ParaBlock2MainInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaBlock2MainInfo.Merge(m, 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_6a397e38c9ea6747, []int{28}
}

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 (m *ParacrossNodeStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossNodeStatus.Merge(m, 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 SelfConsensStages struct {
	Items                []*SelfConsensStage `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SelfConsensStages proto.InternalMessageInfo

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

type SelfConsensStage struct {
	StartHeight          int64    `protobuf:"varint,1,opt,name=startHeight,proto3" json:"startHeight,omitempty"`
	Enable               uint32   `protobuf:"varint,2,opt,name=enable,proto3" json:"enable,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SelfConsensStage proto.InternalMessageInfo

func (m *SelfConsensStage) GetStartHeight() int64 {
	if m != nil {
		return m.StartHeight
	}
	return 0
}

func (m *SelfConsensStage) GetEnable() uint32 {
	if m != nil {
		return m.Enable
	}
	return 0
}

type SelfConsensStageInfo struct {
	Id                   string              `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Status               uint32              `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"`
	Stage                *SelfConsensStage   `protobuf:"bytes,3,opt,name=stage,proto3" json:"stage,omitempty"`
	FromAddr             string              `protobuf:"bytes,4,opt,name=fromAddr,proto3" json:"fromAddr,omitempty"`
	ExecHeight           int64               `protobuf:"varint,5,opt,name=execHeight,proto3" json:"execHeight,omitempty"`
	Votes                *ParaNodeVoteDetail `protobuf:"bytes,6,opt,name=votes,proto3" json:"votes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SelfConsensStageInfo proto.InternalMessageInfo

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

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

func (m *SelfConsensStageInfo) GetStage() *SelfConsensStage {
	if m != nil {
		return m.Stage
	}
	return nil
}

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

func (m *SelfConsensStageInfo) GetExecHeight() int64 {
	if m != nil {
		return m.ExecHeight
	}
	return 0
}

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

type LocalSelfConsStageInfo struct {
	Stage                *SelfConsensStageInfo `protobuf:"bytes,1,opt,name=stage,proto3" json:"stage,omitempty"`
	TxIndex              string                `protobuf:"bytes,2,opt,name=txIndex,proto3" json:"txIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_LocalSelfConsStageInfo proto.InternalMessageInfo

func (m *LocalSelfConsStageInfo) GetStage() *SelfConsensStageInfo {
	if m != nil {
		return m.Stage
	}
	return nil
}

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

type ConfigVoteInfo struct {
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// 投票值　１:ok 2:nok
	Value                uint32   `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ConfigVoteInfo proto.InternalMessageInfo

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

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

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

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

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

var xxx_messageInfo_ConfigCancelInfo proto.InternalMessageInfo

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

//广义配置类型
type ParaStageConfig struct {
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// 配置类型
	Ty uint32 `protobuf:"varint,2,opt,name=ty,proto3" json:"ty,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*ParaStageConfig_Stage
	//	*ParaStageConfig_Vote
	//	*ParaStageConfig_Cancel
	Value                isParaStageConfig_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_ParaStageConfig proto.InternalMessageInfo

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

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

type isParaStageConfig_Value interface {
	isParaStageConfig_Value()
}

type ParaStageConfig_Stage struct {
	Stage *SelfConsensStage `protobuf:"bytes,10,opt,name=stage,proto3,oneof"`
}

type ParaStageConfig_Vote struct {
	Vote *ConfigVoteInfo `protobuf:"bytes,11,opt,name=vote,proto3,oneof"`
}

type ParaStageConfig_Cancel struct {
	Cancel *ConfigCancelInfo `protobuf:"bytes,12,opt,name=cancel,proto3,oneof"`
}

func (*ParaStageConfig_Stage) isParaStageConfig_Value() {}

func (*ParaStageConfig_Vote) isParaStageConfig_Value() {}

func (*ParaStageConfig_Cancel) isParaStageConfig_Value() {}

func (m *ParaStageConfig) GetValue() isParaStageConfig_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ParaStageConfig) GetStage() *SelfConsensStage {
	if x, ok := m.GetValue().(*ParaStageConfig_Stage); ok {
		return x.Stage
	}
	return nil
}

func (m *ParaStageConfig) GetVote() *ConfigVoteInfo {
	if x, ok := m.GetValue().(*ParaStageConfig_Vote); ok {
		return x.Vote
	}
	return nil
}

func (m *ParaStageConfig) GetCancel() *ConfigCancelInfo {
	if x, ok := m.GetValue().(*ParaStageConfig_Cancel); ok {
		return x.Cancel
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ParaStageConfig) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ParaStageConfig_Stage)(nil),
		(*ParaStageConfig_Vote)(nil),
		(*ParaStageConfig_Cancel)(nil),
	}
}

type ReceiptSelfConsStageConfig struct {
	Prev                 *SelfConsensStageInfo `protobuf:"bytes,1,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *SelfConsensStageInfo `protobuf:"bytes,2,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_ReceiptSelfConsStageConfig proto.InternalMessageInfo

func (m *ReceiptSelfConsStageConfig) GetPrev() *SelfConsensStageInfo {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptSelfConsStageConfig) GetCurrent() *SelfConsensStageInfo {
	if m != nil {
		return m.Current
	}
	return nil
}

type ReceiptSelfConsStageVoteDone struct {
	Id                   string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Stage                *SelfConsensStage `protobuf:"bytes,2,opt,name=stage,proto3" json:"stage,omitempty"`
	TotalNodes           int32             `protobuf:"varint,3,opt,name=totalNodes,proto3" json:"totalNodes,omitempty"`
	TotalVote            int32             `protobuf:"varint,4,opt,name=totalVote,proto3" json:"totalVote,omitempty"`
	MostVote             int32             `protobuf:"varint,5,opt,name=mostVote,proto3" json:"mostVote,omitempty"`
	VoteRst              string            `protobuf:"bytes,6,opt,name=voteRst,proto3" json:"voteRst,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_ReceiptSelfConsStageVoteDone proto.InternalMessageInfo

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

func (m *ReceiptSelfConsStageVoteDone) GetStage() *SelfConsensStage {
	if m != nil {
		return m.Stage
	}
	return nil
}

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

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

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

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

type ReceiptSelfConsStagesUpdate struct {
	Prev                 *SelfConsensStages `protobuf:"bytes,1,opt,name=prev,proto3" json:"prev,omitempty"`
	Current              *SelfConsensStages `protobuf:"bytes,2,opt,name=current,proto3" json:"current,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_ReceiptSelfConsStagesUpdate proto.InternalMessageInfo

func (m *ReceiptSelfConsStagesUpdate) GetPrev() *SelfConsensStages {
	if m != nil {
		return m.Prev
	}
	return nil
}

func (m *ReceiptSelfConsStagesUpdate) GetCurrent() *SelfConsensStages {
	if m != nil {
		return m.Current
	}
	return nil
}

// query
type ReqQuerySelfStages struct {
	Status               uint32   `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
	Id                   string   `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	Count                int32    `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	Direction            int32    `protobuf:"varint,4,opt,name=direction,proto3" json:"direction,omitempty"`
	Height               int64    `protobuf:"varint,5,opt,name=height,proto3" json:"height,omitempty"`
	Index                int32    `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReqQuerySelfStages proto.InternalMessageInfo

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

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

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

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

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

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

type ReplyQuerySelfStages struct {
	StageInfo            []*SelfConsensStageInfo `protobuf:"bytes,1,rep,name=stageInfo,proto3" json:"stageInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_ReplyQuerySelfStages proto.InternalMessageInfo

func (m *ReplyQuerySelfStages) GetStageInfo() []*SelfConsensStageInfo {
	if m != nil {
		return m.StageInfo
	}
	return nil
}

type ParacrossCommitBlsInfo struct {
	Sign                 []byte   `protobuf:"bytes,1,opt,name=sign,proto3" json:"sign,omitempty"`
	AddrsMap             []byte   `protobuf:"bytes,2,opt,name=addrsMap,proto3" json:"addrsMap,omitempty"`
	Addrs                []string `protobuf:"bytes,3,rep,name=addrs,proto3" json:"addrs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParacrossCommitBlsInfo proto.InternalMessageInfo

func (m *ParacrossCommitBlsInfo) GetSign() []byte {
	if m != nil {
		return m.Sign
	}
	return nil
}

func (m *ParacrossCommitBlsInfo) GetAddrsMap() []byte {
	if m != nil {
		return m.AddrsMap
	}
	return nil
}

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

type ParacrossCommitAction struct {
	Status               *ParacrossNodeStatus    `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Bls                  *ParacrossCommitBlsInfo `protobuf:"bytes,2,opt,name=bls,proto3" json:"bls,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_6a397e38c9ea6747, []int{42}
}

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 (m *ParacrossCommitAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossCommitAction.Merge(m, 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
}

func (m *ParacrossCommitAction) GetBls() *ParacrossCommitBlsInfo {
	if m != nil {
		return m.Bls
	}
	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_6a397e38c9ea6747, []int{43}
}

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 (m *ParacrossMinerAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossMinerAction.Merge(m, 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 CrossAssetTransfer struct {
	AssetExec   string `protobuf:"bytes,1,opt,name=assetExec,proto3" json:"assetExec,omitempty"`
	AssetSymbol string `protobuf:"bytes,2,opt,name=assetSymbol,proto3" json:"assetSymbol,omitempty"`
	Amount      int64  `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	//default signed addr
	ToAddr               string   `protobuf:"bytes,4,opt,name=toAddr,proto3" json:"toAddr,omitempty"`
	Note                 string   `protobuf:"bytes,5,opt,name=note,proto3" json:"note,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CrossAssetTransfer proto.InternalMessageInfo

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

func (m *CrossAssetTransfer) GetAssetSymbol() string {
	if m != nil {
		return m.AssetSymbol
	}
	return ""
}

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

func (m *CrossAssetTransfer) GetToAddr() string {
	if m != nil {
		return m.ToAddr
	}
	return ""
}

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

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
	//	*ParacrossAction_SelfStageConfig
	//	*ParacrossAction_CrossAssetTransfer
	//	*ParacrossAction_ParaBindMiner
	//	*ParacrossAction_SupervisionNodeConfig
	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_6a397e38c9ea6747, []int{45}
}

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 (m *ParacrossAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossAction.Merge(m, 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"`
}

type ParacrossAction_SelfStageConfig struct {
	SelfStageConfig *ParaStageConfig `protobuf:"bytes,11,opt,name=selfStageConfig,proto3,oneof"`
}

type ParacrossAction_CrossAssetTransfer struct {
	CrossAssetTransfer *CrossAssetTransfer `protobuf:"bytes,12,opt,name=crossAssetTransfer,proto3,oneof"`
}

type ParacrossAction_ParaBindMiner struct {
	ParaBindMiner *ParaBindMinerCmd `protobuf:"bytes,13,opt,name=paraBindMiner,proto3,oneof"`
}

type ParacrossAction_SupervisionNodeConfig struct {
	SupervisionNodeConfig *ParaNodeAddrConfig `protobuf:"bytes,14,opt,name=supervisionNodeConfig,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 (*ParacrossAction_SelfStageConfig) isParacrossAction_Value() {}

func (*ParacrossAction_CrossAssetTransfer) isParacrossAction_Value() {}

func (*ParacrossAction_ParaBindMiner) isParacrossAction_Value() {}

func (*ParacrossAction_SupervisionNodeConfig) 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) GetSelfStageConfig() *ParaStageConfig {
	if x, ok := m.GetValue().(*ParacrossAction_SelfStageConfig); ok {
		return x.SelfStageConfig
	}
	return nil
}

func (m *ParacrossAction) GetCrossAssetTransfer() *CrossAssetTransfer {
	if x, ok := m.GetValue().(*ParacrossAction_CrossAssetTransfer); ok {
		return x.CrossAssetTransfer
	}
	return nil
}

func (m *ParacrossAction) GetParaBindMiner() *ParaBindMinerCmd {
	if x, ok := m.GetValue().(*ParacrossAction_ParaBindMiner); ok {
		return x.ParaBindMiner
	}
	return nil
}

func (m *ParacrossAction) GetSupervisionNodeConfig() *ParaNodeAddrConfig {
	if x, ok := m.GetValue().(*ParacrossAction_SupervisionNodeConfig); ok {
		return x.SupervisionNodeConfig
	}
	return nil
}

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ParacrossAction) XXX_OneofWrappers() []interface{} {
	return []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),
		(*ParacrossAction_SelfStageConfig)(nil),
		(*ParacrossAction_CrossAssetTransfer)(nil),
		(*ParacrossAction_ParaBindMiner)(nil),
		(*ParacrossAction_SupervisionNodeConfig)(nil),
	}
}

// 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_6a397e38c9ea6747, []int{46}
}

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 (m *ReceiptParacrossCommit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossCommit.Merge(m, 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_6a397e38c9ea6747, []int{47}
}

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 (m *ReceiptParacrossMiner) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossMiner.Merge(m, 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"`
	ChainExecHeight        int64    `protobuf:"varint,15,opt,name=chainExecHeight,proto3" json:"chainExecHeight,omitempty"`
	TotalSupervisionNodes  int32    `protobuf:"varint,16,opt,name=totalSupervisionNodes,proto3" json:"totalSupervisionNodes,omitempty"`
	TotalSupervisionCommit int32    `protobuf:"varint,17,opt,name=totalSupervisionCommit,proto3" json:"totalSupervisionCommit,omitempty"`
	MostSupervisionCommit  int32    `protobuf:"varint,18,opt,name=mostSupervisionCommit,proto3" json:"mostSupervisionCommit,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_6a397e38c9ea6747, []int{48}
}

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 (m *ReceiptParacrossDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossDone.Merge(m, 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
}

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

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

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

func (m *ReceiptParacrossDone) GetMostSupervisionCommit() int32 {
	if m != nil {
		return m.MostSupervisionCommit
	}
	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_6a397e38c9ea6747, []int{49}
}

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 (m *ReceiptParacrossRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReceiptParacrossRecord.Merge(m, 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_6a397e38c9ea6747, []int{50}
}

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 (m *ParacrossTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossTx.Merge(m, 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_6a397e38c9ea6747, []int{51}
}

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 (m *ReqParacrossTitleHeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossTitleHeight.Merge(m, 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"`
	// commitDone chainHeight
	ChainExecHeight      int64    `protobuf:"varint,9,opt,name=chainExecHeight,proto3" json:"chainExecHeight,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_6a397e38c9ea6747, []int{52}
}

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 (m *RespParacrossDone) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossDone.Merge(m, 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 ""
}

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

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_6a397e38c9ea6747, []int{53}
}

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 (m *RespParacrossTitles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RespParacrossTitles.Merge(m, 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_6a397e38c9ea6747, []int{54}
}

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 (m *ReqParacrossTitleHash) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReqParacrossTitleHash.Merge(m, 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     string `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"`
	//跨链类型　0:to para, 1:to main
	CrossType uint32 `protobuf:"varint,8,opt,name=crossType,proto3" json:"crossType,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_6a397e38c9ea6747, []int{55}
}

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 (m *ParacrossAsset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParacrossAsset.Merge(m, 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() string {
	if m != nil {
		return m.TxHash
	}
	return ""
}

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) GetCrossType() uint32 {
	if m != nil {
		return m.CrossType
	}
	return 0
}

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_6a397e38c9ea6747, []int{56}
}

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 (m *ParaLocalDbBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaLocalDbBlock.Merge(m, 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_6a397e38c9ea6747, []int{57}
}

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 (m *ParaLocalDbBlockInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParaLocalDbBlockInfo.Merge(m, 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
}

type ParaBlsSignSumDetails struct {
	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Addrs                []string `protobuf:"bytes,2,rep,name=addrs,proto3" json:"addrs,omitempty"`
	Msgs                 [][]byte `protobuf:"bytes,3,rep,name=msgs,proto3" json:"msgs,omitempty"`
	Signs                [][]byte `protobuf:"bytes,4,rep,name=signs,proto3" json:"signs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParaBlsSignSumDetails proto.InternalMessageInfo

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

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

func (m *ParaBlsSignSumDetails) GetMsgs() [][]byte {
	if m != nil {
		return m.Msgs
	}
	return nil
}

func (m *ParaBlsSignSumDetails) GetSigns() [][]byte {
	if m != nil {
		return m.Signs
	}
	return nil
}

type ParaBlsSignSumDetailsShow struct {
	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	Addrs                []string `protobuf:"bytes,2,rep,name=addrs,proto3" json:"addrs,omitempty"`
	Msgs                 []string `protobuf:"bytes,3,rep,name=msgs,proto3" json:"msgs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ParaBlsSignSumDetailsShow proto.InternalMessageInfo

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

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

func (m *ParaBlsSignSumDetailsShow) GetMsgs() []string {
	if m != nil {
		return m.Msgs
	}
	return nil
}

type ParaBlsSignSumInfo struct {
	Info                 []*ParaBlsSignSumDetailsShow `protobuf:"bytes,1,rep,name=info,proto3" json:"info,omitempty"`
	Topics               []string                     `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

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

var xxx_messageInfo_ParaBlsSignSumInfo proto.InternalMessageInfo

func (m *ParaBlsSignSumInfo) GetInfo() []*ParaBlsSignSumDetailsShow {
	if m != nil {
		return m.Info
	}
	return nil
}

func (m *ParaBlsSignSumInfo) GetTopics() []string {
	if m != nil {
		return m.Topics
	}
	return nil
}

type LeaderSyncInfo struct {
	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	BaseIdx              int32    `protobuf:"varint,2,opt,name=baseIdx,proto3" json:"baseIdx,omitempty"`
	Offset               int32    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LeaderSyncInfo proto.InternalMessageInfo

func (m *LeaderSyncInfo) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *LeaderSyncInfo) GetBaseIdx() int32 {
	if m != nil {
		return m.BaseIdx
	}
	return 0
}

func (m *LeaderSyncInfo) GetOffset() int32 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type ParaP2PSubMsg struct {
	Ty int32 `protobuf:"varint,1,opt,name=ty,proto3" json:"ty,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*ParaP2PSubMsg_CommitTx
	//	*ParaP2PSubMsg_SyncMsg
	Value                isParaP2PSubMsg_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_ParaP2PSubMsg proto.InternalMessageInfo

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

type isParaP2PSubMsg_Value interface {
	isParaP2PSubMsg_Value()
}

type ParaP2PSubMsg_CommitTx struct {
	CommitTx *types.Transaction `protobuf:"bytes,10,opt,name=commitTx,proto3,oneof"`
}

type ParaP2PSubMsg_SyncMsg struct {
	SyncMsg *LeaderSyncInfo `protobuf:"bytes,11,opt,name=syncMsg,proto3,oneof"`
}

func (*ParaP2PSubMsg_CommitTx) isParaP2PSubMsg_Value() {}

func (*ParaP2PSubMsg_SyncMsg) isParaP2PSubMsg_Value() {}

func (m *ParaP2PSubMsg) GetValue() isParaP2PSubMsg_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ParaP2PSubMsg) GetCommitTx() *types.Transaction {
	if x, ok := m.GetValue().(*ParaP2PSubMsg_CommitTx); ok {
		return x.CommitTx
	}
	return nil
}

func (m *ParaP2PSubMsg) GetSyncMsg() *LeaderSyncInfo {
	if x, ok := m.GetValue().(*ParaP2PSubMsg_SyncMsg); ok {
		return x.SyncMsg
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ParaP2PSubMsg) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ParaP2PSubMsg_CommitTx)(nil),
		(*ParaP2PSubMsg_SyncMsg)(nil),
	}
}

//bls sign leader info
type ElectionStatus struct {
	IsLeader             bool            `protobuf:"varint,1,opt,name=isLeader,proto3" json:"isLeader,omitempty"`
	Leader               *LeaderSyncInfo `protobuf:"bytes,2,opt,name=leader,proto3" json:"leader,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *ElectionStatus) Reset()         { *m = ElectionStatus{} }
func (m *ElectionStatus) String() string { return proto.CompactTextString(m) }
func (*ElectionStatus) ProtoMessage()    {}
func (*ElectionStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_6a397e38c9ea6747, []int{63}
}

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

var xxx_messageInfo_ElectionStatus proto.InternalMessageInfo

func (m *ElectionStatus) GetIsLeader() bool {
	if m != nil {
		return m.IsLeader
	}
	return false
}

func (m *ElectionStatus) GetLeader() *LeaderSyncInfo {
	if m != nil {
		return m.Leader
	}
	return nil
}

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

func (m *BlsPubKey) Reset()         { *m = BlsPubKey{} }
func (m *BlsPubKey) String() string { return proto.CompactTextString(m) }
func (*BlsPubKey) ProtoMessage()    {}
func (*BlsPubKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_6a397e38c9ea6747, []int{64}
}

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

var xxx_messageInfo_BlsPubKey proto.InternalMessageInfo

func (m *BlsPubKey) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

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((*ParaBindMinerCmd)(nil), "types.ParaBindMinerCmd")
	proto.RegisterType((*ParaBindMinerInfo)(nil), "types.ParaBindMinerInfo")
	proto.RegisterType((*ReceiptParaBindMinerInfo)(nil), "types.ReceiptParaBindMinerInfo")
	proto.RegisterType((*ParaNodeBindOne)(nil), "types.ParaNodeBindOne")
	proto.RegisterType((*ParaNodeBindList)(nil), "types.ParaNodeBindList")
	proto.RegisterType((*ReceiptParaNodeBindListUpdate)(nil), "types.ReceiptParaNodeBindListUpdate")
	proto.RegisterType((*RespParaNodeBindList)(nil), "types.RespParaNodeBindList")
	proto.RegisterType((*ParaBlock2MainMap)(nil), "types.ParaBlock2MainMap")
	proto.RegisterType((*ParaBlock2MainInfo)(nil), "types.ParaBlock2MainInfo")
	proto.RegisterType((*ParacrossNodeStatus)(nil), "types.ParacrossNodeStatus")
	proto.RegisterType((*SelfConsensStages)(nil), "types.SelfConsensStages")
	proto.RegisterType((*SelfConsensStage)(nil), "types.SelfConsensStage")
	proto.RegisterType((*SelfConsensStageInfo)(nil), "types.SelfConsensStageInfo")
	proto.RegisterType((*LocalSelfConsStageInfo)(nil), "types.LocalSelfConsStageInfo")
	proto.RegisterType((*ConfigVoteInfo)(nil), "types.ConfigVoteInfo")
	proto.RegisterType((*ConfigCancelInfo)(nil), "types.ConfigCancelInfo")
	proto.RegisterType((*ParaStageConfig)(nil), "types.ParaStageConfig")
	proto.RegisterType((*ReceiptSelfConsStageConfig)(nil), "types.ReceiptSelfConsStageConfig")
	proto.RegisterType((*ReceiptSelfConsStageVoteDone)(nil), "types.ReceiptSelfConsStageVoteDone")
	proto.RegisterType((*ReceiptSelfConsStagesUpdate)(nil), "types.ReceiptSelfConsStagesUpdate")
	proto.RegisterType((*ReqQuerySelfStages)(nil), "types.ReqQuerySelfStages")
	proto.RegisterType((*ReplyQuerySelfStages)(nil), "types.ReplyQuerySelfStages")
	proto.RegisterType((*ParacrossCommitBlsInfo)(nil), "types.ParacrossCommitBlsInfo")
	proto.RegisterType((*ParacrossCommitAction)(nil), "types.ParacrossCommitAction")
	proto.RegisterType((*ParacrossMinerAction)(nil), "types.ParacrossMinerAction")
	proto.RegisterType((*CrossAssetTransfer)(nil), "types.CrossAssetTransfer")
	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")
	proto.RegisterType((*ParaBlsSignSumDetails)(nil), "types.ParaBlsSignSumDetails")
	proto.RegisterType((*ParaBlsSignSumDetailsShow)(nil), "types.ParaBlsSignSumDetailsShow")
	proto.RegisterType((*ParaBlsSignSumInfo)(nil), "types.ParaBlsSignSumInfo")
	proto.RegisterType((*LeaderSyncInfo)(nil), "types.LeaderSyncInfo")
	proto.RegisterType((*ParaP2PSubMsg)(nil), "types.ParaP2PSubMsg")
	proto.RegisterType((*ElectionStatus)(nil), "types.ElectionStatus")
	proto.RegisterType((*BlsPubKey)(nil), "types.BlsPubKey")
}

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

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

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

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

// 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 {
	IsSync(ctx context.Context, in *types.ReqNil, opts ...grpc.CallOption) (*types.IsCaughtUp, error)
}

type paracrossClient struct {
	cc grpc.ClientConnInterface
}

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

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 {
	IsSync(context.Context, *types.ReqNil) (*types.IsCaughtUp, error)
}

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

func (*UnimplementedParacrossServer) IsSync(ctx context.Context, req *types.ReqNil) (*types.IsCaughtUp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsSync not implemented")
}

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

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: "IsSync",
			Handler:    _Paracross_IsSync_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "paracross.proto",
}
