Update vendor directory and make necessary code changes

Fixes for new geth version

vendor/github.com/ipfs/go-ipfs/core/.gitignore

@@ -0,0 +1 @@
+.testdb

vendor/github.com/ipfs/go-ipfs/core/bootstrap/bootstrap.go

@@ -0,0 +1,217 @@
+package bootstrap
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand"
+	"sync"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	"github.com/jbenet/goprocess"
+	"github.com/jbenet/goprocess/context"
+	"github.com/jbenet/goprocess/periodic"
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/peerstore"
+	"github.com/libp2p/go-libp2p-core/routing"
+	"github.com/libp2p/go-libp2p-loggables"
+)
+
+var log = logging.Logger("bootstrap")
+
+// ErrNotEnoughBootstrapPeers signals that we do not have enough bootstrap
+// peers to bootstrap correctly.
+var ErrNotEnoughBootstrapPeers = errors.New("not enough bootstrap peers to bootstrap")
+
+// BootstrapConfig specifies parameters used in an IpfsNode's network
+// bootstrapping process.
+type BootstrapConfig struct {
+	// MinPeerThreshold governs whether to bootstrap more connections. If the
+	// node has less open connections than this number, it will open connections
+	// to the bootstrap nodes. From there, the routing system should be able
+	// to use the connections to the bootstrap nodes to connect to even more
+	// peers. Routing systems like the IpfsDHT do so in their own Bootstrap
+	// process, which issues random queries to find more peers.
+	MinPeerThreshold int
+
+	// Period governs the periodic interval at which the node will
+	// attempt to bootstrap. The bootstrap process is not very expensive, so
+	// this threshold can afford to be small (<=30s).
+	Period time.Duration
+
+	// ConnectionTimeout determines how long to wait for a bootstrap
+	// connection attempt before cancelling it.
+	ConnectionTimeout time.Duration
+
+	// BootstrapPeers is a function that returns a set of bootstrap peers
+	// for the bootstrap process to use. This makes it possible for clients
+	// to control the peers the process uses at any moment.
+	BootstrapPeers func() []peer.AddrInfo
+}
+
+// DefaultBootstrapConfig specifies default sane parameters for bootstrapping.
+var DefaultBootstrapConfig = BootstrapConfig{
+	MinPeerThreshold:  4,
+	Period:            30 * time.Second,
+	ConnectionTimeout: (30 * time.Second) / 3, // Perod / 3
+}
+
+func BootstrapConfigWithPeers(pis []peer.AddrInfo) BootstrapConfig {
+	cfg := DefaultBootstrapConfig
+	cfg.BootstrapPeers = func() []peer.AddrInfo {
+		return pis
+	}
+	return cfg
+}
+
+// Bootstrap kicks off IpfsNode bootstrapping. This function will periodically
+// check the number of open connections and -- if there are too few -- initiate
+// connections to well-known bootstrap peers. It also kicks off subsystem
+// bootstrapping (i.e. routing).
+func Bootstrap(id peer.ID, host host.Host, rt routing.Routing, cfg BootstrapConfig) (io.Closer, error) {
+
+	// make a signal to wait for one bootstrap round to complete.
+	doneWithRound := make(chan struct{})
+
+	if len(cfg.BootstrapPeers()) == 0 {
+		// We *need* to bootstrap but we have no bootstrap peers
+		// configured *at all*, inform the user.
+		log.Warning("no bootstrap nodes configured: go-ipfs may have difficulty connecting to the network")
+	}
+
+	// the periodic bootstrap function -- the connection supervisor
+	periodic := func(worker goprocess.Process) {
+		ctx := goprocessctx.OnClosingContext(worker)
+		defer log.EventBegin(ctx, "periodicBootstrap", id).Done()
+
+		if err := bootstrapRound(ctx, host, cfg); err != nil {
+			log.Event(ctx, "bootstrapError", id, loggables.Error(err))
+			log.Debugf("%s bootstrap error: %s", id, err)
+		}
+
+		<-doneWithRound
+	}
+
+	// kick off the node's periodic bootstrapping
+	proc := periodicproc.Tick(cfg.Period, periodic)
+	proc.Go(periodic) // run one right now.
+
+	// kick off Routing.Bootstrap
+	if rt != nil {
+		ctx := goprocessctx.OnClosingContext(proc)
+		if err := rt.Bootstrap(ctx); err != nil {
+			proc.Close()
+			return nil, err
+		}
+	}
+
+	doneWithRound <- struct{}{}
+	close(doneWithRound) // it no longer blocks periodic
+	return proc, nil
+}
+
+func bootstrapRound(ctx context.Context, host host.Host, cfg BootstrapConfig) error {
+
+	ctx, cancel := context.WithTimeout(ctx, cfg.ConnectionTimeout)
+	defer cancel()
+	id := host.ID()
+
+	// get bootstrap peers from config. retrieving them here makes
+	// sure we remain observant of changes to client configuration.
+	peers := cfg.BootstrapPeers()
+	// determine how many bootstrap connections to open
+	connected := host.Network().Peers()
+	if len(connected) >= cfg.MinPeerThreshold {
+		log.Event(ctx, "bootstrapSkip", id)
+		log.Debugf("%s core bootstrap skipped -- connected to %d (> %d) nodes",
+			id, len(connected), cfg.MinPeerThreshold)
+		return nil
+	}
+	numToDial := cfg.MinPeerThreshold - len(connected)
+
+	// filter out bootstrap nodes we are already connected to
+	var notConnected []peer.AddrInfo
+	for _, p := range peers {
+		if host.Network().Connectedness(p.ID) != network.Connected {
+			notConnected = append(notConnected, p)
+		}
+	}
+
+	// if connected to all bootstrap peer candidates, exit
+	if len(notConnected) < 1 {
+		log.Debugf("%s no more bootstrap peers to create %d connections", id, numToDial)
+		return ErrNotEnoughBootstrapPeers
+	}
+
+	// connect to a random susbset of bootstrap candidates
+	randSubset := randomSubsetOfPeers(notConnected, numToDial)
+
+	defer log.EventBegin(ctx, "bootstrapStart", id).Done()
+	log.Debugf("%s bootstrapping to %d nodes: %s", id, numToDial, randSubset)
+	return bootstrapConnect(ctx, host, randSubset)
+}
+
+func bootstrapConnect(ctx context.Context, ph host.Host, peers []peer.AddrInfo) error {
+	if len(peers) < 1 {
+		return ErrNotEnoughBootstrapPeers
+	}
+
+	errs := make(chan error, len(peers))
+	var wg sync.WaitGroup
+	for _, p := range peers {
+
+		// performed asynchronously because when performed synchronously, if
+		// one `Connect` call hangs, subsequent calls are more likely to
+		// fail/abort due to an expiring context.
+		// Also, performed asynchronously for dial speed.
+
+		wg.Add(1)
+		go func(p peer.AddrInfo) {
+			defer wg.Done()
+			defer log.EventBegin(ctx, "bootstrapDial", ph.ID(), p.ID).Done()
+			log.Debugf("%s bootstrapping to %s", ph.ID(), p.ID)
+
+			ph.Peerstore().AddAddrs(p.ID, p.Addrs, peerstore.PermanentAddrTTL)
+			if err := ph.Connect(ctx, p); err != nil {
+				log.Event(ctx, "bootstrapDialFailed", p.ID)
+				log.Debugf("failed to bootstrap with %v: %s", p.ID, err)
+				errs <- err
+				return
+			}
+			log.Event(ctx, "bootstrapDialSuccess", p.ID)
+			log.Infof("bootstrapped with %v", p.ID)
+		}(p)
+	}
+	wg.Wait()
+
+	// our failure condition is when no connection attempt succeeded.
+	// So drain the errs channel, counting the results.
+	close(errs)
+	count := 0
+	var err error
+	for err = range errs {
+		if err != nil {
+			count++
+		}
+	}
+	if count == len(peers) {
+		return fmt.Errorf("failed to bootstrap. %s", err)
+	}
+	return nil
+}
+
+func randomSubsetOfPeers(in []peer.AddrInfo, max int) []peer.AddrInfo {
+	if max > len(in) {
+		max = len(in)
+	}
+
+	out := make([]peer.AddrInfo, max)
+	for i, val := range rand.Perm(len(in))[:max] {
+		out[i] = in[val]
+	}
+	return out
+}

vendor/github.com/ipfs/go-ipfs/core/builder.go

@@ -0,0 +1,65 @@
+package core
+
+import (
+	"context"
+	"sync"
+
+	"github.com/ipfs/go-ipfs/core/bootstrap"
+	"github.com/ipfs/go-ipfs/core/node"
+
+	"github.com/ipfs/go-metrics-interface"
+	"go.uber.org/fx"
+)
+
+type BuildCfg = node.BuildCfg // Alias for compatibility until we properly refactor the constructor interface
+
+// NewNode constructs and returns an IpfsNode using the given cfg.
+func NewNode(ctx context.Context, cfg *BuildCfg) (*IpfsNode, error) {
+	ctx = metrics.CtxScope(ctx, "ipfs")
+
+	n := &IpfsNode{
+		ctx: ctx,
+	}
+
+	app := fx.New(
+		node.IPFS(ctx, cfg),
+
+		fx.NopLogger,
+		fx.Extract(n),
+	)
+
+	var once sync.Once
+	var stopErr error
+	n.stop = func() error {
+		once.Do(func() {
+			stopErr = app.Stop(context.Background())
+		})
+		return stopErr
+	}
+	n.IsOnline = cfg.Online
+
+	go func() {
+		// Note that some services use contexts to signal shutting down, which is
+		// very suboptimal. This needs to be here until that's addressed somehow
+		<-ctx.Done()
+		err := n.stop()
+		if err != nil {
+			log.Error("failure on stop: ", err)
+		}
+	}()
+
+	if app.Err() != nil {
+		return nil, app.Err()
+	}
+
+	if err := app.Start(ctx); err != nil {
+		return nil, err
+	}
+
+	// TODO: How soon will bootstrap move to libp2p?
+	if !cfg.Online {
+		return n, nil
+	}
+
+	return n, n.Bootstrap(bootstrap.DefaultBootstrapConfig)
+}

vendor/github.com/ipfs/go-ipfs/core/core.go

@@ -0,0 +1,178 @@
+/*
+Package core implements the IpfsNode object and related methods.
+
+Packages underneath core/ provide a (relatively) stable, low-level API
+to carry out most IPFS-related tasks.  For more details on the other
+interfaces and how core/... fits into the bigger IPFS picture, see:
+
+  $ godoc github.com/ipfs/go-ipfs
+*/
+package core
+
+import (
+	"context"
+	"io"
+
+	version "github.com/ipfs/go-ipfs"
+	"github.com/ipfs/go-ipfs/core/bootstrap"
+	"github.com/ipfs/go-ipfs/core/node"
+	"github.com/ipfs/go-ipfs/core/node/libp2p"
+	"github.com/ipfs/go-ipfs/filestore"
+	"github.com/ipfs/go-ipfs/fuse/mount"
+	"github.com/ipfs/go-ipfs/namesys"
+	ipnsrp "github.com/ipfs/go-ipfs/namesys/republisher"
+	"github.com/ipfs/go-ipfs/p2p"
+	"github.com/ipfs/go-ipfs/pin"
+	"github.com/ipfs/go-ipfs/provider"
+	"github.com/ipfs/go-ipfs/repo"
+
+	bserv "github.com/ipfs/go-blockservice"
+	bstore "github.com/ipfs/go-ipfs-blockstore"
+	exchange "github.com/ipfs/go-ipfs-exchange-interface"
+	ipld "github.com/ipfs/go-ipld-format"
+	logging "github.com/ipfs/go-log"
+	mfs "github.com/ipfs/go-mfs"
+	resolver "github.com/ipfs/go-path/resolver"
+	goprocess "github.com/jbenet/goprocess"
+	autonat "github.com/libp2p/go-libp2p-autonat-svc"
+	connmgr "github.com/libp2p/go-libp2p-core/connmgr"
+	ic "github.com/libp2p/go-libp2p-core/crypto"
+	p2phost "github.com/libp2p/go-libp2p-core/host"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	pstore "github.com/libp2p/go-libp2p-core/peerstore"
+	routing "github.com/libp2p/go-libp2p-core/routing"
+	dht "github.com/libp2p/go-libp2p-kad-dht"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	psrouter "github.com/libp2p/go-libp2p-pubsub-router"
+	record "github.com/libp2p/go-libp2p-record"
+	"github.com/libp2p/go-libp2p/p2p/discovery"
+	p2pbhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
+)
+
+var log = logging.Logger("core")
+
+func init() {
+	identify.ClientVersion = "go-ipfs/" + version.CurrentVersionNumber + "/" + version.CurrentCommit
+}
+
+// IpfsNode is IPFS Core module. It represents an IPFS instance.
+type IpfsNode struct {
+
+	// Self
+	Identity peer.ID // the local node's identity
+
+	Repo repo.Repo
+
+	// Local node
+	Pinning         pin.Pinner             // the pinning manager
+	Mounts          Mounts                 `optional:"true"` // current mount state, if any.
+	PrivateKey      ic.PrivKey             `optional:"true"` // the local node's private Key
+	PNetFingerprint libp2p.PNetFingerprint `optional:"true"` // fingerprint of private network
+
+	// Services
+	Peerstore       pstore.Peerstore     `optional:"true"` // storage for other Peer instances
+	Blockstore      bstore.GCBlockstore  // the block store (lower level)
+	Filestore       *filestore.Filestore `optional:"true"` // the filestore blockstore
+	BaseBlocks      node.BaseBlocks      // the raw blockstore, no filestore wrapping
+	GCLocker        bstore.GCLocker      // the locker used to protect the blockstore during gc
+	Blocks          bserv.BlockService   // the block service, get/add blocks.
+	DAG             ipld.DAGService      // the merkle dag service, get/add objects.
+	Resolver        *resolver.Resolver   // the path resolution system
+	Reporter        metrics.Reporter     `optional:"true"`
+	Discovery       discovery.Service    `optional:"true"`
+	FilesRoot       *mfs.Root
+	RecordValidator record.Validator
+
+	// Online
+	PeerHost     p2phost.Host        `optional:"true"` // the network host (server+client)
+	Bootstrapper io.Closer           `optional:"true"` // the periodic bootstrapper
+	Routing      routing.Routing     `optional:"true"` // the routing system. recommend ipfs-dht
+	Exchange     exchange.Interface  // the block exchange + strategy (bitswap)
+	Namesys      namesys.NameSystem  // the name system, resolves paths to hashes
+	Provider     provider.System     // the value provider system
+	IpnsRepub    *ipnsrp.Republisher `optional:"true"`
+
+	AutoNAT  *autonat.AutoNATService    `optional:"true"`
+	PubSub   *pubsub.PubSub             `optional:"true"`
+	PSRouter *psrouter.PubsubValueStore `optional:"true"`
+	DHT      *dht.IpfsDHT               `optional:"true"`
+	P2P      *p2p.P2P                   `optional:"true"`
+
+	Process goprocess.Process
+	ctx     context.Context
+
+	stop func() error
+
+	// Flags
+	IsOnline bool `optional:"true"` // Online is set when networking is enabled.
+	IsDaemon bool `optional:"true"` // Daemon is set when running on a long-running daemon.
+}
+
+// Mounts defines what the node's mount state is. This should
+// perhaps be moved to the daemon or mount. It's here because
+// it needs to be accessible across daemon requests.
+type Mounts struct {
+	Ipfs mount.Mount
+	Ipns mount.Mount
+}
+
+// Close calls Close() on the App object
+func (n *IpfsNode) Close() error {
+	return n.stop()
+}
+
+// Context returns the IpfsNode context
+func (n *IpfsNode) Context() context.Context {
+	if n.ctx == nil {
+		n.ctx = context.TODO()
+	}
+	return n.ctx
+}
+
+// Bootstrap will set and call the IpfsNodes bootstrap function.
+func (n *IpfsNode) Bootstrap(cfg bootstrap.BootstrapConfig) error {
+	// TODO what should return value be when in offlineMode?
+	if n.Routing == nil {
+		return nil
+	}
+
+	if n.Bootstrapper != nil {
+		n.Bootstrapper.Close() // stop previous bootstrap process.
+	}
+
+	// if the caller did not specify a bootstrap peer function, get the
+	// freshest bootstrap peers from config. this responds to live changes.
+	if cfg.BootstrapPeers == nil {
+		cfg.BootstrapPeers = func() []peer.AddrInfo {
+			ps, err := n.loadBootstrapPeers()
+			if err != nil {
+				log.Warning("failed to parse bootstrap peers from config")
+				return nil
+			}
+			return ps
+		}
+	}
+
+	var err error
+	n.Bootstrapper, err = bootstrap.Bootstrap(n.Identity, n.PeerHost, n.Routing, cfg)
+	return err
+}
+
+func (n *IpfsNode) loadBootstrapPeers() ([]peer.AddrInfo, error) {
+	cfg, err := n.Repo.Config()
+	if err != nil {
+		return nil, err
+	}
+
+	return cfg.BootstrapPeers()
+}
+
+type ConstructPeerHostOpts struct {
+	AddrsFactory      p2pbhost.AddrsFactory
+	DisableNatPortMap bool
+	DisableRelay      bool
+	EnableRelayHop    bool
+	ConnectionManager connmgr.ConnManager
+}

vendor/github.com/ipfs/go-ipfs/core/coredag/cbor.go

@@ -0,0 +1,32 @@
+package coredag
+
+import (
+	"io"
+	"io/ioutil"
+
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
+	ipld "github.com/ipfs/go-ipld-format"
+)
+
+func cborJSONParser(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	nd, err := ipldcbor.FromJSON(r, mhType, mhLen)
+	if err != nil {
+		return nil, err
+	}
+
+	return []ipld.Node{nd}, nil
+}
+
+func cborRawParser(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	nd, err := ipldcbor.Decode(data, mhType, mhLen)
+	if err != nil {
+		return nil, err
+	}
+
+	return []ipld.Node{nd}, nil
+}

vendor/github.com/ipfs/go-ipfs/core/coredag/dagpb.go

@@ -0,0 +1,66 @@
+package coredag
+
+import (
+	"io"
+	"io/ioutil"
+	"math"
+
+	"github.com/ipfs/go-merkledag"
+
+	cid "github.com/ipfs/go-cid"
+	ipld "github.com/ipfs/go-ipld-format"
+	mh "github.com/multiformats/go-multihash"
+)
+
+func dagpbJSONParser(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	nd := &merkledag.ProtoNode{}
+
+	err = nd.UnmarshalJSON(data)
+	if err != nil {
+		return nil, err
+	}
+
+	nd.SetCidBuilder(cidPrefix(mhType, mhLen))
+
+	return []ipld.Node{nd}, nil
+}
+
+func dagpbRawParser(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	nd, err := merkledag.DecodeProtobuf(data)
+	if err != nil {
+		return nil, err
+	}
+
+	nd.SetCidBuilder(cidPrefix(mhType, mhLen))
+
+	return []ipld.Node{nd}, nil
+}
+
+func cidPrefix(mhType uint64, mhLen int) *cid.Prefix {
+	if mhType == math.MaxUint64 {
+		mhType = mh.SHA2_256
+	}
+
+	prefix := &cid.Prefix{
+		MhType:   mhType,
+		MhLength: mhLen,
+		Version:  1,
+		Codec:    cid.DagProtobuf,
+	}
+
+	if mhType == mh.SHA2_256 {
+		prefix.Version = 0
+	}
+
+	return prefix
+}

vendor/github.com/ipfs/go-ipfs/core/coredag/dagtransl.go

@@ -0,0 +1,86 @@
+package coredag
+
+import (
+	"fmt"
+	"io"
+
+	ipld "github.com/ipfs/go-ipld-format"
+)
+
+// DagParser is function used for parsing stream into Node
+type DagParser func(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error)
+
+// FormatParsers is used for mapping format descriptors to DagParsers
+type FormatParsers map[string]DagParser
+
+// InputEncParsers is used for mapping input encodings to FormatParsers
+type InputEncParsers map[string]FormatParsers
+
+// DefaultInputEncParsers is InputEncParser that is used everywhere
+var DefaultInputEncParsers = InputEncParsers{
+	"json":     defaultJSONParsers,
+	"raw":      defaultRawParsers,
+	"cbor":     defaultCborParsers,
+	"protobuf": defaultProtobufParsers,
+}
+
+var defaultJSONParsers = FormatParsers{
+	"cbor":     cborJSONParser,
+	"dag-cbor": cborJSONParser,
+
+	"protobuf": dagpbJSONParser,
+	"dag-pb":   dagpbJSONParser,
+}
+
+var defaultRawParsers = FormatParsers{
+	"cbor":     cborRawParser,
+	"dag-cbor": cborRawParser,
+
+	"protobuf": dagpbRawParser,
+	"dag-pb":   dagpbRawParser,
+
+	"raw": rawRawParser,
+}
+
+var defaultCborParsers = FormatParsers{
+	"cbor":     cborRawParser,
+	"dag-cbor": cborRawParser,
+}
+
+var defaultProtobufParsers = FormatParsers{
+	"protobuf": dagpbRawParser,
+	"dag-pb":   dagpbRawParser,
+}
+
+// ParseInputs uses DefaultInputEncParsers to parse io.Reader described by
+// input encoding and format to an instance of ipld Node
+func ParseInputs(ienc, format string, r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	return DefaultInputEncParsers.ParseInputs(ienc, format, r, mhType, mhLen)
+}
+
+// AddParser adds DagParser under give input encoding and format
+func (iep InputEncParsers) AddParser(ienc, format string, f DagParser) {
+	m, ok := iep[ienc]
+	if !ok {
+		m = make(FormatParsers)
+		iep[ienc] = m
+	}
+
+	m[format] = f
+}
+
+// ParseInputs parses io.Reader described by input encoding and format to
+// an instance of ipld Node
+func (iep InputEncParsers) ParseInputs(ienc, format string, r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	parsers, ok := iep[ienc]
+	if !ok {
+		return nil, fmt.Errorf("no input parser for %q", ienc)
+	}
+
+	parser, ok := parsers[format]
+	if !ok {
+		return nil, fmt.Errorf("no parser for format %q using input type %q", format, ienc)
+	}
+
+	return parser(r, mhType, mhLen)
+}

vendor/github.com/ipfs/go-ipfs/core/coredag/raw.go

@@ -0,0 +1,37 @@
+package coredag
+
+import (
+	"io"
+	"io/ioutil"
+	"math"
+
+	"github.com/ipfs/go-merkledag"
+
+	block "github.com/ipfs/go-block-format"
+	cid "github.com/ipfs/go-cid"
+	ipld "github.com/ipfs/go-ipld-format"
+	mh "github.com/multiformats/go-multihash"
+)
+
+func rawRawParser(r io.Reader, mhType uint64, mhLen int) ([]ipld.Node, error) {
+	if mhType == math.MaxUint64 {
+		mhType = mh.SHA2_256
+	}
+
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	h, err := mh.Sum(data, mhType, mhLen)
+	if err != nil {
+		return nil, err
+	}
+	c := cid.NewCidV1(cid.Raw, h)
+	blk, err := block.NewBlockWithCid(data, c)
+	if err != nil {
+		return nil, err
+	}
+	nd := &merkledag.RawNode{Block: blk}
+	return []ipld.Node{nd}, nil
+}

vendor/github.com/ipfs/go-ipfs/core/node/builder.go

@@ -0,0 +1,151 @@
+package node
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/core/node/libp2p"
+	"github.com/ipfs/go-ipfs/repo"
+
+	ds "github.com/ipfs/go-datastore"
+	dsync "github.com/ipfs/go-datastore/sync"
+	cfg "github.com/ipfs/go-ipfs-config"
+	ci "github.com/libp2p/go-libp2p-core/crypto"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+)
+
+type BuildCfg struct {
+	// If online is set, the node will have networking enabled
+	Online bool
+
+	// ExtraOpts is a map of extra options used to configure the ipfs nodes creation
+	ExtraOpts map[string]bool
+
+	// If permanent then node should run more expensive processes
+	// that will improve performance in long run
+	Permanent bool
+
+	// DisableEncryptedConnections disables connection encryption *entirely*.
+	// DO NOT SET THIS UNLESS YOU'RE TESTING.
+	DisableEncryptedConnections bool
+
+	// If NilRepo is set, a Repo backed by a nil datastore will be constructed
+	NilRepo bool
+
+	Routing libp2p.RoutingOption
+	Host    libp2p.HostOption
+	Repo    repo.Repo
+}
+
+func (cfg *BuildCfg) getOpt(key string) bool {
+	if cfg.ExtraOpts == nil {
+		return false
+	}
+
+	return cfg.ExtraOpts[key]
+}
+
+func (cfg *BuildCfg) fillDefaults() error {
+	if cfg.Repo != nil && cfg.NilRepo {
+		return errors.New("cannot set a Repo and specify nilrepo at the same time")
+	}
+
+	if cfg.Repo == nil {
+		var d ds.Datastore
+		if cfg.NilRepo {
+			d = ds.NewNullDatastore()
+		} else {
+			d = ds.NewMapDatastore()
+		}
+		r, err := defaultRepo(dsync.MutexWrap(d))
+		if err != nil {
+			return err
+		}
+		cfg.Repo = r
+	}
+
+	if cfg.Routing == nil {
+		cfg.Routing = libp2p.DHTOption
+	}
+
+	if cfg.Host == nil {
+		cfg.Host = libp2p.DefaultHostOption
+	}
+
+	return nil
+}
+
+// options creates fx option group from this build config
+func (cfg *BuildCfg) options(ctx context.Context) (fx.Option, *cfg.Config) {
+	err := cfg.fillDefaults()
+	if err != nil {
+		return fx.Error(err), nil
+	}
+
+	repoOption := fx.Provide(func(lc fx.Lifecycle) repo.Repo {
+		lc.Append(fx.Hook{
+			OnStop: func(ctx context.Context) error {
+				return cfg.Repo.Close()
+			},
+		})
+
+		return cfg.Repo
+	})
+
+	metricsCtx := fx.Provide(func() helpers.MetricsCtx {
+		return helpers.MetricsCtx(ctx)
+	})
+
+	hostOption := fx.Provide(func() libp2p.HostOption {
+		return cfg.Host
+	})
+
+	routingOption := fx.Provide(func() libp2p.RoutingOption {
+		return cfg.Routing
+	})
+
+	conf, err := cfg.Repo.Config()
+	if err != nil {
+		return fx.Error(err), nil
+	}
+
+	return fx.Options(
+		repoOption,
+		hostOption,
+		routingOption,
+		metricsCtx,
+	), conf
+}
+
+func defaultRepo(dstore repo.Datastore) (repo.Repo, error) {
+	c := cfg.Config{}
+	priv, pub, err := ci.GenerateKeyPairWithReader(ci.RSA, 1024, rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+
+	pid, err := peer.IDFromPublicKey(pub)
+	if err != nil {
+		return nil, err
+	}
+
+	privkeyb, err := priv.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	c.Bootstrap = cfg.DefaultBootstrapAddresses
+	c.Addresses.Swarm = []string{"/ip4/0.0.0.0/tcp/4001"}
+	c.Identity.PeerID = pid.Pretty()
+	c.Identity.PrivKey = base64.StdEncoding.EncodeToString(privkeyb)
+
+	return &repo.Mock{
+		D: dstore,
+		C: c,
+	}, nil
+}

vendor/github.com/ipfs/go-ipfs/core/node/core.go

@@ -0,0 +1,124 @@
+package node
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/pin"
+	"github.com/ipfs/go-ipfs/repo"
+
+	"github.com/ipfs/go-bitswap"
+	"github.com/ipfs/go-bitswap/network"
+	"github.com/ipfs/go-blockservice"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-ipfs-blockstore"
+	"github.com/ipfs/go-ipfs-exchange-interface"
+	"github.com/ipfs/go-ipfs-exchange-offline"
+	"github.com/ipfs/go-ipld-format"
+	"github.com/ipfs/go-merkledag"
+	"github.com/ipfs/go-mfs"
+	"github.com/ipfs/go-unixfs"
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/routing"
+	"go.uber.org/fx"
+)
+
+// BlockService creates new blockservice which provides an interface to fetch content-addressable blocks
+func BlockService(lc fx.Lifecycle, bs blockstore.Blockstore, rem exchange.Interface) blockservice.BlockService {
+	bsvc := blockservice.New(bs, rem)
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return bsvc.Close()
+		},
+	})
+
+	return bsvc
+}
+
+// Pinning creates new pinner which tells GC which blocks should be kept
+func Pinning(bstore blockstore.Blockstore, ds format.DAGService, repo repo.Repo) (pin.Pinner, error) {
+	internalDag := merkledag.NewDAGService(blockservice.New(bstore, offline.Exchange(bstore)))
+	pinning, err := pin.LoadPinner(repo.Datastore(), ds, internalDag)
+	if err != nil {
+		// TODO: we should move towards only running 'NewPinner' explicitly on
+		// node init instead of implicitly here as a result of the pinner keys
+		// not being found in the datastore.
+		// this is kinda sketchy and could cause data loss
+		pinning = pin.NewPinner(repo.Datastore(), ds, internalDag)
+	}
+
+	return pinning, nil
+}
+
+// Dag creates new DAGService
+func Dag(bs blockservice.BlockService) format.DAGService {
+	return merkledag.NewDAGService(bs)
+}
+
+// OnlineExchange creates new LibP2P backed block exchange (BitSwap)
+func OnlineExchange(provide bool) interface{} {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt routing.Routing, bs blockstore.GCBlockstore) exchange.Interface {
+		bitswapNetwork := network.NewFromIpfsHost(host, rt)
+		exch := bitswap.New(helpers.LifecycleCtx(mctx, lc), bitswapNetwork, bs, bitswap.ProvideEnabled(provide))
+		lc.Append(fx.Hook{
+			OnStop: func(ctx context.Context) error {
+				return exch.Close()
+			},
+		})
+		return exch
+
+	}
+}
+
+// Files loads persisted MFS root
+func Files(mctx helpers.MetricsCtx, lc fx.Lifecycle, repo repo.Repo, dag format.DAGService) (*mfs.Root, error) {
+	dsk := datastore.NewKey("/local/filesroot")
+	pf := func(ctx context.Context, c cid.Cid) error {
+		return repo.Datastore().Put(dsk, c.Bytes())
+	}
+
+	var nd *merkledag.ProtoNode
+	val, err := repo.Datastore().Get(dsk)
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	switch {
+	case err == datastore.ErrNotFound || val == nil:
+		nd = unixfs.EmptyDirNode()
+		err := dag.Add(ctx, nd)
+		if err != nil {
+			return nil, fmt.Errorf("failure writing to dagstore: %s", err)
+		}
+	case err == nil:
+		c, err := cid.Cast(val)
+		if err != nil {
+			return nil, err
+		}
+
+		rnd, err := dag.Get(ctx, c)
+		if err != nil {
+			return nil, fmt.Errorf("error loading filesroot from DAG: %s", err)
+		}
+
+		pbnd, ok := rnd.(*merkledag.ProtoNode)
+		if !ok {
+			return nil, merkledag.ErrNotProtobuf
+		}
+
+		nd = pbnd
+	default:
+		return nil, err
+	}
+
+	root, err := mfs.NewRoot(ctx, dag, nd, pf)
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return root.Close()
+		},
+	})
+
+	return root, err
+}

vendor/github.com/ipfs/go-ipfs/core/node/groups.go

@@ -0,0 +1,294 @@
+package node
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	"github.com/ipfs/go-ipfs-config"
+	util "github.com/ipfs/go-ipfs-util"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-peerstore/pstoremem"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+
+	"github.com/ipfs/go-ipfs/core/node/libp2p"
+	"github.com/ipfs/go-ipfs/p2p"
+
+	offline "github.com/ipfs/go-ipfs-exchange-offline"
+	offroute "github.com/ipfs/go-ipfs-routing/offline"
+	"github.com/ipfs/go-path/resolver"
+	uio "github.com/ipfs/go-unixfs/io"
+	"go.uber.org/fx"
+)
+
+var BaseLibP2P = fx.Options(
+	fx.Provide(libp2p.PNet),
+	fx.Provide(libp2p.ConnectionManager),
+	fx.Provide(libp2p.DefaultTransports),
+
+	fx.Provide(libp2p.Host),
+
+	fx.Provide(libp2p.DiscoveryHandler),
+
+	fx.Invoke(libp2p.PNetChecker),
+)
+
+func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option {
+	// parse ConnMgr config
+
+	grace := config.DefaultConnMgrGracePeriod
+	low := config.DefaultConnMgrLowWater
+	high := config.DefaultConnMgrHighWater
+
+	connmgr := fx.Options()
+
+	if cfg.Swarm.ConnMgr.Type != "none" {
+		switch cfg.Swarm.ConnMgr.Type {
+		case "":
+			// 'default' value is the basic connection manager
+			break
+		case "basic":
+			var err error
+			grace, err = time.ParseDuration(cfg.Swarm.ConnMgr.GracePeriod)
+			if err != nil {
+				return fx.Error(fmt.Errorf("parsing Swarm.ConnMgr.GracePeriod: %s", err))
+			}
+
+			low = cfg.Swarm.ConnMgr.LowWater
+			high = cfg.Swarm.ConnMgr.HighWater
+		default:
+			return fx.Error(fmt.Errorf("unrecognized ConnMgr.Type: %q", cfg.Swarm.ConnMgr.Type))
+		}
+
+		connmgr = fx.Provide(libp2p.ConnectionManager(low, high, grace))
+	}
+
+	// parse PubSub config
+
+	ps := fx.Options()
+	if bcfg.getOpt("pubsub") || bcfg.getOpt("ipnsps") {
+		var pubsubOptions []pubsub.Option
+		pubsubOptions = append(
+			pubsubOptions,
+			pubsub.WithMessageSigning(!cfg.Pubsub.DisableSigning),
+			pubsub.WithStrictSignatureVerification(cfg.Pubsub.StrictSignatureVerification),
+		)
+
+		switch cfg.Pubsub.Router {
+		case "":
+			fallthrough
+		case "floodsub":
+			ps = fx.Provide(libp2p.FloodSub(pubsubOptions...))
+		case "gossipsub":
+			ps = fx.Provide(libp2p.GossipSub(pubsubOptions...))
+		default:
+			return fx.Error(fmt.Errorf("unknown pubsub router %s", cfg.Pubsub.Router))
+		}
+	}
+
+	// Gather all the options
+
+	opts := fx.Options(
+		BaseLibP2P,
+
+		fx.Provide(libp2p.AddrFilters(cfg.Swarm.AddrFilters)),
+		fx.Provide(libp2p.AddrsFactory(cfg.Addresses.Announce, cfg.Addresses.NoAnnounce)),
+		fx.Provide(libp2p.SmuxTransport(bcfg.getOpt("mplex"))),
+		fx.Provide(libp2p.Relay(cfg.Swarm.DisableRelay, cfg.Swarm.EnableRelayHop)),
+		fx.Invoke(libp2p.StartListening(cfg.Addresses.Swarm)),
+		fx.Invoke(libp2p.SetupDiscovery(cfg.Discovery.MDNS.Enabled, cfg.Discovery.MDNS.Interval)),
+
+		fx.Provide(libp2p.Security(!bcfg.DisableEncryptedConnections, cfg.Experimental.PreferTLS)),
+
+		fx.Provide(libp2p.Routing),
+		fx.Provide(libp2p.BaseRouting),
+		maybeProvide(libp2p.PubsubRouter, bcfg.getOpt("ipnsps")),
+
+		maybeProvide(libp2p.BandwidthCounter, !cfg.Swarm.DisableBandwidthMetrics),
+		maybeProvide(libp2p.NatPortMap, !cfg.Swarm.DisableNatPortMap),
+		maybeProvide(libp2p.AutoRealy, cfg.Swarm.EnableAutoRelay),
+		maybeProvide(libp2p.QUIC, cfg.Experimental.QUIC),
+		maybeInvoke(libp2p.AutoNATService(cfg.Experimental.QUIC), cfg.Swarm.EnableAutoNATService),
+		connmgr,
+		ps,
+	)
+
+	return opts
+}
+
+// Storage groups units which setup datastore based persistence and blockstore layers
+func Storage(bcfg *BuildCfg, cfg *config.Config) fx.Option {
+	cacheOpts := blockstore.DefaultCacheOpts()
+	cacheOpts.HasBloomFilterSize = cfg.Datastore.BloomFilterSize
+	if !bcfg.Permanent {
+		cacheOpts.HasBloomFilterSize = 0
+	}
+
+	finalBstore := fx.Provide(GcBlockstoreCtor)
+	if cfg.Experimental.FilestoreEnabled || cfg.Experimental.UrlstoreEnabled {
+		finalBstore = fx.Provide(FilestoreBlockstoreCtor)
+	}
+
+	return fx.Options(
+		fx.Provide(RepoConfig),
+		fx.Provide(Datastore),
+		fx.Provide(BaseBlockstoreCtor(cacheOpts, bcfg.NilRepo, cfg.Datastore.HashOnRead)),
+		finalBstore,
+	)
+}
+
+// Identity groups units providing cryptographic identity
+func Identity(cfg *config.Config) fx.Option {
+	// PeerID
+
+	cid := cfg.Identity.PeerID
+	if cid == "" {
+		return fx.Error(errors.New("identity was not set in config (was 'ipfs init' run?)"))
+	}
+	if len(cid) == 0 {
+		return fx.Error(errors.New("no peer ID in config! (was 'ipfs init' run?)"))
+	}
+
+	id, err := peer.IDB58Decode(cid)
+	if err != nil {
+		return fx.Error(fmt.Errorf("peer ID invalid: %s", err))
+	}
+
+	// Private Key
+
+	if cfg.Identity.PrivKey == "" {
+		return fx.Options( // No PK (usually in tests)
+			fx.Provide(PeerID(id)),
+			fx.Provide(pstoremem.NewPeerstore),
+		)
+	}
+
+	sk, err := cfg.Identity.DecodePrivateKey("passphrase todo!")
+	if err != nil {
+		return fx.Error(err)
+	}
+
+	return fx.Options( // Full identity
+		fx.Provide(PeerID(id)),
+		fx.Provide(PrivateKey(sk)),
+		fx.Provide(pstoremem.NewPeerstore),
+
+		fx.Invoke(libp2p.PstoreAddSelfKeys),
+	)
+}
+
+// IPNS groups namesys related units
+var IPNS = fx.Options(
+	fx.Provide(RecordValidator),
+)
+
+// Online groups online-only units
+func Online(bcfg *BuildCfg, cfg *config.Config) fx.Option {
+
+	// Namesys params
+
+	ipnsCacheSize := cfg.Ipns.ResolveCacheSize
+	if ipnsCacheSize == 0 {
+		ipnsCacheSize = DefaultIpnsCacheSize
+	}
+	if ipnsCacheSize < 0 {
+		return fx.Error(fmt.Errorf("cannot specify negative resolve cache size"))
+	}
+
+	// Republisher params
+
+	var repubPeriod, recordLifetime time.Duration
+
+	if cfg.Ipns.RepublishPeriod != "" {
+		d, err := time.ParseDuration(cfg.Ipns.RepublishPeriod)
+		if err != nil {
+			return fx.Error(fmt.Errorf("failure to parse config setting IPNS.RepublishPeriod: %s", err))
+		}
+
+		if !util.Debug && (d < time.Minute || d > (time.Hour*24)) {
+			return fx.Error(fmt.Errorf("config setting IPNS.RepublishPeriod is not between 1min and 1day: %s", d))
+		}
+
+		repubPeriod = d
+	}
+
+	if cfg.Ipns.RecordLifetime != "" {
+		d, err := time.ParseDuration(cfg.Ipns.RecordLifetime)
+		if err != nil {
+			return fx.Error(fmt.Errorf("failure to parse config setting IPNS.RecordLifetime: %s", err))
+		}
+
+		recordLifetime = d
+	}
+
+	/* don't provide from bitswap when the strategic provider service is active */
+	shouldBitswapProvide := !cfg.Experimental.StrategicProviding
+
+	return fx.Options(
+		fx.Provide(OnlineExchange(shouldBitswapProvide)),
+		fx.Provide(Namesys(ipnsCacheSize)),
+
+		fx.Invoke(IpnsRepublisher(repubPeriod, recordLifetime)),
+
+		fx.Provide(p2p.New),
+
+		LibP2P(bcfg, cfg),
+		OnlineProviders(cfg.Experimental.StrategicProviding, cfg.Reprovider.Strategy, cfg.Reprovider.Interval),
+	)
+}
+
+// Offline groups offline alternatives to Online units
+func Offline(cfg *config.Config) fx.Option {
+	return fx.Options(
+		fx.Provide(offline.Exchange),
+		fx.Provide(Namesys(0)),
+		fx.Provide(offroute.NewOfflineRouter),
+		OfflineProviders(cfg.Experimental.StrategicProviding, cfg.Reprovider.Strategy, cfg.Reprovider.Interval),
+	)
+}
+
+// Core groups basic IPFS services
+var Core = fx.Options(
+	fx.Provide(BlockService),
+	fx.Provide(Dag),
+	fx.Provide(resolver.NewBasicResolver),
+	fx.Provide(Pinning),
+	fx.Provide(Files),
+)
+
+func Networked(bcfg *BuildCfg, cfg *config.Config) fx.Option {
+	if bcfg.Online {
+		return Online(bcfg, cfg)
+	}
+	return Offline(cfg)
+}
+
+// IPFS builds a group of fx Options based on the passed BuildCfg
+func IPFS(ctx context.Context, bcfg *BuildCfg) fx.Option {
+	if bcfg == nil {
+		bcfg = new(BuildCfg)
+	}
+
+	bcfgOpts, cfg := bcfg.options(ctx)
+	if cfg == nil {
+		return bcfgOpts // error
+	}
+
+	// TEMP: setting global sharding switch here
+	uio.UseHAMTSharding = cfg.Experimental.ShardingEnabled
+
+	return fx.Options(
+		bcfgOpts,
+
+		fx.Provide(baseProcess),
+
+		Storage(bcfg, cfg),
+		Identity(cfg),
+		IPNS,
+		Networked(bcfg, cfg),
+
+		Core,
+	)
+}

vendor/github.com/ipfs/go-ipfs/core/node/helpers.go

@@ -0,0 +1,62 @@
+package node
+
+import (
+	"context"
+
+	"github.com/jbenet/goprocess"
+	"github.com/pkg/errors"
+	"go.uber.org/fx"
+)
+
+type lcProcess struct {
+	fx.In
+
+	LC   fx.Lifecycle
+	Proc goprocess.Process
+}
+
+// Append wraps ProcessFunc into a goprocess, and appends it to the lifecycle
+func (lp *lcProcess) Append(f goprocess.ProcessFunc) {
+	// Hooks are guaranteed to run in sequence. If a hook fails to start, its
+	// OnStop won't be executed.
+	var proc goprocess.Process
+
+	lp.LC.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			proc = lp.Proc.Go(f)
+			return nil
+		},
+		OnStop: func(ctx context.Context) error {
+			if proc == nil { // Theoretically this shouldn't ever happen
+				return errors.New("lcProcess: proc was nil")
+			}
+
+			return proc.Close() // todo: respect ctx, somehow
+		},
+	})
+}
+
+func maybeProvide(opt interface{}, enable bool) fx.Option {
+	if enable {
+		return fx.Provide(opt)
+	}
+	return fx.Options()
+}
+
+func maybeInvoke(opt interface{}, enable bool) fx.Option {
+	if enable {
+		return fx.Invoke(opt)
+	}
+	return fx.Options()
+}
+
+// baseProcess creates a goprocess which is closed when the lifecycle signals it to stop
+func baseProcess(lc fx.Lifecycle) goprocess.Process {
+	p := goprocess.WithParent(goprocess.Background())
+	lc.Append(fx.Hook{
+		OnStop: func(_ context.Context) error {
+			return p.Close()
+		},
+	})
+	return p
+}

vendor/github.com/ipfs/go-ipfs/core/node/helpers/helpers.go

@@ -0,0 +1,23 @@
+package helpers
+
+import (
+	"context"
+	"go.uber.org/fx"
+)
+
+type MetricsCtx context.Context
+
+// LifecycleCtx creates a context which will be cancelled when lifecycle stops
+//
+// This is a hack which we need because most of our services use contexts in a
+// wrong way
+func LifecycleCtx(mctx MetricsCtx, lc fx.Lifecycle) context.Context {
+	ctx, cancel := context.WithCancel(mctx)
+	lc.Append(fx.Hook{
+		OnStop: func(_ context.Context) error {
+			cancel()
+			return nil
+		},
+	})
+	return ctx
+}

vendor/github.com/ipfs/go-ipfs/core/node/identity.go

@@ -0,0 +1,29 @@
+package node
+
+import (
+	"fmt"
+
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+)
+
+func PeerID(id peer.ID) func() peer.ID {
+	return func() peer.ID {
+		return id
+	}
+}
+
+// PrivateKey loads the private key from config
+func PrivateKey(sk crypto.PrivKey) func(id peer.ID) (crypto.PrivKey, error) {
+	return func(id peer.ID) (crypto.PrivKey, error) {
+		id2, err := peer.IDFromPrivateKey(sk)
+		if err != nil {
+			return nil, err
+		}
+
+		if id2 != id {
+			return nil, fmt.Errorf("private key in config does not match id: %s != %s", id, id2)
+		}
+		return sk, nil
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/ipns.go

@@ -0,0 +1,56 @@
+package node
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/ipfs/go-ipfs-util"
+	"github.com/ipfs/go-ipns"
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peerstore"
+	"github.com/libp2p/go-libp2p-core/routing"
+	"github.com/libp2p/go-libp2p-record"
+
+	"github.com/ipfs/go-ipfs/namesys"
+	"github.com/ipfs/go-ipfs/namesys/republisher"
+	"github.com/ipfs/go-ipfs/repo"
+)
+
+const DefaultIpnsCacheSize = 128
+
+// RecordValidator provides namesys compatible routing record validator
+func RecordValidator(ps peerstore.Peerstore) record.Validator {
+	return record.NamespacedValidator{
+		"pk":   record.PublicKeyValidator{},
+		"ipns": ipns.Validator{KeyBook: ps},
+	}
+}
+
+// Namesys creates new name system
+func Namesys(cacheSize int) func(rt routing.Routing, repo repo.Repo) (namesys.NameSystem, error) {
+	return func(rt routing.Routing, repo repo.Repo) (namesys.NameSystem, error) {
+		return namesys.NewNameSystem(rt, repo.Datastore(), cacheSize), nil
+	}
+}
+
+// IpnsRepublisher runs new IPNS republisher service
+func IpnsRepublisher(repubPeriod time.Duration, recordLifetime time.Duration) func(lcProcess, namesys.NameSystem, repo.Repo, crypto.PrivKey) error {
+	return func(lc lcProcess, namesys namesys.NameSystem, repo repo.Repo, privKey crypto.PrivKey) error {
+		repub := republisher.NewRepublisher(namesys, repo.Datastore(), privKey, repo.Keystore())
+
+		if repubPeriod != 0 {
+			if !util.Debug && (repubPeriod < time.Minute || repubPeriod > (time.Hour*24)) {
+				return fmt.Errorf("config setting IPNS.RepublishPeriod is not between 1min and 1day: %s", repubPeriod)
+			}
+
+			repub.Interval = repubPeriod
+		}
+
+		if recordLifetime != 0 {
+			repub.RecordLifetime = recordLifetime
+		}
+
+		lc.Append(repub.Run)
+		return nil
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/addrs.go

@@ -0,0 +1,117 @@
+package libp2p
+
+import (
+	"fmt"
+
+	"github.com/libp2p/go-libp2p"
+	host "github.com/libp2p/go-libp2p-core/host"
+	p2pbhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+	mafilter "github.com/libp2p/go-maddr-filter"
+	ma "github.com/multiformats/go-multiaddr"
+	mamask "github.com/whyrusleeping/multiaddr-filter"
+)
+
+func AddrFilters(filters []string) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		for _, s := range filters {
+			f, err := mamask.NewMask(s)
+			if err != nil {
+				return opts, fmt.Errorf("incorrectly formatted address filter in config: %s", s)
+			}
+			opts.Opts = append(opts.Opts, libp2p.FilterAddresses(f))
+		}
+		return opts, nil
+	}
+}
+
+func makeAddrsFactory(announce []string, noAnnounce []string) (p2pbhost.AddrsFactory, error) {
+	var annAddrs []ma.Multiaddr
+	for _, addr := range announce {
+		maddr, err := ma.NewMultiaddr(addr)
+		if err != nil {
+			return nil, err
+		}
+		annAddrs = append(annAddrs, maddr)
+	}
+
+	filters := mafilter.NewFilters()
+	noAnnAddrs := map[string]bool{}
+	for _, addr := range noAnnounce {
+		f, err := mamask.NewMask(addr)
+		if err == nil {
+			filters.AddFilter(*f, mafilter.ActionDeny)
+			continue
+		}
+		maddr, err := ma.NewMultiaddr(addr)
+		if err != nil {
+			return nil, err
+		}
+		noAnnAddrs[string(maddr.Bytes())] = true
+	}
+
+	return func(allAddrs []ma.Multiaddr) []ma.Multiaddr {
+		var addrs []ma.Multiaddr
+		if len(annAddrs) > 0 {
+			addrs = annAddrs
+		} else {
+			addrs = allAddrs
+		}
+
+		var out []ma.Multiaddr
+		for _, maddr := range addrs {
+			// check for exact matches
+			ok := noAnnAddrs[string(maddr.Bytes())]
+			// check for /ipcidr matches
+			if !ok && !filters.AddrBlocked(maddr) {
+				out = append(out, maddr)
+			}
+		}
+		return out
+	}, nil
+}
+
+func AddrsFactory(announce []string, noAnnounce []string) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		addrsFactory, err := makeAddrsFactory(announce, noAnnounce)
+		if err != nil {
+			return opts, err
+		}
+		opts.Opts = append(opts.Opts, libp2p.AddrsFactory(addrsFactory))
+		return
+	}
+}
+
+func listenAddresses(addresses []string) ([]ma.Multiaddr, error) {
+	var listen []ma.Multiaddr
+	for _, addr := range addresses {
+		maddr, err := ma.NewMultiaddr(addr)
+		if err != nil {
+			return nil, fmt.Errorf("failure to parse config.Addresses.Swarm: %s", addresses)
+		}
+		listen = append(listen, maddr)
+	}
+
+	return listen, nil
+}
+
+func StartListening(addresses []string) func(host host.Host) error {
+	return func(host host.Host) error {
+		listenAddrs, err := listenAddresses(addresses)
+		if err != nil {
+			return err
+		}
+
+		// Actually start listening:
+		if err := host.Network().Listen(listenAddrs...); err != nil {
+			return err
+		}
+
+		// list out our addresses
+		addrs, err := host.Network().InterfaceListenAddresses()
+		if err != nil {
+			return err
+		}
+		log.Infof("Swarm listening at: %s", addrs)
+		return nil
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/discovery.go

@@ -0,0 +1,53 @@
+package libp2p
+
+import (
+	"context"
+	"time"
+
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p/p2p/discovery"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+)
+
+const discoveryConnTimeout = time.Second * 30
+
+type discoveryHandler struct {
+	ctx  context.Context
+	host host.Host
+}
+
+func (dh *discoveryHandler) HandlePeerFound(p peer.AddrInfo) {
+	log.Warning("trying peer info: ", p)
+	ctx, cancel := context.WithTimeout(dh.ctx, discoveryConnTimeout)
+	defer cancel()
+	if err := dh.host.Connect(ctx, p); err != nil {
+		log.Warning("Failed to connect to peer found by discovery: ", err)
+	}
+}
+
+func DiscoveryHandler(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) *discoveryHandler {
+	return &discoveryHandler{
+		ctx:  helpers.LifecycleCtx(mctx, lc),
+		host: host,
+	}
+}
+
+func SetupDiscovery(mdns bool, mdnsInterval int) func(helpers.MetricsCtx, fx.Lifecycle, host.Host, *discoveryHandler) error {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, handler *discoveryHandler) error {
+		if mdns {
+			if mdnsInterval == 0 {
+				mdnsInterval = 5
+			}
+			service, err := discovery.NewMdnsService(helpers.LifecycleCtx(mctx, lc), host, time.Duration(mdnsInterval)*time.Second, discovery.ServiceTag)
+			if err != nil {
+				log.Error("mdns error: ", err)
+				return nil
+			}
+			service.RegisterNotifee(handler)
+		}
+		return nil
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/host.go

@@ -0,0 +1,76 @@
+package libp2p
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p"
+	host "github.com/libp2p/go-libp2p-core/host"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	peerstore "github.com/libp2p/go-libp2p-core/peerstore"
+	routing "github.com/libp2p/go-libp2p-core/routing"
+	record "github.com/libp2p/go-libp2p-record"
+	routedhost "github.com/libp2p/go-libp2p/p2p/host/routed"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/repo"
+)
+
+type P2PHostIn struct {
+	fx.In
+
+	Repo          repo.Repo
+	Validator     record.Validator
+	HostOption    HostOption
+	RoutingOption RoutingOption
+	ID            peer.ID
+	Peerstore     peerstore.Peerstore
+
+	Opts [][]libp2p.Option `group:"libp2p"`
+}
+
+type P2PHostOut struct {
+	fx.Out
+
+	Host    host.Host
+	Routing BaseIpfsRouting
+}
+
+func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (out P2PHostOut, err error) {
+	opts := []libp2p.Option{libp2p.NoListenAddrs}
+	for _, o := range params.Opts {
+		opts = append(opts, o...)
+	}
+
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	opts = append(opts, libp2p.Routing(func(h host.Host) (routing.PeerRouting, error) {
+		r, err := params.RoutingOption(ctx, h, params.Repo.Datastore(), params.Validator)
+		out.Routing = r
+		return r, err
+	}))
+
+	out.Host, err = params.HostOption(ctx, params.ID, params.Peerstore, opts...)
+	if err != nil {
+		return P2PHostOut{}, err
+	}
+
+	// this code is necessary just for tests: mock network constructions
+	// ignore the libp2p constructor options that actually construct the routing!
+	if out.Routing == nil {
+		r, err := params.RoutingOption(ctx, out.Host, params.Repo.Datastore(), params.Validator)
+		if err != nil {
+			return P2PHostOut{}, err
+		}
+		out.Routing = r
+		out.Host = routedhost.Wrap(out.Host, out.Routing)
+	}
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return out.Host.Close()
+		},
+	})
+
+	return out, err
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/hostopt.go

@@ -0,0 +1,25 @@
+package libp2p
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/libp2p/go-libp2p"
+	host "github.com/libp2p/go-libp2p-core/host"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	peerstore "github.com/libp2p/go-libp2p-core/peerstore"
+)
+
+type HostOption func(ctx context.Context, id peer.ID, ps peerstore.Peerstore, options ...libp2p.Option) (host.Host, error)
+
+var DefaultHostOption HostOption = constructPeerHost
+
+// isolates the complex initialization steps
+func constructPeerHost(ctx context.Context, id peer.ID, ps peerstore.Peerstore, options ...libp2p.Option) (host.Host, error) {
+	pkey := ps.PrivKey(id)
+	if pkey == nil {
+		return nil, fmt.Errorf("missing private key for node ID: %s", id.Pretty())
+	}
+	options = append([]libp2p.Option{libp2p.Identity(pkey), libp2p.Peerstore(ps)}, options...)
+	return libp2p.New(ctx, options...)
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/libp2p.go

@@ -0,0 +1,46 @@
+package libp2p
+
+import (
+	"time"
+
+	logging "github.com/ipfs/go-log"
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p-connmgr"
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/peerstore"
+	"go.uber.org/fx"
+)
+
+var log = logging.Logger("p2pnode")
+
+type Libp2pOpts struct {
+	fx.Out
+
+	Opts []libp2p.Option `group:"libp2p"`
+}
+
+// Misc options
+
+func ConnectionManager(low, high int, grace time.Duration) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		cm := connmgr.NewConnManager(low, high, grace)
+		opts.Opts = append(opts.Opts, libp2p.ConnectionManager(cm))
+		return
+	}
+}
+
+func PstoreAddSelfKeys(id peer.ID, sk crypto.PrivKey, ps peerstore.Peerstore) error {
+	if err := ps.AddPubKey(id, sk.GetPublic()); err != nil {
+		return err
+	}
+
+	return ps.AddPrivKey(id, sk)
+}
+
+func simpleOpt(opt libp2p.Option) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		opts.Opts = append(opts.Opts, opt)
+		return
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/nat.go

@@ -0,0 +1,32 @@
+package libp2p
+
+import (
+	"github.com/libp2p/go-libp2p"
+	autonat "github.com/libp2p/go-libp2p-autonat-svc"
+	host "github.com/libp2p/go-libp2p-core/host"
+	libp2pquic "github.com/libp2p/go-libp2p-quic-transport"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/repo"
+)
+
+var NatPortMap = simpleOpt(libp2p.NATPortMap())
+
+func AutoNATService(quic bool) func(repo repo.Repo, mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) error {
+	return func(repo repo.Repo, mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) error {
+		// collect private net option in case swarm.key is presented
+		opts, _, err := PNet(repo)
+		if err != nil {
+			// swarm key exists but was failed to decode
+			return err
+		}
+
+		if quic {
+			opts.Opts = append(opts.Opts, libp2p.DefaultTransports, libp2p.Transport(libp2pquic.NewTransport))
+		}
+
+		_, err = autonat.NewAutoNATService(helpers.LifecycleCtx(mctx, lc), host, opts.Opts...)
+		return err
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/pnet.go

@@ -0,0 +1,70 @@
+package libp2p
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/libp2p/go-libp2p"
+	host "github.com/libp2p/go-libp2p-core/host"
+	pnet "github.com/libp2p/go-libp2p-pnet"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/repo"
+)
+
+type PNetFingerprint []byte
+
+func PNet(repo repo.Repo) (opts Libp2pOpts, fp PNetFingerprint, err error) {
+	swarmkey, err := repo.SwarmKey()
+	if err != nil || swarmkey == nil {
+		return opts, nil, err
+	}
+
+	protec, err := pnet.NewProtector(bytes.NewReader(swarmkey))
+	if err != nil {
+		return opts, nil, fmt.Errorf("failed to configure private network: %s", err)
+	}
+	fp = protec.Fingerprint()
+
+	opts.Opts = append(opts.Opts, libp2p.PrivateNetwork(protec))
+	return opts, fp, nil
+}
+
+func PNetChecker(repo repo.Repo, ph host.Host, lc fx.Lifecycle) error {
+	// TODO: better check?
+	swarmkey, err := repo.SwarmKey()
+	if err != nil || swarmkey == nil {
+		return err
+	}
+
+	done := make(chan struct{})
+	lc.Append(fx.Hook{
+		OnStart: func(_ context.Context) error {
+			go func() {
+				t := time.NewTicker(30 * time.Second)
+				defer t.Stop()
+
+				<-t.C // swallow one tick
+				for {
+					select {
+					case <-t.C:
+						if len(ph.Network().Peers()) == 0 {
+							log.Warning("We are in private network and have no peers.")
+							log.Warning("This might be configuration mistake.")
+						}
+					case <-done:
+						return
+					}
+				}
+			}()
+			return nil
+		},
+		OnStop: func(_ context.Context) error {
+			close(done)
+			return nil
+		},
+	})
+	return nil
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/pubsub.go

@@ -0,0 +1,21 @@
+package libp2p
+
+import (
+	host "github.com/libp2p/go-libp2p-core/host"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+)
+
+func FloodSub(pubsubOptions ...pubsub.Option) interface{} {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) (service *pubsub.PubSub, err error) {
+		return pubsub.NewFloodSub(helpers.LifecycleCtx(mctx, lc), host, pubsubOptions...)
+	}
+}
+
+func GossipSub(pubsubOptions ...pubsub.Option) interface{} {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) (service *pubsub.PubSub, err error) {
+		return pubsub.NewGossipSub(helpers.LifecycleCtx(mctx, lc), host, pubsubOptions...)
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/relay.go

@@ -0,0 +1,24 @@
+package libp2p
+
+import (
+	"github.com/libp2p/go-libp2p"
+	relay "github.com/libp2p/go-libp2p-circuit"
+)
+
+func Relay(disable, enableHop bool) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		if disable {
+			// Enabled by default.
+			opts.Opts = append(opts.Opts, libp2p.DisableRelay())
+		} else {
+			relayOpts := []relay.RelayOpt{relay.OptDiscovery}
+			if enableHop {
+				relayOpts = append(relayOpts, relay.OptHop)
+			}
+			opts.Opts = append(opts.Opts, libp2p.EnableRelay(relayOpts...))
+		}
+		return
+	}
+}
+
+var AutoRealy = simpleOpt(libp2p.EnableAutoRelay())

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/routing.go

@@ -0,0 +1,106 @@
+package libp2p
+
+import (
+	"context"
+	"sort"
+
+	host "github.com/libp2p/go-libp2p-core/host"
+	routing "github.com/libp2p/go-libp2p-core/routing"
+	dht "github.com/libp2p/go-libp2p-kad-dht"
+	"github.com/libp2p/go-libp2p-pubsub"
+	namesys "github.com/libp2p/go-libp2p-pubsub-router"
+	record "github.com/libp2p/go-libp2p-record"
+	routinghelpers "github.com/libp2p/go-libp2p-routing-helpers"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+)
+
+type BaseIpfsRouting routing.Routing
+
+type Router struct {
+	routing.Routing
+
+	Priority int // less = more important
+}
+
+type p2pRouterOut struct {
+	fx.Out
+
+	Router Router `group:"routers"`
+}
+
+func BaseRouting(lc fx.Lifecycle, in BaseIpfsRouting) (out p2pRouterOut, dr *dht.IpfsDHT) {
+	if dht, ok := in.(*dht.IpfsDHT); ok {
+		dr = dht
+
+		lc.Append(fx.Hook{
+			OnStop: func(ctx context.Context) error {
+				return dr.Close()
+			},
+		})
+	}
+
+	return p2pRouterOut{
+		Router: Router{
+			Priority: 1000,
+			Routing:  in,
+		},
+	}, dr
+}
+
+type p2pOnlineRoutingIn struct {
+	fx.In
+
+	Routers   []Router `group:"routers"`
+	Validator record.Validator
+}
+
+func Routing(in p2pOnlineRoutingIn) routing.Routing {
+	routers := in.Routers
+
+	sort.SliceStable(routers, func(i, j int) bool {
+		return routers[i].Priority < routers[j].Priority
+	})
+
+	irouters := make([]routing.Routing, len(routers))
+	for i, v := range routers {
+		irouters[i] = v.Routing
+	}
+
+	return routinghelpers.Tiered{
+		Routers:   irouters,
+		Validator: in.Validator,
+	}
+}
+
+type p2pPSRoutingIn struct {
+	fx.In
+
+	BaseIpfsRouting BaseIpfsRouting
+	Validator       record.Validator
+	Host            host.Host
+	PubSub          *pubsub.PubSub `optional:"true"`
+}
+
+func PubsubRouter(mctx helpers.MetricsCtx, lc fx.Lifecycle, in p2pPSRoutingIn) (p2pRouterOut, *namesys.PubsubValueStore) {
+	psRouter := namesys.NewPubsubValueStore(
+		helpers.LifecycleCtx(mctx, lc),
+		in.Host,
+		in.BaseIpfsRouting,
+		in.PubSub,
+		in.Validator,
+	)
+
+	return p2pRouterOut{
+		Router: Router{
+			Routing: &routinghelpers.Compose{
+				ValueStore: &routinghelpers.LimitedValueStore{
+					ValueStore: psRouter,
+					Namespaces: []string{"ipns"},
+				},
+			},
+			Priority: 100,
+		},
+	}, psRouter
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/routingopt.go

@@ -0,0 +1,36 @@
+package libp2p
+
+import (
+	"context"
+
+	"github.com/ipfs/go-datastore"
+	nilrouting "github.com/ipfs/go-ipfs-routing/none"
+	host "github.com/libp2p/go-libp2p-core/host"
+	routing "github.com/libp2p/go-libp2p-core/routing"
+	dht "github.com/libp2p/go-libp2p-kad-dht"
+	dhtopts "github.com/libp2p/go-libp2p-kad-dht/opts"
+	record "github.com/libp2p/go-libp2p-record"
+)
+
+type RoutingOption func(context.Context, host.Host, datastore.Batching, record.Validator) (routing.Routing, error)
+
+func constructDHTRouting(ctx context.Context, host host.Host, dstore datastore.Batching, validator record.Validator) (routing.Routing, error) {
+	return dht.New(
+		ctx, host,
+		dhtopts.Datastore(dstore),
+		dhtopts.Validator(validator),
+	)
+}
+
+func constructClientDHTRouting(ctx context.Context, host host.Host, dstore datastore.Batching, validator record.Validator) (routing.Routing, error) {
+	return dht.New(
+		ctx, host,
+		dhtopts.Client(true),
+		dhtopts.Datastore(dstore),
+		dhtopts.Validator(validator),
+	)
+}
+
+var DHTOption RoutingOption = constructDHTRouting
+var DHTClientOption RoutingOption = constructClientDHTRouting
+var NilRouterOption RoutingOption = nilrouting.ConstructNilRouting

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/smux.go

@@ -0,0 +1,54 @@
+package libp2p
+
+import (
+	"os"
+	"strings"
+
+	"github.com/libp2p/go-libp2p"
+	smux "github.com/libp2p/go-libp2p-core/mux"
+	mplex "github.com/libp2p/go-libp2p-mplex"
+	yamux "github.com/libp2p/go-libp2p-yamux"
+)
+
+func makeSmuxTransportOption(mplexExp bool) libp2p.Option {
+	const yamuxID = "/yamux/1.0.0"
+	const mplexID = "/mplex/6.7.0"
+
+	ymxtpt := *yamux.DefaultTransport
+	ymxtpt.AcceptBacklog = 512
+
+	if os.Getenv("YAMUX_DEBUG") != "" {
+		ymxtpt.LogOutput = os.Stderr
+	}
+
+	muxers := map[string]smux.Multiplexer{yamuxID: &ymxtpt}
+	if mplexExp {
+		muxers[mplexID] = mplex.DefaultTransport
+	}
+
+	// Allow muxer preference order overriding
+	order := []string{yamuxID, mplexID}
+	if prefs := os.Getenv("LIBP2P_MUX_PREFS"); prefs != "" {
+		order = strings.Fields(prefs)
+	}
+
+	opts := make([]libp2p.Option, 0, len(order))
+	for _, id := range order {
+		tpt, ok := muxers[id]
+		if !ok {
+			log.Warning("unknown or duplicate muxer in LIBP2P_MUX_PREFS: %s", id)
+			continue
+		}
+		delete(muxers, id)
+		opts = append(opts, libp2p.Muxer(id, tpt))
+	}
+
+	return libp2p.ChainOptions(opts...)
+}
+
+func SmuxTransport(mplex bool) func() (opts Libp2pOpts, err error) {
+	return func() (opts Libp2pOpts, err error) {
+		opts.Opts = append(opts.Opts, makeSmuxTransportOption(mplex))
+		return
+	}
+}

vendor/github.com/ipfs/go-ipfs/core/node/libp2p/transport.go

@@ -0,0 +1,38 @@
+package libp2p
+
+import (
+	"github.com/libp2p/go-libp2p"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	libp2pquic "github.com/libp2p/go-libp2p-quic-transport"
+	secio "github.com/libp2p/go-libp2p-secio"
+	tls "github.com/libp2p/go-libp2p-tls"
+)
+
+var DefaultTransports = simpleOpt(libp2p.DefaultTransports)
+var QUIC = simpleOpt(libp2p.Transport(libp2pquic.NewTransport))
+
+func Security(enabled, preferTLS bool) interface{} {
+	if !enabled {
+		return func() (opts Libp2pOpts) {
+			// TODO: shouldn't this be Errorf to guarantee visibility?
+			log.Warningf(`Your IPFS node has been configured to run WITHOUT ENCRYPTED CONNECTIONS.
+		You will not be able to connect to any nodes configured to use encrypted connections`)
+			opts.Opts = append(opts.Opts, libp2p.NoSecurity)
+			return opts
+		}
+	}
+	return func() (opts Libp2pOpts) {
+		if preferTLS {
+			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(tls.ID, tls.New), libp2p.Security(secio.ID, secio.New)))
+		} else {
+			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(secio.ID, secio.New), libp2p.Security(tls.ID, tls.New)))
+		}
+		return opts
+	}
+}
+
+func BandwidthCounter() (opts Libp2pOpts, reporter metrics.Reporter) {
+	reporter = metrics.NewBandwidthCounter()
+	opts.Opts = append(opts.Opts, libp2p.BandwidthReporter(reporter))
+	return opts, reporter
+}

vendor/github.com/ipfs/go-ipfs/core/node/provider.go

@@ -0,0 +1,117 @@
+package node
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/provider"
+	q "github.com/ipfs/go-ipfs/provider/queue"
+	"github.com/ipfs/go-ipfs/provider/simple"
+	"github.com/ipfs/go-ipfs/repo"
+	"github.com/libp2p/go-libp2p-core/routing"
+	"go.uber.org/fx"
+)
+
+const kReprovideFrequency = time.Hour * 12
+
+// SIMPLE
+
+// ProviderQueue creates new datastore backed provider queue
+func ProviderQueue(mctx helpers.MetricsCtx, lc fx.Lifecycle, repo repo.Repo) (*q.Queue, error) {
+	return q.NewQueue(helpers.LifecycleCtx(mctx, lc), "provider-v1", repo.Datastore())
+}
+
+// SimpleProvider creates new record provider
+func SimpleProvider(mctx helpers.MetricsCtx, lc fx.Lifecycle, queue *q.Queue, rt routing.Routing) provider.Provider {
+	return simple.NewProvider(helpers.LifecycleCtx(mctx, lc), queue, rt)
+}
+
+// SimpleReprovider creates new reprovider
+func SimpleReprovider(reproviderInterval time.Duration) interface{} {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, rt routing.Routing, keyProvider simple.KeyChanFunc) (provider.Reprovider, error) {
+		return simple.NewReprovider(helpers.LifecycleCtx(mctx, lc), reproviderInterval, rt, keyProvider), nil
+	}
+}
+
+// SimpleProviderSys creates new provider system
+func SimpleProviderSys(isOnline bool) interface{} {
+	return func(lc fx.Lifecycle, p provider.Provider, r provider.Reprovider) provider.System {
+		sys := provider.NewSystem(p, r)
+
+		if isOnline {
+			lc.Append(fx.Hook{
+				OnStart: func(ctx context.Context) error {
+					sys.Run()
+					return nil
+				},
+				OnStop: func(ctx context.Context) error {
+					return sys.Close()
+				},
+			})
+		}
+
+		return sys
+	}
+}
+
+// ONLINE/OFFLINE
+
+// OnlineProviders groups units managing provider routing records online
+func OnlineProviders(useStrategicProviding bool, reprovideStrategy string, reprovideInterval string) fx.Option {
+	if useStrategicProviding {
+		return fx.Provide(provider.NewOfflineProvider)
+	}
+
+	return fx.Options(
+		SimpleProviders(reprovideStrategy, reprovideInterval),
+		fx.Provide(SimpleProviderSys(true)),
+	)
+}
+
+// OfflineProviders groups units managing provider routing records offline
+func OfflineProviders(useStrategicProviding bool, reprovideStrategy string, reprovideInterval string) fx.Option {
+	if useStrategicProviding {
+		return fx.Provide(provider.NewOfflineProvider)
+	}
+
+	return fx.Options(
+		SimpleProviders(reprovideStrategy, reprovideInterval),
+		fx.Provide(SimpleProviderSys(false)),
+	)
+}
+
+// SimpleProviders creates the simple provider/reprovider dependencies
+func SimpleProviders(reprovideStrategy string, reprovideInterval string) fx.Option {
+	reproviderInterval := kReprovideFrequency
+	if reprovideInterval != "" {
+		dur, err := time.ParseDuration(reprovideInterval)
+		if err != nil {
+			return fx.Error(err)
+		}
+
+		reproviderInterval = dur
+	}
+
+	var keyProvider fx.Option
+	switch reprovideStrategy {
+	case "all":
+		fallthrough
+	case "":
+		keyProvider = fx.Provide(simple.NewBlockstoreProvider)
+	case "roots":
+		keyProvider = fx.Provide(simple.NewPinnedProvider(true))
+	case "pinned":
+		keyProvider = fx.Provide(simple.NewPinnedProvider(false))
+	default:
+		return fx.Error(fmt.Errorf("unknown reprovider strategy '%s'", reprovideStrategy))
+	}
+
+	return fx.Options(
+		fx.Provide(ProviderQueue),
+		fx.Provide(SimpleProvider),
+		keyProvider,
+		fx.Provide(SimpleReprovider(reproviderInterval)),
+	)
+}

vendor/github.com/ipfs/go-ipfs/core/node/storage.go

@@ -0,0 +1,94 @@
+package node
+
+import (
+	"os"
+	"syscall"
+	"time"
+
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/retrystore"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	config "github.com/ipfs/go-ipfs-config"
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-ipfs/core/node/helpers"
+	"github.com/ipfs/go-ipfs/filestore"
+	"github.com/ipfs/go-ipfs/repo"
+	"github.com/ipfs/go-ipfs/thirdparty/cidv0v1"
+	"github.com/ipfs/go-ipfs/thirdparty/verifbs"
+)
+
+func isTooManyFDError(err error) bool {
+	perr, ok := err.(*os.PathError)
+	if ok && perr.Err == syscall.EMFILE {
+		return true
+	}
+
+	return false
+}
+
+// RepoConfig loads configuration from the repo
+func RepoConfig(repo repo.Repo) (*config.Config, error) {
+	return repo.Config()
+}
+
+// Datastore provides the datastore
+func Datastore(repo repo.Repo) datastore.Datastore {
+	return repo.Datastore()
+}
+
+// BaseBlocks is the lower level blockstore without GC or Filestore layers
+type BaseBlocks blockstore.Blockstore
+
+// BaseBlockstoreCtor creates cached blockstore backed by the provided datastore
+func BaseBlockstoreCtor(cacheOpts blockstore.CacheOpts, nilRepo bool, hashOnRead bool) func(mctx helpers.MetricsCtx, repo repo.Repo, lc fx.Lifecycle) (bs BaseBlocks, err error) {
+	return func(mctx helpers.MetricsCtx, repo repo.Repo, lc fx.Lifecycle) (bs BaseBlocks, err error) {
+		rds := &retrystore.Datastore{
+			Batching:    repo.Datastore(),
+			Delay:       time.Millisecond * 200,
+			Retries:     6,
+			TempErrFunc: isTooManyFDError,
+		}
+		// hash security
+		bs = blockstore.NewBlockstore(rds)
+		bs = &verifbs.VerifBS{Blockstore: bs}
+
+		if !nilRepo {
+			bs, err = blockstore.CachedBlockstore(helpers.LifecycleCtx(mctx, lc), bs, cacheOpts)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		bs = blockstore.NewIdStore(bs)
+		bs = cidv0v1.NewBlockstore(bs)
+
+		if hashOnRead { // TODO: review: this is how it was done originally, is there a reason we can't just pass this directly?
+			bs.HashOnRead(true)
+		}
+
+		return
+	}
+}
+
+// GcBlockstoreCtor wraps the base blockstore with GC and Filestore layers
+func GcBlockstoreCtor(bb BaseBlocks) (gclocker blockstore.GCLocker, gcbs blockstore.GCBlockstore, bs blockstore.Blockstore) {
+	gclocker = blockstore.NewGCLocker()
+	gcbs = blockstore.NewGCBlockstore(bb, gclocker)
+
+	bs = gcbs
+	return
+}
+
+// GcBlockstoreCtor wraps GcBlockstore and adds Filestore support
+func FilestoreBlockstoreCtor(repo repo.Repo, bb BaseBlocks) (gclocker blockstore.GCLocker, gcbs blockstore.GCBlockstore, bs blockstore.Blockstore, fstore *filestore.Filestore) {
+	gclocker = blockstore.NewGCLocker()
+
+	// hash security
+	fstore = filestore.NewFilestore(bb, repo.FileManager())
+	gcbs = blockstore.NewGCBlockstore(fstore, gclocker)
+	gcbs = &verifbs.VerifBSGC{GCBlockstore: gcbs}
+
+	bs = gcbs
+	return
+}