// 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"
)

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

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

//*
// 请求获取远程节点的节点信息
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
}

//*
// p2p 发送交易协议
type P2PTx struct {
	Tx                   *Transaction `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,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{15}
}

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
}

//*
// 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{16}
}

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

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

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

func (*BroadCastData_Tx) isBroadCastData_Value() {}

func (*BroadCastData_Block) isBroadCastData_Value() {}

func (*BroadCastData_Ping) isBroadCastData_Value() {}

func (*BroadCastData_Version) 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
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BroadCastData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _BroadCastData_OneofMarshaler, _BroadCastData_OneofUnmarshaler, _BroadCastData_OneofSizer, []interface{}{
		(*BroadCastData_Tx)(nil),
		(*BroadCastData_Block)(nil),
		(*BroadCastData_Ping)(nil),
		(*BroadCastData_Version)(nil),
	}
}

func _BroadCastData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BroadCastData)
	// value
	switch x := m.Value.(type) {
	case *BroadCastData_Tx:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Tx); err != nil {
			return err
		}
	case *BroadCastData_Block:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Block); err != nil {
			return err
		}
	case *BroadCastData_Ping:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Ping); err != nil {
			return err
		}
	case *BroadCastData_Version:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Version); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("BroadCastData.Value has unexpected type %T", x)
	}
	return nil
}

func _BroadCastData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BroadCastData)
	switch tag {
	case 1: // value.tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(P2PTx)
		err := b.DecodeMessage(msg)
		m.Value = &BroadCastData_Tx{msg}
		return true, err
	case 2: // value.block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(P2PBlock)
		err := b.DecodeMessage(msg)
		m.Value = &BroadCastData_Block{msg}
		return true, err
	case 3: // value.ping
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(P2PPing)
		err := b.DecodeMessage(msg)
		m.Value = &BroadCastData_Ping{msg}
		return true, err
	case 4: // value.version
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Versions)
		err := b.DecodeMessage(msg)
		m.Value = &BroadCastData_Version{msg}
		return true, err
	default:
		return false, nil
	}
}

func _BroadCastData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BroadCastData)
	// value
	switch x := m.Value.(type) {
	case *BroadCastData_Tx:
		s := proto.Size(x.Tx)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BroadCastData_Block:
		s := proto.Size(x.Block)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BroadCastData_Ping:
		s := proto.Size(x.Ping)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BroadCastData_Version:
		s := proto.Size(x.Version)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

//*
// 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{19}
}

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

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

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_OneofFuncs is for the internal use of the proto package.
func (*InvData) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _InvData_OneofMarshaler, _InvData_OneofUnmarshaler, _InvData_OneofSizer, []interface{}{
		(*InvData_Tx)(nil),
		(*InvData_Block)(nil),
	}
}

func _InvData_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*InvData)
	// value
	switch x := m.Value.(type) {
	case *InvData_Tx:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Tx); err != nil {
			return err
		}
	case *InvData_Block:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Block); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("InvData.Value has unexpected type %T", x)
	}
	return nil
}

func _InvData_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*InvData)
	switch tag {
	case 1: // value.tx
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Transaction)
		err := b.DecodeMessage(msg)
		m.Value = &InvData_Tx{msg}
		return true, err
	case 2: // value.block
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Block)
		err := b.DecodeMessage(msg)
		m.Value = &InvData_Block{msg}
		return true, err
	default:
		return false, nil
	}
}

func _InvData_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*InvData)
	// value
	switch x := m.Value.(type) {
	case *InvData_Tx:
		s := proto.Size(x.Tx)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *InvData_Block:
		s := proto.Size(x.Block)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

//*
// 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{22}
}

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

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

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
}

//*
//当前节点的网络信息
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{25}
}

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

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

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

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

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

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

func NewP2PgserviceClient(cc *grpc.ClientConn) 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)
}

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