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
	// BS_GET_ALL is used to retrieve all blocks from the store
	// It is the gRPC equivalent of Blockstore::AllKeysChan
	BSREQTYPE_BS_GET_ALL BSREQTYPE = 5
	// BS_GET_STATS is used to retrieve statistics about individual blocks
	BSREQTYPE_BS_GET_STATS BSREQTYPE = 6
	// BS_HAS is used to retrieve whether or not we have the block
	BSREQTYPE_BS_HAS BSREQTYPE = 7
	// BS_HASH_ON_READ_ENABLE is used to enable hash on read
	BSREQTYPE_BS_HASH_ON_READ_ENABLE BSREQTYPE = 8
	// BS_HASH_ON_READ_DISABLE is used to disable hash on read
	BSREQTYPE_BS_HASH_ON_READ_DISABLE BSREQTYPE = 9
)

var BSREQTYPE_name = map[int32]string{
	0: "BS_DELETE",
	1: "BS_PUT",
	2: "BS_PUT_MANY",
	3: "BS_GET",
	4: "BS_GET_MANY",
	5: "BS_GET_ALL",
	6: "BS_GET_STATS",
	7: "BS_HAS",
	8: "BS_HASH_ON_READ_ENABLE",
	9: "BS_HASH_ON_READ_DISABLE",
}

var BSREQTYPE_value = map[string]int32{
	"BS_DELETE":               0,
	"BS_PUT":                  1,
	"BS_PUT_MANY":             2,
	"BS_GET":                  3,
	"BS_GET_MANY":             4,
	"BS_GET_ALL":              5,
	"BS_GET_STATS":            6,
	"BS_HAS":                  7,
	"BS_HASH_ON_READ_ENABLE":  8,
	"BS_HASH_ON_READ_DISABLE": 9,
}

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
	// DAG_STAT is used to retrieve ipld.NodeStats information
	DAGREQTYPE_DAG_STAT DAGREQTYPE = 5
)

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

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

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

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

// KSREQTYPE indicates the particular KeystoreAPI request being performed
type KSREQTYPE int32

const (
	// KS_HAS is used to check if the key exists in our keystore
	KSREQTYPE_KS_HAS KSREQTYPE = 0
	// KS_GET is used to retrieve private key bytes from our keystore
	KSREQTYPE_KS_GET KSREQTYPE = 1
	// KS_PUT is used to store private key bytes in our keystore
	KSREQTYPE_KS_PUT KSREQTYPE = 2
	// KS_DELETE is used to delete private keys from our keystore
	KSREQTYPE_KS_DELETE KSREQTYPE = 3
	// KS_LIST is used to list all keys in our keystore by their name
	KSREQTYPE_KS_LIST KSREQTYPE = 4
)

var KSREQTYPE_name = map[int32]string{
	0: "KS_HAS",
	1: "KS_GET",
	2: "KS_PUT",
	3: "KS_DELETE",
	4: "KS_LIST",
}

var KSREQTYPE_value = map[string]int32{
	"KS_HAS":    0,
	"KS_GET":    1,
	"KS_PUT":    2,
	"KS_DELETE": 3,
	"KS_LIST":   4,
}

func (x KSREQTYPE) String() string {
	return proto.EnumName(KSREQTYPE_name, int32(x))
}

func (KSREQTYPE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{7}
}

// 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 {
	//  indicates the particular request type being made
	RequestType BSREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.BSREQTYPE" json:"requestType,omitempty"`
	// optional request settings
	ReqOpts []BSREQOPTS `protobuf:"varint,2,rep,packed,name=reqOpts,proto3,enum=pb.BSREQOPTS" json:"reqOpts,omitempty"`
	// cids of blocks
	// sent by: BS_DELETE, BS_GET, BS_GET_MANY, BS_GET_STATS
	Cids []string `protobuf:"bytes,3,rep,name=cids,proto3" json:"cids,omitempty"`
	// the data we are putting
	// sent by: BS_PUT, BS_PUT_MANY
	Data [][]byte `protobuf:"bytes,4,rep,name=data,proto3" json:"data,omitempty"`
	// the cid version to use when constructing blocks, default is v1
	// sent by: BS_PUT, BS_PUT_MANY
	CidVersion string `protobuf:"bytes,5,opt,name=cidVersion,proto3" json:"cidVersion,omitempty"`
	// the hash function to use when constructing blocks, default is sha2-256
	// sent by: BS_PUT, BS_PUT_MANY
	HashFunc string `protobuf:"bytes,7,opt,name=hashFunc,proto3" json:"hashFunc,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) GetRequestType() BSREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return BSREQTYPE_BS_DELETE
}

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

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

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

func (m *BlockstoreRequest) GetCidVersion() string {
	if m != nil {
		return m.CidVersion
	}
	return ""
}

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

// BlockstoreResponse is a response to a BlockstoreqRequest
type BlockstoreResponse struct {
	// indicates the particular request type being made
	RequestType BSREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.BSREQTYPE" json:"requestType,omitempty"`
	// a copy of blocks from the blockstore
	// sent by: BS_PUT, BS_PUT_MANY, BS_GET, BS_GET_MANY, BS_GET_STATS, BS_GET_ALL
	//
	// in the case of BS_PUT, and BS_PUT_MANY requests
	// the data field will be empty as this is only populated
	// by get requests
	//
	// in the case of BS_GET_STATS only the cid, and size params
	// will be filled out, since we are just interested in the size
	Blocks []*Block `protobuf:"bytes,2,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) GetRequestType() BSREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return BSREQTYPE_BS_DELETE
}

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

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 contents of the block
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// size of the block, only filled out by BS_GET_STATS
	// since if we just want stats, we dont want to
	// retrieve all the data.
	Size_ int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,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
}

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

// 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"`
	// maps ipld cids to a ipld.NodeStat object equivalent
	// sent by: DAG_STAT
	NodeStats map[string]*IPLDStat `protobuf:"bytes,5,rep,name=nodeStats,proto3" json:"nodeStats,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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
}

func (m *DagResponse) GetNodeStats() map[string]*IPLDStat {
	if m != nil {
		return m.NodeStats
	}
	return nil
}

// IPLDStat is statistics about an individual dag node
// it is a protocol buffer wrapper around ipld.NodeStat
type IPLDStat struct {
	// number of links in link table
	NumLinks int64 `protobuf:"varint,1,opt,name=numLinks,proto3" json:"numLinks,omitempty"`
	// size of the raw, encoded data
	BlockSize int64 `protobuf:"varint,2,opt,name=blockSize,proto3" json:"blockSize,omitempty"`
	// size of the links segment
	LinkSize int64 `protobuf:"varint,3,opt,name=linkSize,proto3" json:"linkSize,omitempty"`
	// cumulative size of object and its references
	CumulativeSize int64 `protobuf:"varint,4,opt,name=cumulativeSize,proto3" json:"cumulativeSize,omitempty"`
	// size of the data segment
	DataSize int64 `protobuf:"varint,5,opt,name=dataSize,proto3" json:"dataSize,omitempty"`
}

func (m *IPLDStat) Reset()         { *m = IPLDStat{} }
func (m *IPLDStat) String() string { return proto.CompactTextString(m) }
func (*IPLDStat) ProtoMessage()    {}
func (*IPLDStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{13}
}
func (m *IPLDStat) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IPLDStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IPLDStat.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 *IPLDStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IPLDStat.Merge(m, src)
}
func (m *IPLDStat) XXX_Size() int {
	return m.Size()
}
func (m *IPLDStat) XXX_DiscardUnknown() {
	xxx_messageInfo_IPLDStat.DiscardUnknown(m)
}

var xxx_messageInfo_IPLDStat proto.InternalMessageInfo

func (m *IPLDStat) GetNumLinks() int64 {
	if m != nil {
		return m.NumLinks
	}
	return 0
}

func (m *IPLDStat) GetBlockSize() int64 {
	if m != nil {
		return m.BlockSize
	}
	return 0
}

func (m *IPLDStat) GetLinkSize() int64 {
	if m != nil {
		return m.LinkSize
	}
	return 0
}

func (m *IPLDStat) GetCumulativeSize() int64 {
	if m != nil {
		return m.CumulativeSize
	}
	return 0
}

func (m *IPLDStat) GetDataSize() int64 {
	if m != nil {
		return m.DataSize
	}
	return 0
}

// 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{14}
}
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{15}
}
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
}

// Used to submit a request to Keystore RPC
type KeystoreRequest struct {
	// indicates the request type being performed
	RequestType KSREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.KSREQTYPE" json:"requestType,omitempty"`
	// name of the key the request is for
	// sent by: KS_HAS, KS_GET, KS_PUT, KS_DELETE
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// the actual private key bytes
	// sent by: KS_PUT
	PrivateKey []byte `protobuf:"bytes,3,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
}

func (m *KeystoreRequest) Reset()         { *m = KeystoreRequest{} }
func (m *KeystoreRequest) String() string { return proto.CompactTextString(m) }
func (*KeystoreRequest) ProtoMessage()    {}
func (*KeystoreRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{16}
}
func (m *KeystoreRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeystoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeystoreRequest.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 *KeystoreRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeystoreRequest.Merge(m, src)
}
func (m *KeystoreRequest) XXX_Size() int {
	return m.Size()
}
func (m *KeystoreRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_KeystoreRequest.DiscardUnknown(m)
}

var xxx_messageInfo_KeystoreRequest proto.InternalMessageInfo

func (m *KeystoreRequest) GetRequestType() KSREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return KSREQTYPE_KS_HAS
}

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

func (m *KeystoreRequest) GetPrivateKey() []byte {
	if m != nil {
		return m.PrivateKey
	}
	return nil
}

// Used in response to a Keystore RPC
type KeystoreResponse struct {
	// indicates the request type being performed
	RequestType KSREQTYPE `protobuf:"varint,1,opt,name=requestType,proto3,enum=pb.KSREQTYPE" json:"requestType,omitempty"`
	// the private key bytes
	// sent by: KS_GET
	PrivateKey []byte `protobuf:"bytes,2,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
	// contains all known key names
	// sent by: KS_LIST
	KeyNames []string `protobuf:"bytes,3,rep,name=keyNames,proto3" json:"keyNames,omitempty"`
	// indicates if we have the key in our keystore
	// sent by: KS_HAS
	Has bool `protobuf:"varint,4,opt,name=has,proto3" json:"has,omitempty"`
}

func (m *KeystoreResponse) Reset()         { *m = KeystoreResponse{} }
func (m *KeystoreResponse) String() string { return proto.CompactTextString(m) }
func (*KeystoreResponse) ProtoMessage()    {}
func (*KeystoreResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{17}
}
func (m *KeystoreResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeystoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeystoreResponse.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 *KeystoreResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeystoreResponse.Merge(m, src)
}
func (m *KeystoreResponse) XXX_Size() int {
	return m.Size()
}
func (m *KeystoreResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_KeystoreResponse.DiscardUnknown(m)
}

var xxx_messageInfo_KeystoreResponse proto.InternalMessageInfo

func (m *KeystoreResponse) GetRequestType() KSREQTYPE {
	if m != nil {
		return m.RequestType
	}
	return KSREQTYPE_KS_HAS
}

func (m *KeystoreResponse) GetPrivateKey() []byte {
	if m != nil {
		return m.PrivateKey
	}
	return nil
}

func (m *KeystoreResponse) GetKeyNames() []string {
	if m != nil {
		return m.KeyNames
	}
	return nil
}

func (m *KeystoreResponse) GetHas() bool {
	if m != nil {
		return m.Has
	}
	return false
}

type PersistRequest struct {
	// cids to persist locally
	Cids []string `protobuf:"bytes,1,rep,name=cids,proto3" json:"cids,omitempty"`
}

func (m *PersistRequest) Reset()         { *m = PersistRequest{} }
func (m *PersistRequest) String() string { return proto.CompactTextString(m) }
func (*PersistRequest) ProtoMessage()    {}
func (*PersistRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{18}
}
func (m *PersistRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PersistRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PersistRequest.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 *PersistRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PersistRequest.Merge(m, src)
}
func (m *PersistRequest) XXX_Size() int {
	return m.Size()
}
func (m *PersistRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PersistRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PersistRequest proto.InternalMessageInfo

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

type PersistResponse struct {
	// key = cid, value = whether or not it was persisted
	Status map[string]bool `protobuf:"bytes,1,rep,name=status,proto3" json:"status,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// key = cid, value = error if not persisted
	Errors map[string]string `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *PersistResponse) Reset()         { *m = PersistResponse{} }
func (m *PersistResponse) String() string { return proto.CompactTextString(m) }
func (*PersistResponse) ProtoMessage()    {}
func (*PersistResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0c843d59d2d938e7, []int{19}
}
func (m *PersistResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PersistResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PersistResponse.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 *PersistResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PersistResponse.Merge(m, src)
}
func (m *PersistResponse) XXX_Size() int {
	return m.Size()
}
func (m *PersistResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PersistResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PersistResponse proto.InternalMessageInfo

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

func (m *PersistResponse) GetErrors() map[string]string {
	if m != nil {
		return m.Errors
	}
	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.RegisterEnum("pb.KSREQTYPE", KSREQTYPE_name, KSREQTYPE_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.RegisterMapType((map[string]*IPLDStat)(nil), "pb.DagResponse.NodeStatsEntry")
	proto.RegisterType((*IPLDStat)(nil), "pb.IPLDStat")
	proto.RegisterType((*IPLDLink)(nil), "pb.IPLDLink")
	proto.RegisterType((*IPLDNode)(nil), "pb.IPLDNode")
	proto.RegisterType((*KeystoreRequest)(nil), "pb.KeystoreRequest")
	proto.RegisterType((*KeystoreResponse)(nil), "pb.KeystoreResponse")
	proto.RegisterType((*PersistRequest)(nil), "pb.PersistRequest")
	proto.RegisterType((*PersistResponse)(nil), "pb.PersistResponse")
	proto.RegisterMapType((map[string]string)(nil), "pb.PersistResponse.ErrorsEntry")
	proto.RegisterMapType((map[string]bool)(nil), "pb.PersistResponse.StatusEntry")
}

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

var fileDescriptor_0c843d59d2d938e7 = []byte{
	// 1747 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x92, 0xe3, 0x48,
	0x11, 0xb6, 0xe4, 0x9f, 0xb6, 0xd3, 0xfd, 0xa3, 0xa9, 0x19, 0x06, 0x63, 0x08, 0xd3, 0x88, 0x8d,
	0xa5, 0xa3, 0x83, 0xe8, 0x99, 0xf0, 0x2e, 0x31, 0xb3, 0xc4, 0x12, 0x84, 0x6c, 0xc9, 0xbd, 0xc6,
	0xbf, 0x48, 0xee, 0xdd, 0x99, 0x93, 0x43, 0x6d, 0x17, 0x3d, 0xa2, 0x65, 0xc9, 0x2b, 0xc9, 0xbd,
	0xf4, 0x1c, 0x79, 0x02, 0x78, 0x02, 0x2e, 0x1c, 0x78, 0x03, 0x0e, 0xbc, 0x00, 0xc7, 0xe5, 0xb6,
	0x47, 0x62, 0xe6, 0xc0, 0x89, 0x07, 0xe0, 0x46, 0x64, 0x55, 0x49, 0x96, 0xbc, 0xea, 0xe8, 0x99,
	0xbd, 0x55, 0x66, 0x65, 0x66, 0x7d, 0xf9, 0xab, 0x14, 0x80, 0xe7, 0x2f, 0xe9, 0xd9, 0x3a, 0xf0,
	0x23, 0x9f, 0xc8, 0xeb, 0xcb, 0x26, 0x6c, 0x22, 0xc7, 0xe5, 0xb4, 0xfa, 0x8d, 0x0c, 0x30, 0x6d,
	0x4f, 0x4d, 0xfa, 0xe5, 0x86, 0x86, 0x11, 0x79, 0x0a, 0xf5, 0x80, 0x1f, 0x67, 0xb7, 0x6b, 0xda,
	0x90, 0x8e, 0xa5, 0x93, 0xc3, 0xf6, 0xe1, 0xd9, 0xfa, 0xf2, 0x0c, 0x85, 0x8c, 0xdf, 0xce, 0x5e,
	0x4e, 0x0d, 0x33, 0x2d, 0x42, 0x14, 0x28, 0xda, 0xae, 0xdb, 0x90, 0x8f, 0xa5, 0x93, 0xaa, 0x89,
	0x47, 0xd2, 0x80, 0xbd, 0x1b, 0x1a, 0x5c, 0xfa, 0x21, 0x6d, 0x14, 0x19, 0x37, 0x26, 0x89, 0x0a,
	0xfb, 0xec, 0xd5, 0x85, 0xef, 0x8e, 0xed, 0x15, 0x6d, 0x94, 0x8e, 0xa5, 0x93, 0x9a, 0x99, 0xe1,
	0x91, 0x0f, 0xe0, 0xc0, 0x75, 0xc2, 0x88, 0x7a, 0xda, 0x72, 0x19, 0xd0, 0x30, 0x6c, 0x94, 0x99,
	0x50, 0x96, 0x89, 0x52, 0x91, 0x1d, 0x5c, 0xd1, 0x28, 0x96, 0xaa, 0x70, 0xa9, 0x0c, 0x13, 0xa5,
	0x02, 0xba, 0xf2, 0x23, 0x1a, 0x4b, 0xed, 0x71, 0xa9, 0x0c, 0x93, 0xb4, 0xe1, 0x91, 0xed, 0xba,
	0xfe, 0x57, 0xdd, 0x4d, 0x18, 0xf9, 0xab, 0xa9, 0x00, 0x13, 0x36, 0xaa, 0x0c, 0x7c, 0xee, 0x1d,
	0x7a, 0x12, 0xd0, 0xb5, 0x1f, 0x44, 0x53, 0x4a, 0x83, 0xbe, 0xde, 0xa8, 0x31, 0xd9, 0x0c, 0x4f,
	0xfd, 0x9b, 0x04, 0x75, 0x16, 0xda, 0x70, 0xed, 0x7b, 0x21, 0xfd, 0x0e, 0xb1, 0x7d, 0x04, 0x65,
	0xcf, 0x5e, 0xd1, 0xb0, 0x21, 0x1f, 0x17, 0x4f, 0x6a, 0x26, 0x27, 0xc8, 0x31, 0xd4, 0x17, 0xbe,
	0xe7, 0x85, 0x5d, 0xd7, 0x0f, 0xe9, 0x92, 0xc5, 0xb8, 0x6c, 0xa6, 0x59, 0xe4, 0x09, 0xd4, 0xc3,
	0x28, 0xa0, 0xf6, 0xaa, 0xef, 0xfd, 0xce, 0x0f, 0x1b, 0xa5, 0xe3, 0xe2, 0x49, 0xbd, 0x7d, 0x20,
	0x5e, 0x1a, 0x86, 0xc8, 0x35, 0xd3, 0x12, 0xea, 0x9f, 0x25, 0xa8, 0x25, 0x57, 0xdf, 0x4a, 0x93,
	0xf4, 0x2e, 0x69, 0x92, 0xdf, 0x29, 0x4d, 0xc5, 0xbc, 0x34, 0x3d, 0x82, 0xb2, 0xeb, 0x2f, 0x6c,
	0x97, 0xd5, 0x43, 0xd5, 0xe4, 0x84, 0xfa, 0x73, 0x50, 0xce, 0x29, 0x8b, 0x65, 0x98, 0x84, 0xb0,
	0x01, 0x7b, 0x6b, 0x16, 0xdc, 0xb0, 0x21, 0xb1, 0x90, 0xc4, 0xa4, 0xfa, 0x47, 0x09, 0x8e, 0xba,
	0xbe, 0xe7, 0x8d, 0xae, 0x56, 0x51, 0x5c, 0xcc, 0xbf, 0xc8, 0x0b, 0xf8, 0x43, 0x0c, 0x43, 0x77,
	0x32, 0x1e, 0x8f, 0xce, 0x47, 0xb3, 0xdc, 0xa8, 0xb7, 0x00, 0x56, 0x1b, 0x37, 0x72, 0x10, 0x5e,
	0x1c, 0xfa, 0x14, 0x27, 0x0d, 0xa2, 0x98, 0x05, 0xf1, 0x5f, 0x19, 0x94, 0x2d, 0x08, 0x81, 0xf9,
	0x3b, 0xa2, 0xd0, 0xa0, 0x86, 0x29, 0xa5, 0x8b, 0x88, 0x2e, 0x19, 0x88, 0x7a, 0xfb, 0xa7, 0x4c,
	0x69, 0xc7, 0x3e, 0x63, 0x30, 0x29, 0xc3, 0x8b, 0x82, 0x5b, 0x73, 0xab, 0x45, 0x9e, 0x43, 0x25,
	0x8c, 0xec, 0x68, 0xc3, 0x71, 0xd6, 0xdb, 0xc7, 0xb9, 0xfa, 0x16, 0x13, 0xe1, 0xca, 0x42, 0x3e,
	0xed, 0x62, 0x29, 0xe3, 0x62, 0xf3, 0x53, 0x38, 0xcc, 0x3e, 0x88, 0x03, 0xe0, 0x9a, 0xde, 0x8a,
	0x22, 0xc1, 0x23, 0xe6, 0xf3, 0xc6, 0x76, 0x37, 0x54, 0x0c, 0x05, 0x4e, 0xfc, 0x52, 0x7e, 0x2e,
	0x35, 0x47, 0x50, 0x4f, 0x3d, 0x97, 0xa3, 0x7a, 0x92, 0x56, 0xad, 0xb7, 0x49, 0x1a, 0x31, 0xd7,
	0x4c, 0x99, 0x53, 0x87, 0x1c, 0xcc, 0xf6, 0x12, 0x4b, 0x77, 0xe9, 0x84, 0xdb, 0xc0, 0x49, 0xbc,
	0x2f, 0xd3, 0x3c, 0xf2, 0x18, 0x2a, 0x01, 0xb5, 0x43, 0xdf, 0x13, 0x35, 0x2b, 0x28, 0xf5, 0x35,
	0x1c, 0x18, 0x7f, 0x88, 0x02, 0x3b, 0x8c, 0xeb, 0xe7, 0xa3, 0xbc, 0xcc, 0x3d, 0x40, 0x48, 0xc6,
	0x8b, 0x99, 0xa9, 0x59, 0xb9, 0x79, 0xfb, 0x18, 0x0e, 0x28, 0xb3, 0xd2, 0xa3, 0x76, 0xb4, 0x09,
	0xb8, 0x27, 0xa2, 0xcf, 0xb9, 0x1a, 0xd3, 0xc9, 0x0a, 0xa9, 0xff, 0x92, 0xe0, 0x41, 0xc7, 0xf5,
	0x17, 0xd7, 0x61, 0xe4, 0x07, 0x34, 0x06, 0xf0, 0x24, 0x0f, 0x00, 0xeb, 0xe3, 0x4e, 0xfe, 0xe3,
	0x3f, 0x83, 0xbd, 0x80, 0x7e, 0x39, 0x59, 0x47, 0xbc, 0x6e, 0xd3, 0xc2, 0x93, 0xe9, 0xcc, 0x32,
	0xe3, 0x5b, 0x42, 0xa0, 0xb4, 0x70, 0x96, 0x71, 0x01, 0xb3, 0x33, 0xf2, 0x96, 0x76, 0x64, 0xb3,
	0x8c, 0xef, 0x9b, 0xec, 0x8c, 0xbd, 0xb0, 0x70, 0x96, 0x9f, 0xd3, 0x20, 0x74, 0x7c, 0x4f, 0x8c,
	0xe2, 0x14, 0x87, 0x34, 0xa1, 0xfa, 0xca, 0x0e, 0x5f, 0xf5, 0x36, 0xde, 0x42, 0x0c, 0xd7, 0x84,
	0x56, 0x5f, 0x01, 0x49, 0xbb, 0x24, 0xda, 0xe1, 0xbd, 0x7d, 0xfa, 0x09, 0x54, 0x2e, 0x99, 0x19,
	0xd1, 0x05, 0x35, 0x26, 0x8b, 0x1c, 0x53, 0x5c, 0xa8, 0x1a, 0x94, 0x19, 0x03, 0x0b, 0x6a, 0xe1,
	0x2c, 0xe3, 0x82, 0x5a, 0x38, 0xcb, 0xc4, 0x29, 0xcc, 0x42, 0xec, 0x14, 0x81, 0x52, 0xe8, 0xbc,
	0xe6, 0x5f, 0xa7, 0xa2, 0xc9, 0xce, 0xea, 0x7f, 0x64, 0x00, 0xdd, 0xbe, 0xba, 0xff, 0x3b, 0xa8,
	0x6b, 0xe7, 0xb9, 0x30, 0xf3, 0x1e, 0xfa, 0x10, 0x0e, 0xfd, 0xcb, 0xdf, 0xd3, 0x45, 0x64, 0x78,
	0x0b, 0x7f, 0xe9, 0x78, 0x57, 0x62, 0xfe, 0xed, 0x70, 0xc9, 0x53, 0x78, 0x18, 0xd2, 0xc0, 0xb1,
	0x5d, 0xe7, 0xb5, 0x1d, 0x39, 0xbe, 0xd7, 0xf3, 0x83, 0x95, 0x1d, 0x89, 0xcf, 0x63, 0xde, 0x55,
	0x26, 0xee, 0xe5, 0x6c, 0xdc, 0x77, 0x72, 0x56, 0x61, 0x4e, 0xa6, 0x73, 0x46, 0xa0, 0x84, 0xb2,
	0x22, 0x5f, 0xec, 0x4c, 0x9e, 0x40, 0xd9, 0x75, 0xbc, 0x6b, 0xfc, 0xe8, 0x61, 0x8c, 0x7f, 0xc0,
	0x3c, 0x4d, 0xc2, 0x71, 0x36, 0xc4, 0x3b, 0x3e, 0x22, 0xb8, 0x5c, 0xf3, 0x39, 0xc0, 0x96, 0x79,
	0xdf, 0x0c, 0xa8, 0xa5, 0x9b, 0xf6, 0x2f, 0x32, 0xd4, 0x99, 0xe9, 0x7b, 0x3f, 0x8b, 0x77, 0x85,
	0xfa, 0x31, 0x54, 0x10, 0x74, 0xf2, 0x5d, 0x14, 0x14, 0x4e, 0xad, 0xc0, 0xfe, 0x4a, 0xc7, 0x2c,
	0x14, 0x59, 0x16, 0x62, 0x92, 0xa8, 0xb1, 0x7b, 0xfc, 0x53, 0xb8, 0x8f, 0xd6, 0xfb, 0xd3, 0xa1,
	0x8e, 0x2e, 0x08, 0x8f, 0xc8, 0xa7, 0x50, 0xc3, 0x3d, 0x09, 0x07, 0x09, 0x2e, 0x1d, 0x28, 0xd7,
	0x4a, 0xc2, 0x20, 0x66, 0xe5, 0x38, 0x16, 0x10, 0xb3, 0x36, 0x51, 0x68, 0xfe, 0x06, 0x0e, 0xb3,
	0x97, 0x39, 0x31, 0x51, 0xb3, 0xc3, 0x2d, 0x41, 0x81, 0x4a, 0xe9, 0x08, 0xfd, 0x55, 0x82, 0x6a,
	0xcc, 0xc7, 0x4c, 0x7b, 0x9b, 0x15, 0x8b, 0x35, 0xb3, 0x55, 0x34, 0x13, 0x9a, 0xfc, 0x08, 0x6a,
	0xac, 0x03, 0x2c, 0xac, 0x66, 0x99, 0x5d, 0x6e, 0x19, 0xa8, 0x89, 0x9e, 0x59, 0xdb, 0x52, 0x4f,
	0x68, 0xac, 0xcc, 0xc5, 0x66, 0xb5, 0x71, 0xed, 0xc8, 0xb9, 0xa1, 0x4c, 0xa2, 0xc4, 0x24, 0x76,
	0xb8, 0x68, 0x03, 0x2b, 0x99, 0x49, 0x94, 0xb9, 0x8d, 0x98, 0x56, 0x7b, 0x1c, 0x25, 0x42, 0x49,
	0x6a, 0x4a, 0xe2, 0xd5, 0xcf, 0x6a, 0x8a, 0x40, 0x09, 0x17, 0x16, 0x51, 0x01, 0xec, 0x9c, 0x69,
	0xbd, 0x92, 0x68, 0xbd, 0x0e, 0xb7, 0x83, 0xe1, 0xdb, 0x26, 0x4a, 0xbe, 0x3b, 0x51, 0x71, 0xa7,
	0x49, 0xdb, 0x4e, 0x53, 0x6f, 0xe0, 0x68, 0x40, 0x6f, 0xdf, 0x71, 0x78, 0x0e, 0xac, 0xbb, 0x3a,
	0xf8, 0x5b, 0x78, 0x5b, 0x00, 0xeb, 0xc0, 0xb9, 0xb1, 0x23, 0x3a, 0xa0, 0xb7, 0xa2, 0xaa, 0x52,
	0x1c, 0x5c, 0x9c, 0x94, 0xed, 0xc3, 0xf7, 0x8e, 0xb8, 0x3b, 0x5e, 0xce, 0xbe, 0x22, 0xef, 0xbe,
	0x82, 0x59, 0xb8, 0xa6, 0xb7, 0x63, 0xb6, 0x0a, 0xf2, 0x89, 0x9d, 0xd0, 0x58, 0x66, 0xaf, 0xec,
	0x50, 0xac, 0x4e, 0x78, 0x54, 0x3f, 0x80, 0xc3, 0x29, 0xb6, 0x7a, 0x98, 0x2c, 0x42, 0xf1, 0xb4,
	0x97, 0xb6, 0xd3, 0x5e, 0xfd, 0x9f, 0x04, 0x47, 0x89, 0x98, 0x00, 0xfe, 0x2c, 0x59, 0x18, 0x24,
	0x16, 0xfe, 0x1f, 0xb3, 0x95, 0x31, 0x2b, 0x94, 0xbb, 0x2f, 0x3c, 0x83, 0x0a, 0x0d, 0x02, 0x3f,
	0x88, 0xf3, 0x96, 0xab, 0x68, 0x30, 0x09, 0xa1, 0xc8, 0xc5, 0x9b, 0x9f, 0xdc, 0xb7, 0x10, 0xdc,
	0xbd, 0x4b, 0x7c, 0x02, 0xf5, 0x94, 0xc5, 0xf7, 0x19, 0x41, 0xa7, 0xcf, 0xf9, 0x3f, 0x0f, 0x4f,
	0x05, 0xa9, 0x41, 0xb9, 0x3b, 0x9c, 0x58, 0x86, 0x52, 0x20, 0x75, 0xd8, 0xeb, 0x4d, 0xcc, 0x2f,
	0x34, 0x53, 0x57, 0x24, 0x02, 0x50, 0x19, 0xf6, 0xad, 0x99, 0x31, 0x56, 0x64, 0x52, 0x01, 0x79,
	0x68, 0x29, 0xc5, 0xd3, 0x0b, 0x38, 0xda, 0xd9, 0xda, 0xc8, 0x21, 0x40, 0x77, 0x34, 0x47, 0xae,
	0xd1, 0x9d, 0x29, 0x05, 0xf2, 0x00, 0x0e, 0xba, 0xa3, 0xb9, 0xde, 0xb7, 0x62, 0x96, 0x44, 0x0e,
	0xa0, 0xd6, 0x1d, 0xcd, 0xad, 0x99, 0x36, 0xbb, 0xb0, 0x14, 0x99, 0x28, 0xb0, 0xdf, 0x1d, 0xcd,
	0xcf, 0x8d, 0xd9, 0x7c, 0x6a, 0x18, 0x26, 0x9a, 0x3d, 0x83, 0x83, 0xcc, 0x4a, 0x81, 0x1a, 0xc6,
	0x8b, 0xb9, 0x31, 0xd6, 0x3a, 0x43, 0xc4, 0x75, 0x08, 0x60, 0xbc, 0x40, 0x9b, 0x8c, 0x96, 0x4e,
	0x7f, 0x8d, 0x74, 0xbc, 0x4b, 0x90, 0x7d, 0xa8, 0xf6, 0x75, 0x63, 0x3c, 0xeb, 0xf7, 0x5e, 0x2a,
	0x05, 0x84, 0x3d, 0xbd, 0xe8, 0x58, 0x17, 0x1d, 0xfe, 0x30, 0x03, 0xf2, 0xb9, 0x61, 0xbe, 0x54,
	0x64, 0x52, 0x85, 0xd2, 0x48, 0x1f, 0xe3, 0x83, 0xff, 0x90, 0xa0, 0xd6, 0x49, 0xbf, 0xd6, 0xb1,
	0xe6, 0xba, 0x31, 0x34, 0x66, 0x06, 0xb7, 0xd0, 0xb1, 0xe6, 0xd3, 0x0b, 0x84, 0x7e, 0x04, 0x75,
	0x7e, 0x9e, 0x8f, 0xb4, 0x31, 0xda, 0xe0, 0x97, 0xe7, 0xc6, 0x4c, 0x29, 0x8a, 0x4b, 0x74, 0x84,
	0x5d, 0x96, 0x10, 0xa7, 0x60, 0x68, 0xc3, 0xa1, 0x52, 0x46, 0x4f, 0x05, 0x8d, 0xce, 0x5b, 0x4a,
	0x45, 0xa8, 0x7f, 0xa6, 0x59, 0xca, 0x1e, 0x69, 0xc2, 0x63, 0x7e, 0xfe, 0x6c, 0x3e, 0x19, 0xcf,
	0x4d, 0x43, 0xd3, 0x63, 0x8f, 0xab, 0xe4, 0x87, 0xf0, 0xfd, 0xdd, 0xbb, 0xd8, 0xfd, 0xda, 0xe9,
	0x87, 0x02, 0x3c, 0xee, 0x34, 0x98, 0x33, 0xdd, 0xe8, 0x69, 0x17, 0x43, 0x0c, 0xfe, 0x3e, 0x54,
	0x3b, 0xd6, 0xbc, 0x37, 0x31, 0xbb, 0x18, 0x26, 0x17, 0x60, 0xfb, 0x0d, 0x61, 0x82, 0xda, 0x39,
	0xf3, 0xab, 0x10, 0x13, 0xe8, 0x87, 0x84, 0x30, 0x91, 0x18, 0x1b, 0x5f, 0xcc, 0xc7, 0x13, 0xdd,
	0x50, 0x64, 0x4c, 0x22, 0x72, 0x34, 0x5d, 0x9f, 0x0f, 0xfb, 0xe3, 0x81, 0xa5, 0x14, 0x63, 0x16,
	0x3a, 0xc3, 0x59, 0x25, 0x7c, 0x0d, 0x59, 0xe8, 0x9b, 0x52, 0x3e, 0x1d, 0x40, 0x2d, 0xe9, 0x6f,
	0xf4, 0x73, 0xc0, 0xfd, 0x2c, 0x88, 0x33, 0x7f, 0x8a, 0x9f, 0x11, 0x83, 0x8c, 0x61, 0x1f, 0x24,
	0x61, 0x2f, 0x22, 0xa4, 0x81, 0x35, 0xc7, 0x92, 0x53, 0x4a, 0xed, 0xbf, 0x17, 0x61, 0x0f, 0x27,
	0xa2, 0x36, 0xed, 0x93, 0x67, 0x50, 0x8d, 0xd7, 0x5c, 0xf2, 0x30, 0xbb, 0xc3, 0xb3, 0xfe, 0x6e,
	0x3e, 0xca, 0x5b, 0xec, 0xd5, 0x02, 0x39, 0x81, 0x0a, 0xdf, 0x68, 0x09, 0xdf, 0x5a, 0xd3, 0xdb,
	0x6d, 0x93, 0xed, 0x51, 0xc6, 0x6a, 0x1d, 0xdd, 0x32, 0xc9, 0xe2, 0xb4, 0x3d, 0x25, 0xc9, 0xdf,
	0xa8, 0x90, 0x39, 0x4a, 0xe8, 0xc4, 0xe6, 0xaf, 0x00, 0xb6, 0x5b, 0x1d, 0xf9, 0x5e, 0xb2, 0x8c,
	0xa5, 0x67, 0x6f, 0xf3, 0xf1, 0x2e, 0x3b, 0x51, 0x3f, 0x07, 0x65, 0xcb, 0xb7, 0xd8, 0x2f, 0xe8,
	0x7b, 0x1b, 0x39, 0x91, 0x9e, 0x4a, 0x88, 0x58, 0xb7, 0xaf, 0x38, 0xe2, 0xed, 0xa6, 0xc2, 0x11,
	0xa7, 0x3e, 0xd9, 0x6a, 0x01, 0xc3, 0x17, 0x8f, 0x68, 0x1e, 0xbe, 0x9d, 0x2f, 0x05, 0x0f, 0xdf,
	0xee, 0x14, 0x57, 0x0b, 0xe4, 0x63, 0xd8, 0x13, 0x33, 0x8c, 0x90, 0xcc, 0x40, 0xe3, 0x6a, 0x0f,
	0x73, 0x86, 0x9c, 0x5a, 0xe8, 0x34, 0xfe, 0xf9, 0xa6, 0x25, 0x7d, 0xfd, 0xa6, 0x25, 0xfd, 0xfb,
	0x4d, 0x4b, 0xfa, 0xd3, 0xdb, 0x56, 0xe1, 0xeb, 0xb7, 0xad, 0xc2, 0x37, 0x6f, 0x5b, 0x85, 0xcb,
	0x0a, 0xfb, 0x83, 0xfe, 0xe8, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x83, 0x57, 0x74, 0x90,
	0x11, 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)
	// BlockstoreStream is akin to Blockstore, except streamable
	// Once v4 is out, condense this + blockstore into a single call
	BlockstoreStream(ctx context.Context, opts ...grpc.CallOption) (NodeAPI_BlockstoreStreamClient, error)
	// Dag is a unidirectional rpc allowing manipulation of low-level ipld objects
	Dag(ctx context.Context, in *DagRequest, opts ...grpc.CallOption) (*DagResponse, error)
	// Keystore is a unidirectional RPC allowing management of ipfs keystores
	Keystore(ctx context.Context, in *KeystoreRequest, opts ...grpc.CallOption) (*KeystoreResponse, error)
	// Persist is used to retrieve data from the network and make it available locally
	Persist(ctx context.Context, in *PersistRequest, opts ...grpc.CallOption) (*PersistResponse, 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) BlockstoreStream(ctx context.Context, opts ...grpc.CallOption) (NodeAPI_BlockstoreStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_NodeAPI_serviceDesc.Streams[0], "/pb.NodeAPI/BlockstoreStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &nodeAPIBlockstoreStreamClient{stream}
	return x, nil
}

type NodeAPI_BlockstoreStreamClient interface {
	Send(*BlockstoreRequest) error
	Recv() (*BlockstoreResponse, error)
	grpc.ClientStream
}

type nodeAPIBlockstoreStreamClient struct {
	grpc.ClientStream
}

func (x *nodeAPIBlockstoreStreamClient) Send(m *BlockstoreRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *nodeAPIBlockstoreStreamClient) Recv() (*BlockstoreResponse, error) {
	m := new(BlockstoreResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, 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
}

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

func (c *nodeAPIClient) Persist(ctx context.Context, in *PersistRequest, opts ...grpc.CallOption) (*PersistResponse, error) {
	out := new(PersistResponse)
	err := c.cc.Invoke(ctx, "/pb.NodeAPI/Persist", 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)
	// BlockstoreStream is akin to Blockstore, except streamable
	// Once v4 is out, condense this + blockstore into a single call
	BlockstoreStream(NodeAPI_BlockstoreStreamServer) error
	// Dag is a unidirectional rpc allowing manipulation of low-level ipld objects
	Dag(context.Context, *DagRequest) (*DagResponse, error)
	// Keystore is a unidirectional RPC allowing management of ipfs keystores
	Keystore(context.Context, *KeystoreRequest) (*KeystoreResponse, error)
	// Persist is used to retrieve data from the network and make it available locally
	Persist(context.Context, *PersistRequest) (*PersistResponse, 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) BlockstoreStream(srv NodeAPI_BlockstoreStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method BlockstoreStream not implemented")
}
func (*UnimplementedNodeAPIServer) Dag(ctx context.Context, req *DagRequest) (*DagResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Dag not implemented")
}
func (*UnimplementedNodeAPIServer) Keystore(ctx context.Context, req *KeystoreRequest) (*KeystoreResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Keystore not implemented")
}
func (*UnimplementedNodeAPIServer) Persist(ctx context.Context, req *PersistRequest) (*PersistResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Persist 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_BlockstoreStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(NodeAPIServer).BlockstoreStream(&nodeAPIBlockstoreStreamServer{stream})
}

type NodeAPI_BlockstoreStreamServer interface {
	Send(*BlockstoreResponse) error
	Recv() (*BlockstoreRequest, error)
	grpc.ServerStream
}

type nodeAPIBlockstoreStreamServer struct {
	grpc.ServerStream
}

func (x *nodeAPIBlockstoreStreamServer) Send(m *BlockstoreResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

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)
}

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

func _NodeAPI_Persist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PersistRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NodeAPIServer).Persist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/pb.NodeAPI/Persist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NodeAPIServer).Persist(ctx, req.(*PersistRequest))
	}
	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,
		},
		{
			MethodName: "Keystore",
			Handler:    _NodeAPI_Keystore_Handler,
		},
		{
			MethodName: "Persist",
			Handler:    _NodeAPI_Persist_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BlockstoreStream",
			Handler:       _NodeAPI_BlockstoreStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	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 len(m.HashFunc) > 0 {
		i -= len(m.HashFunc)
		copy(dAtA[i:], m.HashFunc)
		i = encodeVarintNode(dAtA, i, uint64(len(m.HashFunc)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.CidVersion) > 0 {
		i -= len(m.CidVersion)
		copy(dAtA[i:], m.CidVersion)
		i = encodeVarintNode(dAtA, i, uint64(len(m.CidVersion)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Data[iNdEx])
			copy(dAtA[i:], m.Data[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.Data[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	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] = 0x1a
		}
	}
	if len(m.ReqOpts) > 0 {
		dAtA3 := make([]byte, len(m.ReqOpts)*10)
		var j2 int
		for _, num := range m.ReqOpts {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintNode(dAtA, i, uint64(j2))
		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 *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] = 0x12
		}
	}
	if m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	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 m.Size_ != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.Size_))
		i--
		dAtA[i] = 0x18
	}
	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.NodeStats) > 0 {
		for k := range m.NodeStats {
			v := m.NodeStats[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] = 0x2a
		}
	}
	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 *IPLDStat) 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 *IPLDStat) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IPLDStat) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DataSize != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.DataSize))
		i--
		dAtA[i] = 0x28
	}
	if m.CumulativeSize != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.CumulativeSize))
		i--
		dAtA[i] = 0x20
	}
	if m.LinkSize != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.LinkSize))
		i--
		dAtA[i] = 0x18
	}
	if m.BlockSize != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.BlockSize))
		i--
		dAtA[i] = 0x10
	}
	if m.NumLinks != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.NumLinks))
		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 (m *KeystoreRequest) 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 *KeystoreRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeystoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PrivateKey) > 0 {
		i -= len(m.PrivateKey)
		copy(dAtA[i:], m.PrivateKey)
		i = encodeVarintNode(dAtA, i, uint64(len(m.PrivateKey)))
		i--
		dAtA[i] = 0x1a
	}
	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 m.RequestType != 0 {
		i = encodeVarintNode(dAtA, i, uint64(m.RequestType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *KeystoreResponse) 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 *KeystoreResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeystoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Has {
		i--
		if m.Has {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.KeyNames) > 0 {
		for iNdEx := len(m.KeyNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.KeyNames[iNdEx])
			copy(dAtA[i:], m.KeyNames[iNdEx])
			i = encodeVarintNode(dAtA, i, uint64(len(m.KeyNames[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.PrivateKey) > 0 {
		i -= len(m.PrivateKey)
		copy(dAtA[i:], m.PrivateKey)
		i = encodeVarintNode(dAtA, i, uint64(len(m.PrivateKey)))
		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 *PersistRequest) 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 *PersistRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PersistRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 *PersistResponse) 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 *PersistResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PersistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Errors) > 0 {
		for k := range m.Errors {
			v := m.Errors[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] = 0x12
		}
	}
	if len(m.Status) > 0 {
		for k := range m.Status {
			v := m.Status[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] = 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 m.RequestType != 0 {
		n += 1 + sovNode(uint64(m.RequestType))
	}
	if len(m.ReqOpts) > 0 {
		l = 0
		for _, e := range m.ReqOpts {
			l += sovNode(uint64(e))
		}
		n += 1 + sovNode(uint64(l)) + l
	}
	if len(m.Cids) > 0 {
		for _, s := range m.Cids {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	if len(m.Data) > 0 {
		for _, b := range m.Data {
			l = len(b)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	l = len(m.CidVersion)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.HashFunc)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	return n
}

func (m *BlockstoreResponse) 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.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))
	}
	if m.Size_ != 0 {
		n += 1 + sovNode(uint64(m.Size_))
	}
	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))
		}
	}
	if len(m.NodeStats) > 0 {
		for k, v := range m.NodeStats {
			_ = 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))
		}
	}
	return n
}

func (m *IPLDStat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NumLinks != 0 {
		n += 1 + sovNode(uint64(m.NumLinks))
	}
	if m.BlockSize != 0 {
		n += 1 + sovNode(uint64(m.BlockSize))
	}
	if m.LinkSize != 0 {
		n += 1 + sovNode(uint64(m.LinkSize))
	}
	if m.CumulativeSize != 0 {
		n += 1 + sovNode(uint64(m.CumulativeSize))
	}
	if m.DataSize != 0 {
		n += 1 + sovNode(uint64(m.DataSize))
	}
	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 (m *KeystoreRequest) 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.Name)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	l = len(m.PrivateKey)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	return n
}

func (m *KeystoreResponse) 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.PrivateKey)
	if l > 0 {
		n += 1 + l + sovNode(uint64(l))
	}
	if len(m.KeyNames) > 0 {
		for _, s := range m.KeyNames {
			l = len(s)
			n += 1 + l + sovNode(uint64(l))
		}
	}
	if m.Has {
		n += 2
	}
	return n
}

func (m *PersistRequest) 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))
		}
	}
	return n
}

func (m *PersistResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Status) > 0 {
		for k, v := range m.Status {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + 1
			n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize))
		}
	}
	if len(m.Errors) > 0 {
		for k, v := range m.Errors {
			_ = 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 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 != 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 |= BSREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v BSREQOPTS
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= BSREQOPTS(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ReqOpts = append(m.ReqOpts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowNode
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthNode
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthNode
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.ReqOpts) == 0 {
					m.ReqOpts = make([]BSREQOPTS, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v BSREQOPTS
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowNode
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= BSREQOPTS(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ReqOpts = append(m.ReqOpts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ReqOpts", wireType)
			}
		case 3:
			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 4:
			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, make([]byte, postIndex-iNdEx))
			copy(m.Data[len(m.Data)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CidVersion", 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.CidVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			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
		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 != 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 |= BSREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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
		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_ |= int64(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 *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
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeStats", 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.NodeStats == nil {
				m.NodeStats = make(map[string]*IPLDStat)
			}
			var mapkey string
			var mapvalue *IPLDStat
			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 = &IPLDStat{}
					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.NodeStats[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 *IPLDStat) 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: IPLDStat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IPLDStat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumLinks", wireType)
			}
			m.NumLinks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumLinks |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockSize", wireType)
			}
			m.BlockSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkSize", wireType)
			}
			m.LinkSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LinkSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CumulativeSize", wireType)
			}
			m.CumulativeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CumulativeSize |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataSize", wireType)
			}
			m.DataSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNode
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataSize |= int64(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 *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 (m *KeystoreRequest) 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: KeystoreRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeystoreRequest: 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 |= KSREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrivateKey", 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.PrivateKey = append(m.PrivateKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PrivateKey == nil {
				m.PrivateKey = []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 *KeystoreResponse) 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: KeystoreResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeystoreResponse: 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 |= KSREQTYPE(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrivateKey", 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.PrivateKey = append(m.PrivateKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PrivateKey == nil {
				m.PrivateKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyNames", 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.KeyNames = append(m.KeyNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Has", 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.Has = 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 *PersistRequest) 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: PersistRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PersistRequest: 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
		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 *PersistResponse) 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: PersistResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PersistResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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]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.Status[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errors", 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.Errors == nil {
				m.Errors = 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.Errors[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 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")
)