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

package types

import (
	context "context"
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

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

//*
// 请求获取远程节点的节点信息
type P2PGetPeerInfo struct {
	/// p2p版本
	Version              int32    `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetPeerInfo proto.InternalMessageInfo

func (m *P2PGetPeerInfo) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

//*
// 节点信息
type P2PPeerInfo struct {
	///节点的IP地址
	Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	///节点的外网端口
	Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	///节点的名称
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	/// mempool 的大小
	MempoolSize int32 `protobuf:"varint,4,opt,name=mempoolSize,proto3" json:"mempoolSize,omitempty"`
	///节点当前高度头部数据
	Header               *Header  `protobuf:"bytes,5,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PPeerInfo proto.InternalMessageInfo

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

func (m *P2PPeerInfo) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *P2PPeerInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *P2PPeerInfo) GetMempoolSize() int32 {
	if m != nil {
		return m.MempoolSize
	}
	return 0
}

func (m *P2PPeerInfo) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

//*
// p2p节点间发送版本数据结构
type P2PVersion struct {
	///当前版本
	Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	///服务类型
	Service int64 `protobuf:"varint,2,opt,name=service,proto3" json:"service,omitempty"`
	///时间戳
	Timestamp int64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	///数据包的目的地址
	AddrRecv string `protobuf:"bytes,4,opt,name=addrRecv,proto3" json:"addrRecv,omitempty"`
	///数据发送的源地址
	AddrFrom string `protobuf:"bytes,5,opt,name=addrFrom,proto3" json:"addrFrom,omitempty"`
	///随机数
	Nonce int64 `protobuf:"varint,6,opt,name=nonce,proto3" json:"nonce,omitempty"`
	///用户代理
	UserAgent string `protobuf:"bytes,7,opt,name=userAgent,proto3" json:"userAgent,omitempty"`
	///当前节点的高度
	StartHeight          int64    `protobuf:"varint,8,opt,name=startHeight,proto3" json:"startHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PVersion proto.InternalMessageInfo

func (m *P2PVersion) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *P2PVersion) GetService() int64 {
	if m != nil {
		return m.Service
	}
	return 0
}

func (m *P2PVersion) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *P2PVersion) GetAddrRecv() string {
	if m != nil {
		return m.AddrRecv
	}
	return ""
}

func (m *P2PVersion) GetAddrFrom() string {
	if m != nil {
		return m.AddrFrom
	}
	return ""
}

func (m *P2PVersion) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *P2PVersion) GetUserAgent() string {
	if m != nil {
		return m.UserAgent
	}
	return ""
}

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

//*
// P2P 版本返回
type P2PVerAck struct {
	Version              int32    `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	Service              int64    `protobuf:"varint,2,opt,name=service,proto3" json:"service,omitempty"`
	Nonce                int64    `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PVerAck proto.InternalMessageInfo

func (m *P2PVerAck) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *P2PVerAck) GetService() int64 {
	if m != nil {
		return m.Service
	}
	return 0
}

func (m *P2PVerAck) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

//*
// P2P 心跳包
type P2PPing struct {
	///随机数
	Nonce int64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	///节点的外网地址
	Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
	///节点的外网端口
	Port int32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	//签名
	Sign                 *Signature `protobuf:"bytes,4,opt,name=sign,proto3" json:"sign,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_P2PPing proto.InternalMessageInfo

func (m *P2PPing) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

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

func (m *P2PPing) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *P2PPing) GetSign() *Signature {
	if m != nil {
		return m.Sign
	}
	return nil
}

//*
// 心跳返回包
type P2PPong struct {
	Nonce                int64    `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PPong proto.InternalMessageInfo

func (m *P2PPong) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

//*
// 获取对方节点所连接的其他节点地址的请求包
type P2PGetAddr struct {
	Nonce                int64    `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetAddr proto.InternalMessageInfo

func (m *P2PGetAddr) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

//*
// 返回请求地址列表的社保
type P2PAddr struct {
	Nonce int64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	///对方节点返回的其他节点信息
	Addrlist             []string `protobuf:"bytes,2,rep,name=addrlist,proto3" json:"addrlist,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PAddr proto.InternalMessageInfo

func (m *P2PAddr) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *P2PAddr) GetAddrlist() []string {
	if m != nil {
		return m.Addrlist
	}
	return nil
}

type P2PAddrList struct {
	Nonce                int64          `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Peerinfo             []*P2PPeerInfo `protobuf:"bytes,2,rep,name=peerinfo,proto3" json:"peerinfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_P2PAddrList proto.InternalMessageInfo

func (m *P2PAddrList) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

func (m *P2PAddrList) GetPeerinfo() []*P2PPeerInfo {
	if m != nil {
		return m.Peerinfo
	}
	return nil
}

//*
// 节点外网信息
type P2PExternalInfo struct {
	///节点的外网地址
	Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	//节点是否在外网
	Isoutside            bool     `protobuf:"varint,2,opt,name=isoutside,proto3" json:"isoutside,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PExternalInfo proto.InternalMessageInfo

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

func (m *P2PExternalInfo) GetIsoutside() bool {
	if m != nil {
		return m.Isoutside
	}
	return false
}

//*
// 获取区间区块
type P2PGetBlocks struct {
	Version              int32    `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	StartHeight          int64    `protobuf:"varint,2,opt,name=startHeight,proto3" json:"startHeight,omitempty"`
	EndHeight            int64    `protobuf:"varint,3,opt,name=endHeight,proto3" json:"endHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetBlocks proto.InternalMessageInfo

func (m *P2PGetBlocks) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

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

func (m *P2PGetBlocks) GetEndHeight() int64 {
	if m != nil {
		return m.EndHeight
	}
	return 0
}

//*
// 获取mempool
type P2PGetMempool struct {
	Version              int32    `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetMempool proto.InternalMessageInfo

func (m *P2PGetMempool) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

type P2PInv struct {
	Invs                 []*Inventory `protobuf:"bytes,1,rep,name=invs,proto3" json:"invs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_P2PInv proto.InternalMessageInfo

func (m *P2PInv) GetInvs() []*Inventory {
	if m != nil {
		return m.Invs
	}
	return nil
}

// ty=MSG_TX MSG_BLOCK
type Inventory struct {
	//类型，数据类型，MSG_TX MSG_BLOCK
	Ty int32 `protobuf:"varint,1,opt,name=ty,proto3" json:"ty,omitempty"`
	///哈希
	Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
	//高度
	Height               int64    `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Inventory proto.InternalMessageInfo

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

func (m *Inventory) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

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

//*
// 通过invs 下载数据
type P2PGetData struct {
	/// p2p版本
	Version int32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	/// invs 数组
	Invs                 []*Inventory `protobuf:"bytes,2,rep,name=invs,proto3" json:"invs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetData proto.InternalMessageInfo

func (m *P2PGetData) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *P2PGetData) GetInvs() []*Inventory {
	if m != nil {
		return m.Invs
	}
	return nil
}

//
type P2PRoute struct {
	TTL                  int32    `protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PRoute proto.InternalMessageInfo

func (m *P2PRoute) GetTTL() int32 {
	if m != nil {
		return m.TTL
	}
	return 0
}

//*
// p2p 发送交易协议
type P2PTx struct {
	Tx                   *Transaction `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
	Route                *P2PRoute    `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_P2PTx proto.InternalMessageInfo

func (m *P2PTx) GetTx() *Transaction {
	if m != nil {
		return m.Tx
	}
	return nil
}

func (m *P2PTx) GetRoute() *P2PRoute {
	if m != nil {
		return m.Route
	}
	return nil
}

//*
// p2p 发送区块协议
type P2PBlock struct {
	Block                *Block   `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PBlock proto.InternalMessageInfo

func (m *P2PBlock) GetBlock() *Block {
	if m != nil {
		return m.Block
	}
	return nil
}

//*
// p2p 轻量级区块, 广播交易短哈希列表
type LightBlock struct {
	Size                 int64        `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"`
	Header               *Header      `protobuf:"bytes,2,opt,name=header,proto3" json:"header,omitempty"`
	MinerTx              *Transaction `protobuf:"bytes,3,opt,name=minerTx,proto3" json:"minerTx,omitempty"`
	STxHashes            []string     `protobuf:"bytes,4,rep,name=sTxHashes,proto3" json:"sTxHashes,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_LightBlock proto.InternalMessageInfo

func (m *LightBlock) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *LightBlock) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *LightBlock) GetMinerTx() *Transaction {
	if m != nil {
		return m.MinerTx
	}
	return nil
}

func (m *LightBlock) GetSTxHashes() []string {
	if m != nil {
		return m.STxHashes
	}
	return nil
}

// 轻量级交易广播
type LightTx struct {
	TxHash               []byte    `protobuf:"bytes,1,opt,name=txHash,proto3" json:"txHash,omitempty"`
	Route                *P2PRoute `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_LightTx proto.InternalMessageInfo

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

func (m *LightTx) GetRoute() *P2PRoute {
	if m != nil {
		return m.Route
	}
	return nil
}

// 请求完整交易数据
type P2PTxReq struct {
	TxHash               []byte   `protobuf:"bytes,1,opt,name=txHash,proto3" json:"txHash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PTxReq proto.InternalMessageInfo

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

// 请求区块内交易数据
type P2PBlockTxReq struct {
	BlockHash            string   `protobuf:"bytes,1,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	TxIndices            []int32  `protobuf:"varint,2,rep,packed,name=txIndices,proto3" json:"txIndices,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PBlockTxReq proto.InternalMessageInfo

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

func (m *P2PBlockTxReq) GetTxIndices() []int32 {
	if m != nil {
		return m.TxIndices
	}
	return nil
}

// 区块交易数据返回
type P2PBlockTxReply struct {
	BlockHash            string         `protobuf:"bytes,1,opt,name=blockHash,proto3" json:"blockHash,omitempty"`
	TxIndices            []int32        `protobuf:"varint,2,rep,packed,name=txIndices,proto3" json:"txIndices,omitempty"`
	Txs                  []*Transaction `protobuf:"bytes,3,rep,name=txs,proto3" json:"txs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

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

var xxx_messageInfo_P2PBlockTxReply proto.InternalMessageInfo

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

func (m *P2PBlockTxReply) GetTxIndices() []int32 {
	if m != nil {
		return m.TxIndices
	}
	return nil
}

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

// 节点收到区块或交易hash,
// 当在本地不存在时,需要请求重发完整交易或区块
// 采用统一结构减少消息类型
type P2PQueryData struct {
	// Types that are valid to be assigned to Value:
	//	*P2PQueryData_TxReq
	//	*P2PQueryData_BlockTxReq
	Value                isP2PQueryData_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_P2PQueryData proto.InternalMessageInfo

type isP2PQueryData_Value interface {
	isP2PQueryData_Value()
}

type P2PQueryData_TxReq struct {
	TxReq *P2PTxReq `protobuf:"bytes,1,opt,name=txReq,proto3,oneof"`
}

type P2PQueryData_BlockTxReq struct {
	BlockTxReq *P2PBlockTxReq `protobuf:"bytes,2,opt,name=blockTxReq,proto3,oneof"`
}

func (*P2PQueryData_TxReq) isP2PQueryData_Value() {}

func (*P2PQueryData_BlockTxReq) isP2PQueryData_Value() {}

func (m *P2PQueryData) GetValue() isP2PQueryData_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *P2PQueryData) GetTxReq() *P2PTxReq {
	if x, ok := m.GetValue().(*P2PQueryData_TxReq); ok {
		return x.TxReq
	}
	return nil
}

func (m *P2PQueryData) GetBlockTxReq() *P2PBlockTxReq {
	if x, ok := m.GetValue().(*P2PQueryData_BlockTxReq); ok {
		return x.BlockTxReq
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*P2PQueryData) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*P2PQueryData_TxReq)(nil),
		(*P2PQueryData_BlockTxReq)(nil),
	}
}

//*
// p2p 协议和软件版本
type Versions struct {
	P2Pversion           int32    `protobuf:"varint,1,opt,name=p2pversion,proto3" json:"p2pversion,omitempty"`
	Softversion          string   `protobuf:"bytes,2,opt,name=softversion,proto3" json:"softversion,omitempty"`
	Peername             string   `protobuf:"bytes,3,opt,name=peername,proto3" json:"peername,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Versions proto.InternalMessageInfo

func (m *Versions) GetP2Pversion() int32 {
	if m != nil {
		return m.P2Pversion
	}
	return 0
}

func (m *Versions) GetSoftversion() string {
	if m != nil {
		return m.Softversion
	}
	return ""
}

func (m *Versions) GetPeername() string {
	if m != nil {
		return m.Peername
	}
	return ""
}

//*
// p2p 广播数据协议
type BroadCastData struct {
	// Types that are valid to be assigned to Value:
	//	*BroadCastData_Tx
	//	*BroadCastData_Block
	//	*BroadCastData_Ping
	//	*BroadCastData_Version
	//	*BroadCastData_LtTx
	//	*BroadCastData_LtBlock
	//	*BroadCastData_Query
	//	*BroadCastData_BlockRep
	Value                isBroadCastData_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_BroadCastData proto.InternalMessageInfo

type isBroadCastData_Value interface {
	isBroadCastData_Value()
}

type BroadCastData_Tx struct {
	Tx *P2PTx `protobuf:"bytes,1,opt,name=tx,proto3,oneof"`
}

type BroadCastData_Block struct {
	Block *P2PBlock `protobuf:"bytes,2,opt,name=block,proto3,oneof"`
}

type BroadCastData_Ping struct {
	Ping *P2PPing `protobuf:"bytes,3,opt,name=ping,proto3,oneof"`
}

type BroadCastData_Version struct {
	Version *Versions `protobuf:"bytes,4,opt,name=version,proto3,oneof"`
}

type BroadCastData_LtTx struct {
	LtTx *LightTx `protobuf:"bytes,5,opt,name=ltTx,proto3,oneof"`
}

type BroadCastData_LtBlock struct {
	LtBlock *LightBlock `protobuf:"bytes,6,opt,name=ltBlock,proto3,oneof"`
}

type BroadCastData_Query struct {
	Query *P2PQueryData `protobuf:"bytes,7,opt,name=query,proto3,oneof"`
}

type BroadCastData_BlockRep struct {
	BlockRep *P2PBlockTxReply `protobuf:"bytes,8,opt,name=blockRep,proto3,oneof"`
}

func (*BroadCastData_Tx) isBroadCastData_Value() {}

func (*BroadCastData_Block) isBroadCastData_Value() {}

func (*BroadCastData_Ping) isBroadCastData_Value() {}

func (*BroadCastData_Version) isBroadCastData_Value() {}

func (*BroadCastData_LtTx) isBroadCastData_Value() {}

func (*BroadCastData_LtBlock) isBroadCastData_Value() {}

func (*BroadCastData_Query) isBroadCastData_Value() {}

func (*BroadCastData_BlockRep) isBroadCastData_Value() {}

func (m *BroadCastData) GetValue() isBroadCastData_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *BroadCastData) GetTx() *P2PTx {
	if x, ok := m.GetValue().(*BroadCastData_Tx); ok {
		return x.Tx
	}
	return nil
}

func (m *BroadCastData) GetBlock() *P2PBlock {
	if x, ok := m.GetValue().(*BroadCastData_Block); ok {
		return x.Block
	}
	return nil
}

func (m *BroadCastData) GetPing() *P2PPing {
	if x, ok := m.GetValue().(*BroadCastData_Ping); ok {
		return x.Ping
	}
	return nil
}

func (m *BroadCastData) GetVersion() *Versions {
	if x, ok := m.GetValue().(*BroadCastData_Version); ok {
		return x.Version
	}
	return nil
}

func (m *BroadCastData) GetLtTx() *LightTx {
	if x, ok := m.GetValue().(*BroadCastData_LtTx); ok {
		return x.LtTx
	}
	return nil
}

func (m *BroadCastData) GetLtBlock() *LightBlock {
	if x, ok := m.GetValue().(*BroadCastData_LtBlock); ok {
		return x.LtBlock
	}
	return nil
}

func (m *BroadCastData) GetQuery() *P2PQueryData {
	if x, ok := m.GetValue().(*BroadCastData_Query); ok {
		return x.Query
	}
	return nil
}

func (m *BroadCastData) GetBlockRep() *P2PBlockTxReply {
	if x, ok := m.GetValue().(*BroadCastData_BlockRep); ok {
		return x.BlockRep
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*BroadCastData) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*BroadCastData_Tx)(nil),
		(*BroadCastData_Block)(nil),
		(*BroadCastData_Ping)(nil),
		(*BroadCastData_Version)(nil),
		(*BroadCastData_LtTx)(nil),
		(*BroadCastData_LtBlock)(nil),
		(*BroadCastData_Query)(nil),
		(*BroadCastData_BlockRep)(nil),
	}
}

//*
// p2p 获取区块区间头部信息协议
type P2PGetHeaders struct {
	Version              int32    `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	StartHeight          int64    `protobuf:"varint,2,opt,name=startHeight,proto3" json:"startHeight,omitempty"`
	EndHeight            int64    `protobuf:"varint,3,opt,name=endHeight,proto3" json:"endHeight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetHeaders proto.InternalMessageInfo

func (m *P2PGetHeaders) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

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

func (m *P2PGetHeaders) GetEndHeight() int64 {
	if m != nil {
		return m.EndHeight
	}
	return 0
}

//*
// p2p 区块头传输协议
type P2PHeaders struct {
	Headers              []*Header `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

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

var xxx_messageInfo_P2PHeaders proto.InternalMessageInfo

func (m *P2PHeaders) GetHeaders() []*Header {
	if m != nil {
		return m.Headers
	}
	return nil
}

//*
// inv 请求协议
type InvData struct {
	// Types that are valid to be assigned to Value:
	//	*InvData_Tx
	//	*InvData_Block
	Value                isInvData_Value `protobuf_oneof:"value"`
	Ty                   int32           `protobuf:"varint,3,opt,name=ty,proto3" json:"ty,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_InvData proto.InternalMessageInfo

type isInvData_Value interface {
	isInvData_Value()
}

type InvData_Tx struct {
	Tx *Transaction `protobuf:"bytes,1,opt,name=tx,proto3,oneof"`
}

type InvData_Block struct {
	Block *Block `protobuf:"bytes,2,opt,name=block,proto3,oneof"`
}

func (*InvData_Tx) isInvData_Value() {}

func (*InvData_Block) isInvData_Value() {}

func (m *InvData) GetValue() isInvData_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *InvData) GetTx() *Transaction {
	if x, ok := m.GetValue().(*InvData_Tx); ok {
		return x.Tx
	}
	return nil
}

func (m *InvData) GetBlock() *Block {
	if x, ok := m.GetValue().(*InvData_Block); ok {
		return x.Block
	}
	return nil
}

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*InvData) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*InvData_Tx)(nil),
		(*InvData_Block)(nil),
	}
}

//*
// inv 返回数据
type InvDatas struct {
	Items                []*InvData `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

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

var xxx_messageInfo_InvDatas proto.InternalMessageInfo

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

//*
// peer 信息
type Peer struct {
	Addr                 string   `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"`
	Port                 int32    `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Self                 bool     `protobuf:"varint,4,opt,name=self,proto3" json:"self,omitempty"`
	MempoolSize          int32    `protobuf:"varint,5,opt,name=mempoolSize,proto3" json:"mempoolSize,omitempty"`
	Header               *Header  `protobuf:"bytes,6,opt,name=header,proto3" json:"header,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Peer proto.InternalMessageInfo

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

func (m *Peer) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *Peer) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Peer) GetSelf() bool {
	if m != nil {
		return m.Self
	}
	return false
}

func (m *Peer) GetMempoolSize() int32 {
	if m != nil {
		return m.MempoolSize
	}
	return 0
}

func (m *Peer) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

//*
// peer 列表
type PeerList struct {
	Peers                []*Peer  `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PeerList proto.InternalMessageInfo

func (m *PeerList) GetPeers() []*Peer {
	if m != nil {
		return m.Peers
	}
	return nil
}

//*
// p2p get peer req
type P2PGetPeerReq struct {
	P2PType              string   `protobuf:"bytes,1,opt,name=p2pType,proto3" json:"p2pType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetPeerReq proto.InternalMessageInfo

func (m *P2PGetPeerReq) GetP2PType() string {
	if m != nil {
		return m.P2PType
	}
	return ""
}

//*
// p2p get net info req
type P2PGetNetInfoReq struct {
	P2PType              string   `protobuf:"bytes,1,opt,name=p2pType,proto3" json:"p2pType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_P2PGetNetInfoReq proto.InternalMessageInfo

func (m *P2PGetNetInfoReq) GetP2PType() string {
	if m != nil {
		return m.P2PType
	}
	return ""
}

//*
//当前节点的网络信息
type NodeNetInfo struct {
	Externaladdr         string   `protobuf:"bytes,1,opt,name=externaladdr,proto3" json:"externaladdr,omitempty"`
	Localaddr            string   `protobuf:"bytes,2,opt,name=localaddr,proto3" json:"localaddr,omitempty"`
	Service              bool     `protobuf:"varint,3,opt,name=service,proto3" json:"service,omitempty"`
	Outbounds            int32    `protobuf:"varint,4,opt,name=outbounds,proto3" json:"outbounds,omitempty"`
	Inbounds             int32    `protobuf:"varint,5,opt,name=inbounds,proto3" json:"inbounds,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_NodeNetInfo proto.InternalMessageInfo

func (m *NodeNetInfo) GetExternaladdr() string {
	if m != nil {
		return m.Externaladdr
	}
	return ""
}

func (m *NodeNetInfo) GetLocaladdr() string {
	if m != nil {
		return m.Localaddr
	}
	return ""
}

func (m *NodeNetInfo) GetService() bool {
	if m != nil {
		return m.Service
	}
	return false
}

func (m *NodeNetInfo) GetOutbounds() int32 {
	if m != nil {
		return m.Outbounds
	}
	return 0
}

func (m *NodeNetInfo) GetInbounds() int32 {
	if m != nil {
		return m.Inbounds
	}
	return 0
}

type PeersReply struct {
	Peers                []*PeersInfo `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_PeersReply proto.InternalMessageInfo

func (m *PeersReply) GetPeers() []*PeersInfo {
	if m != nil {
		return m.Peers
	}
	return nil
}

type PeersInfo struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Ip                   string   `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
	Port                 int32    `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	Softversion          string   `protobuf:"bytes,4,opt,name=softversion,proto3" json:"softversion,omitempty"`
	P2Pversion           int32    `protobuf:"varint,5,opt,name=p2pversion,proto3" json:"p2pversion,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PeersInfo proto.InternalMessageInfo

func (m *PeersInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *PeersInfo) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *PeersInfo) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

func (m *PeersInfo) GetSoftversion() string {
	if m != nil {
		return m.Softversion
	}
	return ""
}

func (m *PeersInfo) GetP2Pversion() int32 {
	if m != nil {
		return m.P2Pversion
	}
	return 0
}

func init() {
	proto.RegisterType((*P2PGetPeerInfo)(nil), "types.P2PGetPeerInfo")
	proto.RegisterType((*P2PPeerInfo)(nil), "types.P2PPeerInfo")
	proto.RegisterType((*P2PVersion)(nil), "types.P2PVersion")
	proto.RegisterType((*P2PVerAck)(nil), "types.P2PVerAck")
	proto.RegisterType((*P2PPing)(nil), "types.P2PPing")
	proto.RegisterType((*P2PPong)(nil), "types.P2PPong")
	proto.RegisterType((*P2PGetAddr)(nil), "types.P2PGetAddr")
	proto.RegisterType((*P2PAddr)(nil), "types.P2PAddr")
	proto.RegisterType((*P2PAddrList)(nil), "types.P2PAddrList")
	proto.RegisterType((*P2PExternalInfo)(nil), "types.P2PExternalInfo")
	proto.RegisterType((*P2PGetBlocks)(nil), "types.P2PGetBlocks")
	proto.RegisterType((*P2PGetMempool)(nil), "types.P2PGetMempool")
	proto.RegisterType((*P2PInv)(nil), "types.P2PInv")
	proto.RegisterType((*Inventory)(nil), "types.Inventory")
	proto.RegisterType((*P2PGetData)(nil), "types.P2PGetData")
	proto.RegisterType((*P2PRoute)(nil), "types.P2PRoute")
	proto.RegisterType((*P2PTx)(nil), "types.P2PTx")
	proto.RegisterType((*P2PBlock)(nil), "types.P2PBlock")
	proto.RegisterType((*LightBlock)(nil), "types.LightBlock")
	proto.RegisterType((*LightTx)(nil), "types.LightTx")
	proto.RegisterType((*P2PTxReq)(nil), "types.P2PTxReq")
	proto.RegisterType((*P2PBlockTxReq)(nil), "types.P2PBlockTxReq")
	proto.RegisterType((*P2PBlockTxReply)(nil), "types.P2PBlockTxReply")
	proto.RegisterType((*P2PQueryData)(nil), "types.P2PQueryData")
	proto.RegisterType((*Versions)(nil), "types.Versions")
	proto.RegisterType((*BroadCastData)(nil), "types.BroadCastData")
	proto.RegisterType((*P2PGetHeaders)(nil), "types.P2PGetHeaders")
	proto.RegisterType((*P2PHeaders)(nil), "types.P2PHeaders")
	proto.RegisterType((*InvData)(nil), "types.InvData")
	proto.RegisterType((*InvDatas)(nil), "types.InvDatas")
	proto.RegisterType((*Peer)(nil), "types.Peer")
	proto.RegisterType((*PeerList)(nil), "types.PeerList")
	proto.RegisterType((*P2PGetPeerReq)(nil), "types.P2PGetPeerReq")
	proto.RegisterType((*P2PGetNetInfoReq)(nil), "types.P2PGetNetInfoReq")
	proto.RegisterType((*NodeNetInfo)(nil), "types.NodeNetInfo")
	proto.RegisterType((*PeersReply)(nil), "types.PeersReply")
	proto.RegisterType((*PeersInfo)(nil), "types.PeersInfo")
}

func init() {
	proto.RegisterFile("p2p.proto", fileDescriptor_e7fdddb109e6467a)
}

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

// P2PgserviceClient is the client API for P2Pgservice service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type P2PgserviceClient interface {
	//广播交易
	BroadCastTx(ctx context.Context, in *P2PTx, opts ...grpc.CallOption) (*Reply, error)
	//广播区块
	BroadCastBlock(ctx context.Context, in *P2PBlock, opts ...grpc.CallOption) (*Reply, error)
	// PING
	Ping(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*P2PPong, error)
	//获取地址
	GetAddr(ctx context.Context, in *P2PGetAddr, opts ...grpc.CallOption) (*P2PAddr, error)
	GetAddrList(ctx context.Context, in *P2PGetAddr, opts ...grpc.CallOption) (*P2PAddrList, error)
	//版本
	Version(ctx context.Context, in *P2PVersion, opts ...grpc.CallOption) (*P2PVerAck, error)
	//获取p2p协议的版本号
	Version2(ctx context.Context, in *P2PVersion, opts ...grpc.CallOption) (*P2PVersion, error)
	//获取软件的版本号
	SoftVersion(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*Reply, error)
	//获取区块，最高200
	GetBlocks(ctx context.Context, in *P2PGetBlocks, opts ...grpc.CallOption) (*P2PInv, error)
	//获取mempool
	GetMemPool(ctx context.Context, in *P2PGetMempool, opts ...grpc.CallOption) (*P2PInv, error)
	//获取数据
	GetData(ctx context.Context, in *P2PGetData, opts ...grpc.CallOption) (P2Pgservice_GetDataClient, error)
	//获取头部
	GetHeaders(ctx context.Context, in *P2PGetHeaders, opts ...grpc.CallOption) (*P2PHeaders, error)
	//获取 peerinfo
	GetPeerInfo(ctx context.Context, in *P2PGetPeerInfo, opts ...grpc.CallOption) (*P2PPeerInfo, error)
	// grpc server 读客户端发送来的数据
	ServerStreamRead(ctx context.Context, opts ...grpc.CallOption) (P2Pgservice_ServerStreamReadClient, error)
	// grpc server 发送数据给客户端
	ServerStreamSend(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (P2Pgservice_ServerStreamSendClient, error)
	// grpc 收集inpeers
	CollectInPeers(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*PeerList, error)
	CollectInPeers2(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*PeersReply, error)
}

type p2PgserviceClient struct {
	cc grpc.ClientConnInterface
}

func NewP2PgserviceClient(cc grpc.ClientConnInterface) P2PgserviceClient {
	return &p2PgserviceClient{cc}
}

func (c *p2PgserviceClient) BroadCastTx(ctx context.Context, in *P2PTx, opts ...grpc.CallOption) (*Reply, error) {
	out := new(Reply)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/BroadCastTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) BroadCastBlock(ctx context.Context, in *P2PBlock, opts ...grpc.CallOption) (*Reply, error) {
	out := new(Reply)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/BroadCastBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) Ping(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*P2PPong, error) {
	out := new(P2PPong)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetAddr(ctx context.Context, in *P2PGetAddr, opts ...grpc.CallOption) (*P2PAddr, error) {
	out := new(P2PAddr)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetAddrList(ctx context.Context, in *P2PGetAddr, opts ...grpc.CallOption) (*P2PAddrList, error) {
	out := new(P2PAddrList)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetAddrList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) Version(ctx context.Context, in *P2PVersion, opts ...grpc.CallOption) (*P2PVerAck, error) {
	out := new(P2PVerAck)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) Version2(ctx context.Context, in *P2PVersion, opts ...grpc.CallOption) (*P2PVersion, error) {
	out := new(P2PVersion)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/Version2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) SoftVersion(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*Reply, error) {
	out := new(Reply)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/SoftVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetBlocks(ctx context.Context, in *P2PGetBlocks, opts ...grpc.CallOption) (*P2PInv, error) {
	out := new(P2PInv)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetBlocks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetMemPool(ctx context.Context, in *P2PGetMempool, opts ...grpc.CallOption) (*P2PInv, error) {
	out := new(P2PInv)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetMemPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetData(ctx context.Context, in *P2PGetData, opts ...grpc.CallOption) (P2Pgservice_GetDataClient, error) {
	stream, err := c.cc.NewStream(ctx, &_P2Pgservice_serviceDesc.Streams[0], "/types.p2pgservice/GetData", opts...)
	if err != nil {
		return nil, err
	}
	x := &p2PgserviceGetDataClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type P2Pgservice_GetDataClient interface {
	Recv() (*InvDatas, error)
	grpc.ClientStream
}

type p2PgserviceGetDataClient struct {
	grpc.ClientStream
}

func (x *p2PgserviceGetDataClient) Recv() (*InvDatas, error) {
	m := new(InvDatas)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *p2PgserviceClient) GetHeaders(ctx context.Context, in *P2PGetHeaders, opts ...grpc.CallOption) (*P2PHeaders, error) {
	out := new(P2PHeaders)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetHeaders", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) GetPeerInfo(ctx context.Context, in *P2PGetPeerInfo, opts ...grpc.CallOption) (*P2PPeerInfo, error) {
	out := new(P2PPeerInfo)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/GetPeerInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) ServerStreamRead(ctx context.Context, opts ...grpc.CallOption) (P2Pgservice_ServerStreamReadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_P2Pgservice_serviceDesc.Streams[1], "/types.p2pgservice/ServerStreamRead", opts...)
	if err != nil {
		return nil, err
	}
	x := &p2PgserviceServerStreamReadClient{stream}
	return x, nil
}

type P2Pgservice_ServerStreamReadClient interface {
	Send(*BroadCastData) error
	CloseAndRecv() (*ReqNil, error)
	grpc.ClientStream
}

type p2PgserviceServerStreamReadClient struct {
	grpc.ClientStream
}

func (x *p2PgserviceServerStreamReadClient) Send(m *BroadCastData) error {
	return x.ClientStream.SendMsg(m)
}

func (x *p2PgserviceServerStreamReadClient) CloseAndRecv() (*ReqNil, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(ReqNil)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *p2PgserviceClient) ServerStreamSend(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (P2Pgservice_ServerStreamSendClient, error) {
	stream, err := c.cc.NewStream(ctx, &_P2Pgservice_serviceDesc.Streams[2], "/types.p2pgservice/ServerStreamSend", opts...)
	if err != nil {
		return nil, err
	}
	x := &p2PgserviceServerStreamSendClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type P2Pgservice_ServerStreamSendClient interface {
	Recv() (*BroadCastData, error)
	grpc.ClientStream
}

type p2PgserviceServerStreamSendClient struct {
	grpc.ClientStream
}

func (x *p2PgserviceServerStreamSendClient) Recv() (*BroadCastData, error) {
	m := new(BroadCastData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *p2PgserviceClient) CollectInPeers(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*PeerList, error) {
	out := new(PeerList)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/CollectInPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *p2PgserviceClient) CollectInPeers2(ctx context.Context, in *P2PPing, opts ...grpc.CallOption) (*PeersReply, error) {
	out := new(PeersReply)
	err := c.cc.Invoke(ctx, "/types.p2pgservice/CollectInPeers2", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// P2PgserviceServer is the server API for P2Pgservice service.
type P2PgserviceServer interface {
	//广播交易
	BroadCastTx(context.Context, *P2PTx) (*Reply, error)
	//广播区块
	BroadCastBlock(context.Context, *P2PBlock) (*Reply, error)
	// PING
	Ping(context.Context, *P2PPing) (*P2PPong, error)
	//获取地址
	GetAddr(context.Context, *P2PGetAddr) (*P2PAddr, error)
	GetAddrList(context.Context, *P2PGetAddr) (*P2PAddrList, error)
	//版本
	Version(context.Context, *P2PVersion) (*P2PVerAck, error)
	//获取p2p协议的版本号
	Version2(context.Context, *P2PVersion) (*P2PVersion, error)
	//获取软件的版本号
	SoftVersion(context.Context, *P2PPing) (*Reply, error)
	//获取区块，最高200
	GetBlocks(context.Context, *P2PGetBlocks) (*P2PInv, error)
	//获取mempool
	GetMemPool(context.Context, *P2PGetMempool) (*P2PInv, error)
	//获取数据
	GetData(*P2PGetData, P2Pgservice_GetDataServer) error
	//获取头部
	GetHeaders(context.Context, *P2PGetHeaders) (*P2PHeaders, error)
	//获取 peerinfo
	GetPeerInfo(context.Context, *P2PGetPeerInfo) (*P2PPeerInfo, error)
	// grpc server 读客户端发送来的数据
	ServerStreamRead(P2Pgservice_ServerStreamReadServer) error
	// grpc server 发送数据给客户端
	ServerStreamSend(*P2PPing, P2Pgservice_ServerStreamSendServer) error
	// grpc 收集inpeers
	CollectInPeers(context.Context, *P2PPing) (*PeerList, error)
	CollectInPeers2(context.Context, *P2PPing) (*PeersReply, error)
}

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

func (*UnimplementedP2PgserviceServer) BroadCastTx(ctx context.Context, req *P2PTx) (*Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BroadCastTx not implemented")
}
func (*UnimplementedP2PgserviceServer) BroadCastBlock(ctx context.Context, req *P2PBlock) (*Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BroadCastBlock not implemented")
}
func (*UnimplementedP2PgserviceServer) Ping(ctx context.Context, req *P2PPing) (*P2PPong, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (*UnimplementedP2PgserviceServer) GetAddr(ctx context.Context, req *P2PGetAddr) (*P2PAddr, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAddr not implemented")
}
func (*UnimplementedP2PgserviceServer) GetAddrList(ctx context.Context, req *P2PGetAddr) (*P2PAddrList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAddrList not implemented")
}
func (*UnimplementedP2PgserviceServer) Version(ctx context.Context, req *P2PVersion) (*P2PVerAck, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (*UnimplementedP2PgserviceServer) Version2(ctx context.Context, req *P2PVersion) (*P2PVersion, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version2 not implemented")
}
func (*UnimplementedP2PgserviceServer) SoftVersion(ctx context.Context, req *P2PPing) (*Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SoftVersion not implemented")
}
func (*UnimplementedP2PgserviceServer) GetBlocks(ctx context.Context, req *P2PGetBlocks) (*P2PInv, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBlocks not implemented")
}
func (*UnimplementedP2PgserviceServer) GetMemPool(ctx context.Context, req *P2PGetMempool) (*P2PInv, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetMemPool not implemented")
}
func (*UnimplementedP2PgserviceServer) GetData(req *P2PGetData, srv P2Pgservice_GetDataServer) error {
	return status.Errorf(codes.Unimplemented, "method GetData not implemented")
}
func (*UnimplementedP2PgserviceServer) GetHeaders(ctx context.Context, req *P2PGetHeaders) (*P2PHeaders, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetHeaders not implemented")
}
func (*UnimplementedP2PgserviceServer) GetPeerInfo(ctx context.Context, req *P2PGetPeerInfo) (*P2PPeerInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPeerInfo not implemented")
}
func (*UnimplementedP2PgserviceServer) ServerStreamRead(srv P2Pgservice_ServerStreamReadServer) error {
	return status.Errorf(codes.Unimplemented, "method ServerStreamRead not implemented")
}
func (*UnimplementedP2PgserviceServer) ServerStreamSend(req *P2PPing, srv P2Pgservice_ServerStreamSendServer) error {
	return status.Errorf(codes.Unimplemented, "method ServerStreamSend not implemented")
}
func (*UnimplementedP2PgserviceServer) CollectInPeers(ctx context.Context, req *P2PPing) (*PeerList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectInPeers not implemented")
}
func (*UnimplementedP2PgserviceServer) CollectInPeers2(ctx context.Context, req *P2PPing) (*PeersReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollectInPeers2 not implemented")
}

func RegisterP2PgserviceServer(s *grpc.Server, srv P2PgserviceServer) {
	s.RegisterService(&_P2Pgservice_serviceDesc, srv)
}

func _P2Pgservice_BroadCastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PTx)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).BroadCastTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/BroadCastTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).BroadCastTx(ctx, req.(*P2PTx))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_BroadCastBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PBlock)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).BroadCastBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/BroadCastBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).BroadCastBlock(ctx, req.(*P2PBlock))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PPing)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).Ping(ctx, req.(*P2PPing))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetAddr)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetAddr(ctx, req.(*P2PGetAddr))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetAddrList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetAddr)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetAddrList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetAddrList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetAddrList(ctx, req.(*P2PGetAddr))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PVersion)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).Version(ctx, req.(*P2PVersion))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_Version2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PVersion)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).Version2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/Version2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).Version2(ctx, req.(*P2PVersion))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_SoftVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PPing)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).SoftVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/SoftVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).SoftVersion(ctx, req.(*P2PPing))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetBlocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetBlocks)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetBlocks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetBlocks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetBlocks(ctx, req.(*P2PGetBlocks))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetMemPool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetMempool)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetMemPool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetMemPool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetMemPool(ctx, req.(*P2PGetMempool))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetData_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(P2PGetData)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(P2PgserviceServer).GetData(m, &p2PgserviceGetDataServer{stream})
}

type P2Pgservice_GetDataServer interface {
	Send(*InvDatas) error
	grpc.ServerStream
}

type p2PgserviceGetDataServer struct {
	grpc.ServerStream
}

func (x *p2PgserviceGetDataServer) Send(m *InvDatas) error {
	return x.ServerStream.SendMsg(m)
}

func _P2Pgservice_GetHeaders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetHeaders)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetHeaders(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetHeaders",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetHeaders(ctx, req.(*P2PGetHeaders))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_GetPeerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PGetPeerInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).GetPeerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/GetPeerInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).GetPeerInfo(ctx, req.(*P2PGetPeerInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_ServerStreamRead_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(P2PgserviceServer).ServerStreamRead(&p2PgserviceServerStreamReadServer{stream})
}

type P2Pgservice_ServerStreamReadServer interface {
	SendAndClose(*ReqNil) error
	Recv() (*BroadCastData, error)
	grpc.ServerStream
}

type p2PgserviceServerStreamReadServer struct {
	grpc.ServerStream
}

func (x *p2PgserviceServerStreamReadServer) SendAndClose(m *ReqNil) error {
	return x.ServerStream.SendMsg(m)
}

func (x *p2PgserviceServerStreamReadServer) Recv() (*BroadCastData, error) {
	m := new(BroadCastData)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _P2Pgservice_ServerStreamSend_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(P2PPing)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(P2PgserviceServer).ServerStreamSend(m, &p2PgserviceServerStreamSendServer{stream})
}

type P2Pgservice_ServerStreamSendServer interface {
	Send(*BroadCastData) error
	grpc.ServerStream
}

type p2PgserviceServerStreamSendServer struct {
	grpc.ServerStream
}

func (x *p2PgserviceServerStreamSendServer) Send(m *BroadCastData) error {
	return x.ServerStream.SendMsg(m)
}

func _P2Pgservice_CollectInPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PPing)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).CollectInPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/CollectInPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).CollectInPeers(ctx, req.(*P2PPing))
	}
	return interceptor(ctx, in, info, handler)
}

func _P2Pgservice_CollectInPeers2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PPing)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(P2PgserviceServer).CollectInPeers2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/types.p2pgservice/CollectInPeers2",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(P2PgserviceServer).CollectInPeers2(ctx, req.(*P2PPing))
	}
	return interceptor(ctx, in, info, handler)
}

var _P2Pgservice_serviceDesc = grpc.ServiceDesc{
	ServiceName: "types.p2pgservice",
	HandlerType: (*P2PgserviceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "BroadCastTx",
			Handler:    _P2Pgservice_BroadCastTx_Handler,
		},
		{
			MethodName: "BroadCastBlock",
			Handler:    _P2Pgservice_BroadCastBlock_Handler,
		},
		{
			MethodName: "Ping",
			Handler:    _P2Pgservice_Ping_Handler,
		},
		{
			MethodName: "GetAddr",
			Handler:    _P2Pgservice_GetAddr_Handler,
		},
		{
			MethodName: "GetAddrList",
			Handler:    _P2Pgservice_GetAddrList_Handler,
		},
		{
			MethodName: "Version",
			Handler:    _P2Pgservice_Version_Handler,
		},
		{
			MethodName: "Version2",
			Handler:    _P2Pgservice_Version2_Handler,
		},
		{
			MethodName: "SoftVersion",
			Handler:    _P2Pgservice_SoftVersion_Handler,
		},
		{
			MethodName: "GetBlocks",
			Handler:    _P2Pgservice_GetBlocks_Handler,
		},
		{
			MethodName: "GetMemPool",
			Handler:    _P2Pgservice_GetMemPool_Handler,
		},
		{
			MethodName: "GetHeaders",
			Handler:    _P2Pgservice_GetHeaders_Handler,
		},
		{
			MethodName: "GetPeerInfo",
			Handler:    _P2Pgservice_GetPeerInfo_Handler,
		},
		{
			MethodName: "CollectInPeers",
			Handler:    _P2Pgservice_CollectInPeers_Handler,
		},
		{
			MethodName: "CollectInPeers2",
			Handler:    _P2Pgservice_CollectInPeers2_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetData",
			Handler:       _P2Pgservice_GetData_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ServerStreamRead",
			Handler:       _P2Pgservice_ServerStreamRead_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ServerStreamSend",
			Handler:       _P2Pgservice_ServerStreamSend_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "p2p.proto",
}
