node.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: node.proto

package pb

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	proto "github.com/gogo/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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// P2PREQTYPE denotes the particular type of request being used in the p2p rpc
type P2PREQTYPE int32

const (
	// equivalent of ipfs p2p close
	P2PREQTYPE_CLOSE P2PREQTYPE = 0
	// equivalent of ipfs p2p forward
	P2PREQTYPE_FORWARD P2PREQTYPE = 1
	// equivalent of ipfs p2p listen
	P2PREQTYPE_LISTEN P2PREQTYPE = 2
	// equivalent of ipfs p2p ls
	P2PREQTYPE_LS P2PREQTYPE = 3
)

var P2PREQTYPE_name = map[int32]string{
	0: "CLOSE",
	1: "FORWARD",
	2: "LISTEN",
	3: "LS",
}

var P2PREQTYPE_value = map[string]int32{
	"CLOSE":   0,
	"FORWARD": 1,
	"LISTEN":  2,
	"LS":      3,
}

func (x P2PREQTYPE) String() string {
	return proto.EnumName(P2PREQTYPE_name, int32(x))
}

func (P2PREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{0}
}

// CONNMGMTREQTYPE indicates the particular ConnMgmt request being performed
type CONNMGMTREQTYPE int32

const (
	// CM_CONNECT is used to connect to a libp2p peer
	CONNMGMTREQTYPE_CM_CONNECT CONNMGMTREQTYPE = 0
	// CM_DISCONNECT is used to disconnect from a libp2p peer
	CONNMGMTREQTYPE_CM_DISCONNECT CONNMGMTREQTYPE = 1
	// CM_STATUS is used to return status information about libp2p peer connections
	// useful for determining whether or not we are connected to someone
	CONNMGMTREQTYPE_CM_STATUS CONNMGMTREQTYPE = 2
	//CM_GET_PEERS is used to return all known peers
	CONNMGMTREQTYPE_CM_GET_PEERS CONNMGMTREQTYPE = 3
)

var CONNMGMTREQTYPE_name = map[int32]string{
	0: "CM_CONNECT",
	1: "CM_DISCONNECT",
	2: "CM_STATUS",
	3: "CM_GET_PEERS",
}

var CONNMGMTREQTYPE_value = map[string]int32{
	"CM_CONNECT":    0,
	"CM_DISCONNECT": 1,
	"CM_STATUS":     2,
	"CM_GET_PEERS":  3,
}

func (x CONNMGMTREQTYPE) String() string {
	return proto.EnumName(CONNMGMTREQTYPE_name, int32(x))
}

func (CONNMGMTREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{1}
}

// EXTRASREQTYPE indicates the particular Extras request being performed
type EXTRASREQTYPE int32

const (
	// EX_ENABLE is used to enable a particular node extras feature
	EXTRASREQTYPE_EX_ENABLE EXTRASREQTYPE = 0
	// EX_DISABLE is used to disable a particular node extras feature
	EXTRASREQTYPE_EX_DISABLE EXTRASREQTYPE = 1
)

var EXTRASREQTYPE_name = map[int32]string{
	0: "EX_ENABLE",
	1: "EX_DISABLE",
}

var EXTRASREQTYPE_value = map[string]int32{
	"EX_ENABLE":  0,
	"EX_DISABLE": 1,
}

func (x EXTRASREQTYPE) String() string {
	return proto.EnumName(EXTRASREQTYPE_name, int32(x))
}

func (EXTRASREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{2}
}

// EXTRASTYPE denotes a particular extras type
type EXTRASTYPE int32

const (
	// IDENTIFY is the identify service
	EXTRASTYPE_IDENTIFY EXTRASTYPE = 0
	// PUBSUB is the libp2p pubsub system
	EXTRASTYPE_PUBSUB EXTRASTYPE = 1
	// DISCOVERY is a libp2p discovery service
	EXTRASTYPE_DISCOVERY EXTRASTYPE = 2
	// MDNS is used to discover libp2p hosts over mdns
	EXTRASTYPE_MDNS EXTRASTYPE = 3
)

var EXTRASTYPE_name = map[int32]string{
	0: "IDENTIFY",
	1: "PUBSUB",
	2: "DISCOVERY",
	3: "MDNS",
}

var EXTRASTYPE_value = map[string]int32{
	"IDENTIFY":  0,
	"PUBSUB":    1,
	"DISCOVERY": 2,
	"MDNS":      3,
}

func (x EXTRASTYPE) String() string {
	return proto.EnumName(EXTRASTYPE_name, int32(x))
}

func (EXTRASTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{3}
}

// BSREQTYPE is a particular blockstore request type
type BSREQTYPE int32

const (
	// BS_DELETE is used to delete a block from the store
	BSREQTYPE_BS_DELETE BSREQTYPE = 0
	// BS_PUT is used to put a single block in the store
	BSREQTYPE_BS_PUT BSREQTYPE = 1
	// BS_PUT_MANY is used to put many blocks in the store
	BSREQTYPE_BS_PUT_MANY BSREQTYPE = 2
	// BS_GET is used to get a block from the store
	BSREQTYPE_BS_GET BSREQTYPE = 3
	// BS_GET_MANY is used to get many blocks from the store
	BSREQTYPE_BS_GET_MANY BSREQTYPE = 4
)

var BSREQTYPE_name = map[int32]string{
	0: "BS_DELETE",
	1: "BS_PUT",
	2: "BS_PUT_MANY",
	3: "BS_GET",
	4: "BS_GET_MANY",
}

var BSREQTYPE_value = map[string]int32{
	"BS_DELETE":   0,
	"BS_PUT":      1,
	"BS_PUT_MANY": 2,
	"BS_GET":      3,
	"BS_GET_MANY": 4,
}

func (x BSREQTYPE) String() string {
	return proto.EnumName(BSREQTYPE_name, int32(x))
}

func (BSREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{4}
}

// BSREQOPTS are options for blockstore requests
type BSREQOPTS int32

const (
	// DEFAULT indicates to use the default settings
	BSREQOPTS_DEFAULT BSREQOPTS = 0
	// BS_FORCE indicates to force the request regardless of any possible issues
	BSREQOPTS_BS_FORCE BSREQOPTS = 1
)

var BSREQOPTS_name = map[int32]string{
	0: "DEFAULT",
	1: "BS_FORCE",
}

var BSREQOPTS_value = map[string]int32{
	"DEFAULT":  0,
	"BS_FORCE": 1,
}

func (x BSREQOPTS) String() string {
	return proto.EnumName(BSREQOPTS_name, int32(x))
}

func (BSREQOPTS) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{5}
}

// DAGREQTYPE indicates the particular DagAPI request being performed
type DAGREQTYPE int32

const (
	// DAG_PUT is used to add new IPLD objects
	DAGREQTYPE_DAG_PUT DAGREQTYPE = 0
	// DAG_GET is used to retrieve IPLD object data
	DAGREQTYPE_DAG_GET DAGREQTYPE = 1
	// DAG_NEW_NODE is used to create a new IPLD node object
	DAGREQTYPE_DAG_NEW_NODE DAGREQTYPE = 2
	// DAG_ADD_LINKS is used to add links to an IPLD node object
	DAGREQTYPE_DAG_ADD_LINKS DAGREQTYPE = 3
	// DAG_GET_LINKS is used to retrieve all links contained in an IPLD node object
	DAGREQTYPE_DAG_GET_LINKS DAGREQTYPE = 4
)

var DAGREQTYPE_name = map[int32]string{
	0: "DAG_PUT",
	1: "DAG_GET",
	2: "DAG_NEW_NODE",
	3: "DAG_ADD_LINKS",
	4: "DAG_GET_LINKS",
}

var DAGREQTYPE_value = map[string]int32{
	"DAG_PUT":       0,
	"DAG_GET":       1,
	"DAG_NEW_NODE":  2,
	"DAG_ADD_LINKS": 3,
	"DAG_GET_LINKS": 4,
}

func (x DAGREQTYPE) String() string {
	return proto.EnumName(DAGREQTYPE_name, int32(x))
}

func (DAGREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{6}
}

// P2PRequest is a request message holding the details of a particular P2P rpc call
type P2PRequest struct {
	// indicates the request type
	RequestType P2PREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.P2PREQTYPE" json:"requestType,omitempty"`
	// used by: P2PREQTYPE.CLOSE
	All bool `protobuf:"varint,2,opt,name=all,proto3" json:"all,omitempty"`
	// used by: P2PREQTYPE.LS
	Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"`
	// used by: P2PREQTYPE.CLOSE, P2PREQTYPE.FORWARD, P2PREQTYPE.LISTEN
	ProtocolName string `protobuf:"bytes,4,opt,name=protocolName,proto3" json:"protocolName,omitempty"`
	// used by: P2PREQTYPE.CLOSE, P2PREQTYPE.FORWARD
	// must be specified as a multiaddr
	ListenAddress string `protobuf:"bytes,5,opt,name=listenAddress,proto3" json:"listenAddress,omitempty"`
	// used by: P2PREQTYPE.CLOSE, P2PREQTYPE.FORWARD
	// must be specified as a multiaddr
	TargetAddress string `protobuf:"bytes,6,opt,name=targetAddress,proto3" json:"targetAddress,omitempty"`
	// used by: P2PREQTYPE.LISTEN
	// must be specified as a multiaddr
	RemoteAddress string `protobuf:"bytes,7,opt,name=remoteAddress,proto3" json:"remoteAddress,omitempty"`
	// used by: P2PREQTYPE.LISTEN, P2PREQTYPE.FORWARD
	AllowCustomProtocols bool `protobuf:"varint,8,opt,name=allowCustomProtocols,proto3" json:"allowCustomProtocols,omitempty"`
	// used by: P2PREQTYPE.LISTEN
	ReportPeerID bool `protobuf:"varint,9,opt,name=reportPeerID,proto3" json:"reportPeerID,omitempty"`
}

func (m *P2PRequest) Reset()         { *m = P2PRequest{} }
func (m *P2PRequest) String() string { return proto.CompactTextString(m) }
func (*P2PRequest) ProtoMessage()    {}
func (*P2PRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{0}
}
func (m *P2PRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *P2PRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_P2PRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *P2PRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PRequest.Merge(m, src)
}
func (m *P2PRequest) XXX_Size() int {
	return m.Size()
}
func (m *P2PRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PRequest.DiscardUnknown(m)
}

var xxx_messageInfo_P2PRequest proto.InternalMessageInfo

func (m *P2PRequest) GetRequestType() P2PREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return P2PREQTYPE_CLOSE
}

func (m *P2PRequest) GetAll() bool {
	if m != nil {
		return m.All
	}
	return false
}

func (m *P2PRequest) GetVerbose() bool {
	if m != nil {
		return m.Verbose
	}
	return false
}

func (m *P2PRequest) GetProtocolName() string {
	if m != nil {
		return m.ProtocolName
	}
	return ""
}

func (m *P2PRequest) GetListenAddress() string {
	if m != nil {
		return m.ListenAddress
	}
	return ""
}

func (m *P2PRequest) GetTargetAddress() string {
	if m != nil {
		return m.TargetAddress
	}
	return ""
}

func (m *P2PRequest) GetRemoteAddress() string {
	if m != nil {
		return m.RemoteAddress
	}
	return ""
}

func (m *P2PRequest) GetAllowCustomProtocols() bool {
	if m != nil {
		return m.AllowCustomProtocols
	}
	return false
}

func (m *P2PRequest) GetReportPeerID() bool {
	if m != nil {
		return m.ReportPeerID
	}
	return false
}

// P2PResponse is a response message sent in response to a P2PRequest message
type P2PResponse struct {
	RequestType P2PREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.P2PREQTYPE" json:"requestType,omitempty"`
	// sent by: P2PREQTYPE.LISTEN
	Names []string `protobuf:"bytes,2,rep,name=names,proto3" json:"names,omitempty"`
	// sent by: P2PREQTYPE.CLOSE to indicate the number of connections closed
	ConnsClosed int32 `protobuf:"varint,3,opt,name=connsClosed,proto3" json:"connsClosed,omitempty"`
	// sent by: P2PREQTYPE.LS and contains all known stream information
	StreamInfos []*P2PLsInfo `protobuf:"bytes,4,rep,name=streamInfos,proto3" json:"streamInfos,omitempty"`
}

func (m *P2PResponse) Reset()         { *m = P2PResponse{} }
func (m *P2PResponse) String() string { return proto.CompactTextString(m) }
func (*P2PResponse) ProtoMessage()    {}
func (*P2PResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{1}
}
func (m *P2PResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *P2PResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_P2PResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *P2PResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PResponse.Merge(m, src)
}
func (m *P2PResponse) XXX_Size() int {
	return m.Size()
}
func (m *P2PResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PResponse.DiscardUnknown(m)
}

var xxx_messageInfo_P2PResponse proto.InternalMessageInfo

func (m *P2PResponse) GetRequestType() P2PREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return P2PREQTYPE_CLOSE
}

func (m *P2PResponse) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

func (m *P2PResponse) GetConnsClosed() int32 {
	if m != nil {
		return m.ConnsClosed
	}
	return 0
}

func (m *P2PResponse) GetStreamInfos() []*P2PLsInfo {
	if m != nil {
		return m.StreamInfos
	}
	return nil
}

// P2PLsInfo contains information about a single p2p stream
type P2PLsInfo struct {
	ProtocolName  string `protobuf:"bytes,1,opt,name=protocolName,proto3" json:"protocolName,omitempty"`
	ListenAddress string `protobuf:"bytes,2,opt,name=listenAddress,proto3" json:"listenAddress,omitempty"`
	TargetAddress string `protobuf:"bytes,3,opt,name=targetAddress,proto3" json:"targetAddress,omitempty"`
	// indicates whether or not this is a p2p listener or local listener
	Local bool `protobuf:"varint,4,opt,name=local,proto3" json:"local,omitempty"`
}

func (m *P2PLsInfo) Reset()         { *m = P2PLsInfo{} }
func (m *P2PLsInfo) String() string { return proto.CompactTextString(m) }
func (*P2PLsInfo) ProtoMessage()    {}
func (*P2PLsInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{2}
}
func (m *P2PLsInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *P2PLsInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_P2PLsInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *P2PLsInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_P2PLsInfo.Merge(m, src)
}
func (m *P2PLsInfo) XXX_Size() int {
	return m.Size()
}
func (m *P2PLsInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_P2PLsInfo.DiscardUnknown(m)
}

var xxx_messageInfo_P2PLsInfo proto.InternalMessageInfo

func (m *P2PLsInfo) GetProtocolName() string {
	if m != nil {
		return m.ProtocolName
	}
	return ""
}

func (m *P2PLsInfo) GetListenAddress() string {
	if m != nil {
		return m.ListenAddress
	}
	return ""
}

func (m *P2PLsInfo) GetTargetAddress() string {
	if m != nil {
		return m.TargetAddress
	}
	return ""
}

func (m *P2PLsInfo) GetLocal() bool {
	if m != nil {
		return m.Local
	}
	return false
}

// GetPeersResponse is a response to GetPeers containing a slice of peer IDs
type GetPeersResponse struct {
	// a slice of peer IDs
	PeerIDs []string `protobuf:"bytes,1,rep,name=peerIDs,proto3" json:"peerIDs,omitempty"`
}

func (m *GetPeersResponse) Reset()         { *m = GetPeersResponse{} }
func (m *GetPeersResponse) String() string { return proto.CompactTextString(m) }
func (*GetPeersResponse) ProtoMessage()    {}
func (*GetPeersResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{3}
}
func (m *GetPeersResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPeersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPeersResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetPeersResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPeersResponse.Merge(m, src)
}
func (m *GetPeersResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetPeersResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPeersResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetPeersResponse proto.InternalMessageInfo

func (m *GetPeersResponse) GetPeerIDs() []string {
	if m != nil {
		return m.PeerIDs
	}
	return nil
}

type ConnMgmtRequest struct {
	// indicates the particular connection management request being performed
	RequestType CONNMGMTREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.CONNMGMTREQTYPE" json:"requestType,omitempty"`
	// a list of multiaddrs
	// sent by: CM_CONNECT
	MultiAddrs []string `protobuf:"bytes,2,rep,name=multiAddrs,proto3" json:"multiAddrs,omitempty"`
	// a list of peer IDs
	// sent by: CM_DISCONNECT, CM_STATUS, CM_GET_PEERS
	PeerIDs []string `protobuf:"bytes,3,rep,name=peerIDs,proto3" json:"peerIDs,omitempty"`
}

func (m *ConnMgmtRequest) Reset()         { *m = ConnMgmtRequest{} }
func (m *ConnMgmtRequest) String() string { return proto.CompactTextString(m) }
func (*ConnMgmtRequest) ProtoMessage()    {}
func (*ConnMgmtRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{4}
}
func (m *ConnMgmtRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnMgmtRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnMgmtRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnMgmtRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnMgmtRequest.Merge(m, src)
}
func (m *ConnMgmtRequest) XXX_Size() int {
	return m.Size()
}
func (m *ConnMgmtRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnMgmtRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConnMgmtRequest proto.InternalMessageInfo

func (m *ConnMgmtRequest) GetRequestType() CONNMGMTREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return CONNMGMTREQTYPE_CM_CONNECT
}

func (m *ConnMgmtRequest) GetMultiAddrs() []string {
	if m != nil {
		return m.MultiAddrs
	}
	return nil
}

func (m *ConnMgmtRequest) GetPeerIDs() []string {
	if m != nil {
		return m.PeerIDs
	}
	return nil
}

type ConnMgmtResponse struct {
	// indicates the particular connection management request being performed
	RequestType CONNMGMTREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.CONNMGMTREQTYPE" json:"requestType,omitempty"`
	Connected   map[string]bool `protobuf:"bytes,2,rep,name=connected,proto3" json:"connected,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// a map of the peer id, and a custom message indicating success, or why there was a failure
	Status  map[string]*ConnMgmtStatus `protobuf:"bytes,3,rep,name=status,proto3" json:"status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	PeerIDs []string                   `protobuf:"bytes,4,rep,name=peerIDs,proto3" json:"peerIDs,omitempty"`
}

func (m *ConnMgmtResponse) Reset()         { *m = ConnMgmtResponse{} }
func (m *ConnMgmtResponse) String() string { return proto.CompactTextString(m) }
func (*ConnMgmtResponse) ProtoMessage()    {}
func (*ConnMgmtResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{5}
}
func (m *ConnMgmtResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnMgmtResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnMgmtResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnMgmtResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnMgmtResponse.Merge(m, src)
}
func (m *ConnMgmtResponse) XXX_Size() int {
	return m.Size()
}
func (m *ConnMgmtResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnMgmtResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ConnMgmtResponse proto.InternalMessageInfo

func (m *ConnMgmtResponse) GetRequestType() CONNMGMTREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return CONNMGMTREQTYPE_CM_CONNECT
}

func (m *ConnMgmtResponse) GetConnected() map[string]bool {
	if m != nil {
		return m.Connected
	}
	return nil
}

func (m *ConnMgmtResponse) GetStatus() map[string]*ConnMgmtStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ConnMgmtResponse) GetPeerIDs() []string {
	if m != nil {
		return m.PeerIDs
	}
	return nil
}

// Contains status information about a particular disconnect attempt
type ConnMgmtStatus struct {
	// indicate whether or not we actually disconnected
	Disconnected bool `protobuf:"varint,1,opt,name=disconnected,proto3" json:"disconnected,omitempty"`
	// if disconnected is false, the reason why it is false
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
}

func (m *ConnMgmtStatus) Reset()         { *m = ConnMgmtStatus{} }
func (m *ConnMgmtStatus) String() string { return proto.CompactTextString(m) }
func (*ConnMgmtStatus) ProtoMessage()    {}
func (*ConnMgmtStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{6}
}
func (m *ConnMgmtStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnMgmtStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnMgmtStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnMgmtStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnMgmtStatus.Merge(m, src)
}
func (m *ConnMgmtStatus) XXX_Size() int {
	return m.Size()
}
func (m *ConnMgmtStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnMgmtStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ConnMgmtStatus proto.InternalMessageInfo

func (m *ConnMgmtStatus) GetDisconnected() bool {
	if m != nil {
		return m.Disconnected
	}
	return false
}

func (m *ConnMgmtStatus) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

type ExtrasRequest struct {
	// indicates the request being performed
	RequestType EXTRASREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.EXTRASREQTYPE" json:"requestType,omitempty"`
	// indicates the extras feature this request applies to
	ExtrasFeature EXTRASTYPE `protobuf:"varint,2,opt,name=extrasFeature,proto3,enum=pb.EXTRASTYPE" json:"extrasFeature,omitempty"`
}

func (m *ExtrasRequest) Reset()         { *m = ExtrasRequest{} }
func (m *ExtrasRequest) String() string { return proto.CompactTextString(m) }
func (*ExtrasRequest) ProtoMessage()    {}
func (*ExtrasRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{7}
}
func (m *ExtrasRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExtrasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExtrasRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExtrasRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExtrasRequest.Merge(m, src)
}
func (m *ExtrasRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExtrasRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExtrasRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExtrasRequest proto.InternalMessageInfo

func (m *ExtrasRequest) GetRequestType() EXTRASREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return EXTRASREQTYPE_EX_ENABLE
}

func (m *ExtrasRequest) GetExtrasFeature() EXTRASTYPE {
	if m != nil {
		return m.ExtrasFeature
	}
	return EXTRASTYPE_IDENTIFY
}

// BlockstoreRequest is a message used to control blockstores
type BlockstoreRequest struct {
	// cids holds at least 1 cid, to hold 0 is considered an error
	Cids []string `protobuf:"bytes,1,rep,name=cids,proto3" json:"cids,omitempty"`
	// reqType is used to indicate the particular request being mande
	ReqType BSREQTYPE `protobuf:"varint,2,opt,name=reqType,proto3,enum=pb.BSREQTYPE" json:"reqType,omitempty"`
	// reqOpts is an optional parameter that can be used for fine-tuned request control
	ReqOpts BSREQOPTS `protobuf:"varint,3,opt,name=reqOpts,proto3,enum=pb.BSREQOPTS" json:"reqOpts,omitempty"`
}

func (m *BlockstoreRequest) Reset()         { *m = BlockstoreRequest{} }
func (m *BlockstoreRequest) String() string { return proto.CompactTextString(m) }
func (*BlockstoreRequest) ProtoMessage()    {}
func (*BlockstoreRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{8}
}
func (m *BlockstoreRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockstoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockstoreRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockstoreRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockstoreRequest.Merge(m, src)
}
func (m *BlockstoreRequest) XXX_Size() int {
	return m.Size()
}
func (m *BlockstoreRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockstoreRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BlockstoreRequest proto.InternalMessageInfo

func (m *BlockstoreRequest) GetCids() []string {
	if m != nil {
		return m.Cids
	}
	return nil
}

func (m *BlockstoreRequest) GetReqType() BSREQTYPE {
	if m != nil {
		return m.ReqType
	}
	return BSREQTYPE_BS_DELETE
}

func (m *BlockstoreRequest) GetReqOpts() BSREQOPTS {
	if m != nil {
		return m.ReqOpts
	}
	return BSREQOPTS_DEFAULT
}

// BlockstoreResponse is a response to a BlockstoreqRequest
type BlockstoreResponse struct {
	Blocks []*Block `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
}

func (m *BlockstoreResponse) Reset()         { *m = BlockstoreResponse{} }
func (m *BlockstoreResponse) String() string { return proto.CompactTextString(m) }
func (*BlockstoreResponse) ProtoMessage()    {}
func (*BlockstoreResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{9}
}
func (m *BlockstoreResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockstoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockstoreResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockstoreResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockstoreResponse.Merge(m, src)
}
func (m *BlockstoreResponse) XXX_Size() int {
	return m.Size()
}
func (m *BlockstoreResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockstoreResponse.DiscardUnknown(m)
}

var xxx_messageInfo_BlockstoreResponse proto.InternalMessageInfo

func (m *BlockstoreResponse) GetBlocks() []*Block {
	if m != nil {
		return m.Blocks
	}
	return nil
}

// Block is a single block of ipfs data
type Block struct {
	// cid is the identifier of the block
	Cid string `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
	// data is the actual contnets of this block
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *Block) Reset()         { *m = Block{} }
func (m *Block) String() string { return proto.CompactTextString(m) }
func (*Block) ProtoMessage()    {}
func (*Block) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{10}
}
func (m *Block) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Block.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Block) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Block.Merge(m, src)
}
func (m *Block) XXX_Size() int {
	return m.Size()
}
func (m *Block) XXX_DiscardUnknown() {
	xxx_messageInfo_Block.DiscardUnknown(m)
}

var xxx_messageInfo_Block proto.InternalMessageInfo

func (m *Block) GetCid() string {
	if m != nil {
		return m.Cid
	}
	return ""
}

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

// Used to submit a request to Dag or DagStream RPCs
type DagRequest struct {
	// indicates the request being performed
	// sent by: all request types
	RequestType DAGREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.DAGREQTYPE" json:"requestType,omitempty"`
	// data that we will be storing
	// sent by: DAG_PUT, DAG_NEW_NODE
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// the object encoding type (raw, cbor, protobuf, etc...)
	// sent by: DAG_PUT
	ObjectEncoding string `protobuf:"bytes,3,opt,name=objectEncoding,proto3" json:"objectEncoding,omitempty"`
	// the serialization format (raw, cbor, protobuf, etc...)
	// sent by: DAG_PUT
	SerializationFormat string `protobuf:"bytes,4,opt,name=serializationFormat,proto3" json:"serializationFormat,omitempty"`
	// the hash function to to use (sha2-256, sha3-512, etc...)
	// sent by: DAG_PUT, DAG_NEW_NODE, DAG_ADD_LINKS
	HashFunc string `protobuf:"bytes,5,opt,name=hashFunc,proto3" json:"hashFunc,omitempty"`
	// the cid version to use (0, 1)
	// sent by: DAG_PUT, DAG_NEW_NODE
	CidVersion int64 `protobuf:"varint,6,opt,name=cidVersion,proto3" json:"cidVersion,omitempty"`
	// the hash of the object we are processing
	// sent by: DAG_GET, DAG_NEW_NODe, DAG_ADD_LINKS, DAG_GET_LINKS
	Hash string `protobuf:"bytes,7,opt,name=hash,proto3" json:"hash,omitempty"`
	// indicates links and their names. key = name, value = link hash
	// sent by: DAG_NEW_NODE, DAG_ADD_LINKS
	Links map[string]string `protobuf:"bytes,8,rep,name=links,proto3" json:"links,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *DagRequest) Reset()         { *m = DagRequest{} }
func (m *DagRequest) String() string { return proto.CompactTextString(m) }
func (*DagRequest) ProtoMessage()    {}
func (*DagRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{11}
}
func (m *DagRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DagRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagRequest.Merge(m, src)
}
func (m *DagRequest) XXX_Size() int {
	return m.Size()
}
func (m *DagRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DagRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DagRequest proto.InternalMessageInfo

func (m *DagRequest) GetRequestType() DAGREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return DAGREQTYPE_DAG_PUT
}

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

func (m *DagRequest) GetObjectEncoding() string {
	if m != nil {
		return m.ObjectEncoding
	}
	return ""
}

func (m *DagRequest) GetSerializationFormat() string {
	if m != nil {
		return m.SerializationFormat
	}
	return ""
}

func (m *DagRequest) GetHashFunc() string {
	if m != nil {
		return m.HashFunc
	}
	return ""
}

func (m *DagRequest) GetCidVersion() int64 {
	if m != nil {
		return m.CidVersion
	}
	return 0
}

func (m *DagRequest) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *DagRequest) GetLinks() map[string]string {
	if m != nil {
		return m.Links
	}
	return nil
}

// Used in response to a Dag or DagStream RPC
type DagResponse struct {
	// indicates the request being performed
	// sent by: all request types
	RequestType DAGREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.DAGREQTYPE" json:"requestType,omitempty"`
	// returns the hashes of newly generated IPLD objects
	// sent by: DAG_PUT, DAG_NEW_NODE, DAG_ADD_LINKS, DAG_GET_LINKS
	Hashes []string `protobuf:"bytes,2,rep,name=hashes,proto3" json:"hashes,omitempty"`
	// the actual data contained by the IPLD object
	// sent by: DAG_GET
	RawData []byte `protobuf:"bytes,3,opt,name=rawData,proto3" json:"rawData,omitempty"`
	// the links contained within an IPLD node object
	// sent by: DAG_GET_LINKS
	Links []*IPLDLink `protobuf:"bytes,4,rep,name=links,proto3" json:"links,omitempty"`
}

func (m *DagResponse) Reset()         { *m = DagResponse{} }
func (m *DagResponse) String() string { return proto.CompactTextString(m) }
func (*DagResponse) ProtoMessage()    {}
func (*DagResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{12}
}
func (m *DagResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DagResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DagResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DagResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DagResponse.Merge(m, src)
}
func (m *DagResponse) XXX_Size() int {
	return m.Size()
}
func (m *DagResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DagResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DagResponse proto.InternalMessageInfo

func (m *DagResponse) GetRequestType() DAGREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return DAGREQTYPE_DAG_PUT
}

func (m *DagResponse) GetHashes() []string {
	if m != nil {
		return m.Hashes
	}
	return nil
}

func (m *DagResponse) GetRawData() []byte {
	if m != nil {
		return m.RawData
	}
	return nil
}

func (m *DagResponse) GetLinks() []*IPLDLink {
	if m != nil {
		return m.Links
	}
	return nil
}

// An IPFS MerkleDAG Link
type IPLDLink struct {
	// multihash of the target object
	Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	// utf string name. should be unique per object
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// cumulative size of target object
	Size_ uint64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
}

func (m *IPLDLink) Reset()         { *m = IPLDLink{} }
func (m *IPLDLink) String() string { return proto.CompactTextString(m) }
func (*IPLDLink) ProtoMessage()    {}
func (*IPLDLink) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{13}
}
func (m *IPLDLink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPLDLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPLDLink.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IPLDLink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPLDLink.Merge(m, src)
}
func (m *IPLDLink) XXX_Size() int {
	return m.Size()
}
func (m *IPLDLink) XXX_DiscardUnknown() {
	xxx_messageInfo_IPLDLink.DiscardUnknown(m)
}

var xxx_messageInfo_IPLDLink proto.InternalMessageInfo

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

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

func (m *IPLDLink) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

// An IPFS MerkleDAG Node
type IPLDNode struct {
	// refs to other objects
	Links []*IPLDLink `protobuf:"bytes,2,rep,name=links,proto3" json:"links,omitempty"`
	// opaque user data
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *IPLDNode) Reset()         { *m = IPLDNode{} }
func (m *IPLDNode) String() string { return proto.CompactTextString(m) }
func (*IPLDNode) ProtoMessage()    {}
func (*IPLDNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{14}
}
func (m *IPLDNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPLDNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPLDNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IPLDNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPLDNode.Merge(m, src)
}
func (m *IPLDNode) XXX_Size() int {
	return m.Size()
}
func (m *IPLDNode) XXX_DiscardUnknown() {
	xxx_messageInfo_IPLDNode.DiscardUnknown(m)
}

var xxx_messageInfo_IPLDNode proto.InternalMessageInfo

func (m *IPLDNode) GetLinks() []*IPLDLink {
	if m != nil {
		return m.Links
	}
	return nil
}

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

func init() {
	proto.RegisterEnum("pb.P2PREQTYPE", P2PREQTYPE_name, P2PREQTYPE_value)
	proto.RegisterEnum("pb.CONNMGMTREQTYPE", CONNMGMTREQTYPE_name, CONNMGMTREQTYPE_value)
	proto.RegisterEnum("pb.EXTRASREQTYPE", EXTRASREQTYPE_name, EXTRASREQTYPE_value)
	proto.RegisterEnum("pb.EXTRASTYPE", EXTRASTYPE_name, EXTRASTYPE_value)
	proto.RegisterEnum("pb.BSREQTYPE", BSREQTYPE_name, BSREQTYPE_value)
	proto.RegisterEnum("pb.BSREQOPTS", BSREQOPTS_name, BSREQOPTS_value)
	proto.RegisterEnum("pb.DAGREQTYPE", DAGREQTYPE_name, DAGREQTYPE_value)
	proto.RegisterType((*P2PRequest)(nil), "pb.P2PRequest")
	proto.RegisterType((*P2PResponse)(nil), "pb.P2PResponse")
	proto.RegisterType((*P2PLsInfo)(nil), "pb.P2PLsInfo")
	proto.RegisterType((*GetPeersResponse)(nil), "pb.GetPeersResponse")
	proto.RegisterType((*ConnMgmtRequest)(nil), "pb.ConnMgmtRequest")
	proto.RegisterType((*ConnMgmtResponse)(nil), "pb.ConnMgmtResponse")
	proto.RegisterMapType((map[string]bool)(nil), "pb.ConnMgmtResponse.ConnectedEntry")
	proto.RegisterMapType((map[string]*ConnMgmtStatus)(nil), "pb.ConnMgmtResponse.StatusEntry")
	proto.RegisterType((*ConnMgmtStatus)(nil), "pb.ConnMgmtStatus")
	proto.RegisterType((*ExtrasRequest)(nil), "pb.ExtrasRequest")
	proto.RegisterType((*BlockstoreRequest)(nil), "pb.BlockstoreRequest")
	proto.RegisterType((*BlockstoreResponse)(nil), "pb.BlockstoreResponse")
	proto.RegisterType((*Block)(nil), "pb.Block")
	proto.RegisterType((*DagRequest)(nil), "pb.DagRequest")
	proto.RegisterMapType((map[string]string)(nil), "pb.DagRequest.LinksEntry")
	proto.RegisterType((*DagResponse)(nil), "pb.DagResponse")
	proto.RegisterType((*IPLDLink)(nil), "pb.IPLDLink")
	proto.RegisterType((*IPLDNode)(nil), "pb.IPLDNode")
}

func init() { proto.RegisterFile("node.proto", fileDescriptor_0c843d59d2d938e7) }

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

// NodeAPIClient is the client API for NodeAPI service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NodeAPIClient interface {
	// ConnMgmt provides control over libp2p connections
	ConnMgmt(ctx context.Context, in *ConnMgmtRequest, opts ...grpc.CallOption) (*ConnMgmtResponse, error)
	// Extras provide control over node extras capabilities
	Extras(ctx context.Context, in *ExtrasRequest, opts ...grpc.CallOption) (*Empty, error)
	// P2P allows control of generalized p2p streams for tcp/udp based protocol.
	// By using this RPC, we can tunnel traffic similar to ssh tunneling
	// except using libp2p as the transport layer, and and tcp/udp port.
	P2P(ctx context.Context, in *P2PRequest, opts ...grpc.CallOption) (*P2PResponse, error)
	// Blockstore allows low-level management of the underlying blockstore
	Blockstore(ctx context.Context, in *BlockstoreRequest, opts ...grpc.CallOption) (*BlockstoreResponse, error)
	// Dag is a unidirectional rpc allowing manipulation of low-level ipld objects
	Dag(ctx context.Context, in *DagRequest, opts ...grpc.CallOption) (*DagResponse, error)
}

type nodeAPIClient struct {
	cc *grpc.ClientConn
}

func NewNodeAPIClient(cc *grpc.ClientConn) NodeAPIClient {
	return &nodeAPIClient{cc}
}

func (c *nodeAPIClient) ConnMgmt(ctx context.Context, in *ConnMgmtRequest, opts ...grpc.CallOption) (*ConnMgmtResponse, error) {
	out := new(ConnMgmtResponse)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/ConnMgmt", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeAPIClient) Extras(ctx context.Context, in *ExtrasRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/Extras", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeAPIClient) P2P(ctx context.Context, in *P2PRequest, opts ...grpc.CallOption) (*P2PResponse, error) {
	out := new(P2PResponse)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/P2P", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeAPIClient) Blockstore(ctx context.Context, in *BlockstoreRequest, opts ...grpc.CallOption) (*BlockstoreResponse, error) {
	out := new(BlockstoreResponse)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/Blockstore", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeAPIClient) Dag(ctx context.Context, in *DagRequest, opts ...grpc.CallOption) (*DagResponse, error) {
	out := new(DagResponse)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/Dag", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NodeAPIServer is the server API for NodeAPI service.
type NodeAPIServer interface {
	// ConnMgmt provides control over libp2p connections
	ConnMgmt(context.Context, *ConnMgmtRequest) (*ConnMgmtResponse, error)
	// Extras provide control over node extras capabilities
	Extras(context.Context, *ExtrasRequest) (*Empty, error)
	// P2P allows control of generalized p2p streams for tcp/udp based protocol.
	// By using this RPC, we can tunnel traffic similar to ssh tunneling
	// except using libp2p as the transport layer, and and tcp/udp port.
	P2P(context.Context, *P2PRequest) (*P2PResponse, error)
	// Blockstore allows low-level management of the underlying blockstore
	Blockstore(context.Context, *BlockstoreRequest) (*BlockstoreResponse, error)
	// Dag is a unidirectional rpc allowing manipulation of low-level ipld objects
	Dag(context.Context, *DagRequest) (*DagResponse, error)
}

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

func (*UnimplementedNodeAPIServer) ConnMgmt(ctx context.Context, req *ConnMgmtRequest) (*ConnMgmtResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConnMgmt not implemented")
}
func (*UnimplementedNodeAPIServer) Extras(ctx context.Context, req *ExtrasRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Extras not implemented")
}
func (*UnimplementedNodeAPIServer) P2P(ctx context.Context, req *P2PRequest) (*P2PResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method P2P not implemented")
}
func (*UnimplementedNodeAPIServer) Blockstore(ctx context.Context, req *BlockstoreRequest) (*BlockstoreResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Blockstore not implemented")
}
func (*UnimplementedNodeAPIServer) Dag(ctx context.Context, req *DagRequest) (*DagResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Dag not implemented")
}

func RegisterNodeAPIServer(s *grpc.Server, srv NodeAPIServer) {
	s.RegisterService(&_NodeAPI_serviceDesc, srv)
}

func _NodeAPI_ConnMgmt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnMgmtRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).ConnMgmt(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/ConnMgmt",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).ConnMgmt(ctx, req.(*ConnMgmtRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeAPI_Extras_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExtrasRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).Extras(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/Extras",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).Extras(ctx, req.(*ExtrasRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeAPI_P2P_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(P2PRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).P2P(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/P2P",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).P2P(ctx, req.(*P2PRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeAPI_Blockstore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockstoreRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).Blockstore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/Blockstore",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).Blockstore(ctx, req.(*BlockstoreRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NodeAPI_Dag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DagRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).Dag(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/Dag",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).Dag(ctx, req.(*DagRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NodeAPI_serviceDesc = grpc.ServiceDesc{
	ServiceName: "pb.NodeAPI",
	HandlerType: (*NodeAPIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ConnMgmt",
			Handler:    _NodeAPI_ConnMgmt_Handler,
		},
		{
			MethodName: "Extras",
			Handler:    _NodeAPI_Extras_Handler,
		},
		{
			MethodName: "P2P",
			Handler:    _NodeAPI_P2P_Handler,
		},
		{
			MethodName: "Blockstore",
			Handler:    _NodeAPI_Blockstore_Handler,
		},
		{
			MethodName: "Dag",
			Handler:    _NodeAPI_Dag_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "node.proto",
}

func (m *P2PRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *P2PRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *P2PRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReportPeerID {
		i--
		if m.ReportPeerID {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x48
	}
	if m.AllowCustomProtocols {
		i--
		if m.AllowCustomProtocols {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if len(m.RemoteAddress) > 0 {
		i -= len(m.RemoteAddress)
		copy(dAtA[i:], m.RemoteAddress)
		i = encodeVarintNode(dAtA, i, uint64(len(m.RemoteAddress)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.TargetAddress) > 0 {
		i -= len(m.TargetAddress)
		copy(dAtA[i:], m.TargetAddress)
		i = encodeVarintNode(dAtA, i, uint64(len(m.TargetAddress)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.ListenAddress) > 0 {
		i -= len(m.ListenAddress)
		copy(dAtA[i:], m.ListenAddress)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ListenAddress)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ProtocolName) > 0 {
		i -= len(m.ProtocolName)
		copy(dAtA[i:], m.ProtocolName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ProtocolName)))
		i--
		dAtA[i] = 0x22
	}
	if m.Verbose {
		i--
		if m.Verbose {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.All {
		i--
		if m.All {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *P2PResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *P2PResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *P2PResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.StreamInfos) > 0 {
		for iNdEx := len(m.StreamInfos) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StreamInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.ConnsClosed != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ConnsClosed))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Names) > 0 {
		for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Names[iNdEx])
			copy(dAtA[i:], m.Names[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.Names[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *P2PLsInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *P2PLsInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *P2PLsInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Local {
		i--
		if m.Local {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.TargetAddress) > 0 {
		i -= len(m.TargetAddress)
		copy(dAtA[i:], m.TargetAddress)
		i = encodeVarintNode(dAtA, i, uint64(len(m.TargetAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ListenAddress) > 0 {
		i -= len(m.ListenAddress)
		copy(dAtA[i:], m.ListenAddress)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ListenAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProtocolName) > 0 {
		i -= len(m.ProtocolName)
		copy(dAtA[i:], m.ProtocolName)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ProtocolName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetPeersResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetPeersResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetPeersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PeerIDs) > 0 {
		for iNdEx := len(m.PeerIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PeerIDs[iNdEx])
			copy(dAtA[i:], m.PeerIDs[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.PeerIDs[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ConnMgmtRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnMgmtRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnMgmtRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PeerIDs) > 0 {
		for iNdEx := len(m.PeerIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PeerIDs[iNdEx])
			copy(dAtA[i:], m.PeerIDs[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.PeerIDs[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.MultiAddrs) > 0 {
		for iNdEx := len(m.MultiAddrs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.MultiAddrs[iNdEx])
			copy(dAtA[i:], m.MultiAddrs[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.MultiAddrs[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ConnMgmtResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnMgmtResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnMgmtResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PeerIDs) > 0 {
		for iNdEx := len(m.PeerIDs) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PeerIDs[iNdEx])
			copy(dAtA[i:], m.PeerIDs[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.PeerIDs[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Status) > 0 {
		for k := range m.Status {
			v := m.Status[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintNode(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintNode(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintNode(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Connected) > 0 {
		for k := range m.Connected {
			v := m.Connected[k]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintNode(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintNode(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ConnMgmtStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConnMgmtStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ConnMgmtStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x12
	}
	if m.Disconnected {
		i--
		if m.Disconnected {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ExtrasRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExtrasRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExtrasRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExtrasFeature != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ExtrasFeature))
		i--
		dAtA[i] = 0x10
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BlockstoreRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockstoreRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockstoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReqOpts != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ReqOpts))
		i--
		dAtA[i] = 0x18
	}
	if m.ReqType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.ReqType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Cids) > 0 {
		for iNdEx := len(m.Cids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Cids[iNdEx])
			copy(dAtA[i:], m.Cids[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.Cids[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *BlockstoreResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockstoreResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockstoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Block) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Block) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Cid) > 0 {
		i -= len(m.Cid)
		copy(dAtA[i:], m.Cid)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Cid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DagRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DagRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Links) > 0 {
		for k := range m.Links {
			v := m.Links[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintNode(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintNode(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintNode(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x3a
	}
	if m.CidVersion != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CidVersion))
		i--
		dAtA[i] = 0x30
	}
	if len(m.HashFunc) > 0 {
		i -= len(m.HashFunc)
		copy(dAtA[i:], m.HashFunc)
		i = encodeVarintNode(dAtA, i, uint64(len(m.HashFunc)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SerializationFormat) > 0 {
		i -= len(m.SerializationFormat)
		copy(dAtA[i:], m.SerializationFormat)
		i = encodeVarintNode(dAtA, i, uint64(len(m.SerializationFormat)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ObjectEncoding) > 0 {
		i -= len(m.ObjectEncoding)
		copy(dAtA[i:], m.ObjectEncoding)
		i = encodeVarintNode(dAtA, i, uint64(len(m.ObjectEncoding)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DagResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DagResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DagResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Links) > 0 {
		for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.RawData) > 0 {
		i -= len(m.RawData)
		copy(dAtA[i:], m.RawData)
		i = encodeVarintNode(dAtA, i, uint64(len(m.RawData)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Hashes) > 0 {
		for iNdEx := len(m.Hashes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Hashes[iNdEx])
			copy(dAtA[i:], m.Hashes[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.Hashes[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *IPLDLink) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPLDLink) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IPLDLink) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IPLDNode) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IPLDNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IPLDNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Links) > 0 {
		for iNdEx := len(m.Links) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Links[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNode(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintNode(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintNode(dAtA []byte, offset int, v uint64) int {
	offset -= sovNode(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *P2PRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if m.All {
		n += 2
	}
	if m.Verbose {
		n += 2
	}
	l = len(m.ProtocolName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.ListenAddress)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.TargetAddress)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.RemoteAddress)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.AllowCustomProtocols {
		n += 2
	}
	if m.ReportPeerID {
		n += 2
	}
	return n
}

func (m *P2PResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if len(m.Names) > 0 {
		for _, s := range m.Names {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	if m.ConnsClosed != 0 {
		n += 1 + sovNode(uint64(m.ConnsClosed))
	}
	if len(m.StreamInfos) > 0 {
		for _, e := range m.StreamInfos {
			l = e.Size()
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *P2PLsInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProtocolName)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.ListenAddress)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.TargetAddress)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Local {
		n += 2
	}
	return n
}

func (m *GetPeersResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PeerIDs) > 0 {
		for _, s := range m.PeerIDs {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *ConnMgmtRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if len(m.MultiAddrs) > 0 {
		for _, s := range m.MultiAddrs {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	if len(m.PeerIDs) > 0 {
		for _, s := range m.PeerIDs {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *ConnMgmtResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if len(m.Connected) > 0 {
		for k, v := range m.Connected {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	if len(m.Status) > 0 {
		for k, v := range m.Status {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovNode(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	if len(m.PeerIDs) > 0 {
		for _, s := range m.PeerIDs {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *ConnMgmtStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Disconnected {
		n += 2
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	return n
}

func (m *ExtrasRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if m.ExtrasFeature != 0 {
		n += 1 + sovNode(uint64(m.ExtrasFeature))
	}
	return n
}

func (m *BlockstoreRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Cids) > 0 {
		for _, s := range m.Cids {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	if m.ReqType != 0 {
		n += 1 + sovNode(uint64(m.ReqType))
	}
	if m.ReqOpts != 0 {
		n += 1 + sovNode(uint64(m.ReqOpts))
	}
	return n
}

func (m *BlockstoreResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Blocks) > 0 {
		for _, e := range m.Blocks {
			l = e.Size()
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *Block) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Cid)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	return n
}

func (m *DagRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.ObjectEncoding)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.SerializationFormat)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.HashFunc)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.CidVersion != 0 {
		n += 1 + sovNode(uint64(m.CidVersion))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if len(m.Links) > 0 {
		for k, v := range m.Links {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + len(v) + sovNode(uint64(len(v)))
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *DagResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if len(m.Hashes) > 0 {
		for _, s := range m.Hashes {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	l = len(m.RawData)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if len(m.Links) > 0 {
		for _, e := range m.Links {
			l = e.Size()
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func (m *IPLDLink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovNode(uint64(m.Size_))
	}
	return n
}

func (m *IPLDNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if len(m.Links) > 0 {
		for _, e := range m.Links {
			l = e.Size()
			n += 1 + l + sovNode(uint64(l))
		}
	}
	return n
}

func sovNode(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozNode(x uint64) (n int) {
	return sovNode(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *P2PRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: P2PRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: P2PRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= P2PREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field All", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.All = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Verbose", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Verbose = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProtocolName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProtocolName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListenAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ListenAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoteAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RemoteAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowCustomProtocols", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowCustomProtocols = bool(v != 0)
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportPeerID", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReportPeerID = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *P2PResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: P2PResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: P2PResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= P2PREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Names = append(m.Names, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnsClosed", wireType)
			}
			m.ConnsClosed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnsClosed |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamInfos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StreamInfos = append(m.StreamInfos, &P2PLsInfo{})
			if err := m.StreamInfos[len(m.StreamInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *P2PLsInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: P2PLsInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: P2PLsInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProtocolName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProtocolName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListenAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ListenAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Local = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetPeersResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetPeersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetPeersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PeerIDs = append(m.PeerIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnMgmtRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnMgmtRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnMgmtRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= CONNMGMTREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultiAddrs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MultiAddrs = append(m.MultiAddrs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PeerIDs = append(m.PeerIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnMgmtResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnMgmtResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnMgmtResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= CONNMGMTREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connected", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Connected == nil {
				m.Connected = make(map[string]bool)
			}
			var mapkey string
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipNode(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthNode
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Connected[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = make(map[string]*ConnMgmtStatus)
			}
			var mapkey string
			var mapvalue *ConnMgmtStatus
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthNode
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthNode
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ConnMgmtStatus{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipNode(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthNode
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Status[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PeerIDs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PeerIDs = append(m.PeerIDs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnMgmtStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConnMgmtStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnMgmtStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Disconnected", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Disconnected = bool(v != 0)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExtrasRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExtrasRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExtrasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= EXTRASREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtrasFeature", wireType)
			}
			m.ExtrasFeature = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExtrasFeature |= EXTRASTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockstoreRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockstoreRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockstoreRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cids = append(m.Cids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReqType", wireType)
			}
			m.ReqType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReqType |= BSREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReqOpts", wireType)
			}
			m.ReqOpts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReqOpts |= BSREQOPTS(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockstoreResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockstoreResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockstoreResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Blocks = append(m.Blocks, &Block{})
			if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Block) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Block: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DagRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DagRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DagRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= DAGREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectEncoding", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ObjectEncoding = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SerializationFormat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SerializationFormat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HashFunc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HashFunc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CidVersion", wireType)
			}
			m.CidVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CidVersion |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Links == nil {
				m.Links = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthNode
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthNode
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipNode(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthNode
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Links[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DagResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DagResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DagResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestType", wireType)
			}
			m.RequestType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestType |= DAGREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hashes", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hashes = append(m.Hashes, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RawData = append(m.RawData[:0], dAtA[iNdEx:postIndex]...)
			if m.RawData == nil {
				m.RawData = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Links = append(m.Links, &IPLDLink{})
			if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPLDLink) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPLDLink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPLDLink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IPLDNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowNode
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IPLDNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPLDNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Links", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNode
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNode
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Links = append(m.Links, &IPLDLink{})
			if err := m.Links[len(m.Links)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNode(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthNode
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipNode(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowNode
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNode
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowNode
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthNode
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupNode
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthNode
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthNode        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNode          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNode = fmt.Errorf("proto: unexpected end of group")
)