Merge pull request #2 from libp2p/master

refactor merge

examples/protocol-multiplexing-with-multicodecs/main.go

@@ -8,15 +8,11 @@ import (
 	"math/rand"
 	"time"
 
-	crypto "github.com/libp2p/go-libp2p-crypto"
 	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
-	peer "github.com/libp2p/go-libp2p-peer"
 	ps "github.com/libp2p/go-libp2p-peerstore"
-	swarm "github.com/libp2p/go-libp2p-swarm"
-	ma "github.com/multiformats/go-multiaddr"
 
-	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+	libp2p "github.com/libp2p/go-libp2p"
 	multicodec "github.com/multiformats/go-multicodec"
 	json "github.com/multiformats/go-multicodec/json"
 )
@@ -80,17 +76,11 @@ var conversationMsgs = []string{
 }
 
 func makeRandomHost(port int) host.Host {
-	// Ignoring most errors for brevity
-	// See echo example for more details and better implementation
-	priv, pub, _ := crypto.GenerateKeyPair(crypto.RSA, 2048)
-	pid, _ := peer.IDFromPublicKey(pub)
-	listen, _ := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port))
-	ps := ps.NewPeerstore()
-	ps.AddPrivKey(pid, priv)
-	ps.AddPubKey(pid, pub)
-	n, _ := swarm.NewNetwork(context.Background(),
-		[]ma.Multiaddr{listen}, pid, ps, nil)
-	return bhost.New(n)
+	h, err := libp2p.New(context.Background(), libp2p.ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)))
+	if err != nil {
+		panic(err)
+	}
+	return h
 }
 
 func main() {

libp2p.go

@@ -2,240 +2,49 @@ package libp2p
 
 import (
 	"context"
-	"crypto/rand"
-	"fmt"
 
-	crypto "github.com/libp2p/go-libp2p-crypto"
+	config "github.com/libp2p/go-libp2p/config"
+
 	host "github.com/libp2p/go-libp2p-host"
-	pnet "github.com/libp2p/go-libp2p-interface-pnet"
-	metrics "github.com/libp2p/go-libp2p-metrics"
-	peer "github.com/libp2p/go-libp2p-peer"
-	pstore "github.com/libp2p/go-libp2p-peerstore"
-	swarm "github.com/libp2p/go-libp2p-swarm"
-	transport "github.com/libp2p/go-libp2p-transport"
-	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
-	mux "github.com/libp2p/go-stream-muxer"
-	ma "github.com/multiformats/go-multiaddr"
-	mplex "github.com/whyrusleeping/go-smux-multiplex"
-	msmux "github.com/whyrusleeping/go-smux-multistream"
-	yamux "github.com/whyrusleeping/go-smux-yamux"
 )
 
 // Config describes a set of settings for a libp2p node
-type Config struct {
-	Transports   []transport.Transport
-	Muxer        mux.Transport
-	ListenAddrs  []ma.Multiaddr
-	PeerKey      crypto.PrivKey
-	Peerstore    pstore.Peerstore
-	Protector    pnet.Protector
-	Reporter     metrics.Reporter
-	DisableSecio bool
-	EnableNAT    bool
-}
-
-type Option func(cfg *Config) error
+type Config = config.Config
 
-func Transports(tpts ...transport.Transport) Option {
-	return func(cfg *Config) error {
-		cfg.Transports = append(cfg.Transports, tpts...)
-		return nil
-	}
-}
+// Option is a libp2p config option that can be given to the libp2p constructor
+// (`libp2p.New`).
+type Option = config.Option
 
-func ListenAddrStrings(s ...string) Option {
+// ChainOptions chains multiple options into a single option.
+func ChainOptions(opts ...Option) Option {
 	return func(cfg *Config) error {
-		for _, addrstr := range s {
-			a, err := ma.NewMultiaddr(addrstr)
-			if err != nil {
+		for _, opt := range opts {
+			if err := opt(cfg); err != nil {
 				return err
 			}
-			cfg.ListenAddrs = append(cfg.ListenAddrs, a)
-		}
-		return nil
-	}
-}
-
-func ListenAddrs(addrs ...ma.Multiaddr) Option {
-	return func(cfg *Config) error {
-		cfg.ListenAddrs = append(cfg.ListenAddrs, addrs...)
-		return nil
-	}
-}
-
-type transportEncOpt int
-
-const (
-	EncPlaintext = transportEncOpt(0)
-	EncSecio     = transportEncOpt(1)
-)
-
-func TransportEncryption(tenc ...transportEncOpt) Option {
-	return func(cfg *Config) error {
-		if len(tenc) != 1 {
-			return fmt.Errorf("can only specify a single transport encryption option right now")
-		}
-
-		// TODO: actually make this pluggable, otherwise tls will get tricky
-		switch tenc[0] {
-		case EncPlaintext:
-			cfg.DisableSecio = true
-		case EncSecio:
-			// noop
-		default:
-			return fmt.Errorf("unrecognized transport encryption option: %d", tenc[0])
-		}
-		return nil
-	}
-}
-
-func NoEncryption() Option {
-	return TransportEncryption(EncPlaintext)
-}
-
-func NATPortMap() Option {
-	return func(cfg *Config) error {
-		cfg.EnableNAT = true
-		return nil
-	}
-}
-
-func Muxer(m mux.Transport) Option {
-	return func(cfg *Config) error {
-		if cfg.Muxer != nil {
-			return fmt.Errorf("cannot specify multiple muxer options")
 		}
-
-		cfg.Muxer = m
-		return nil
-	}
-}
-
-func Peerstore(ps pstore.Peerstore) Option {
-	return func(cfg *Config) error {
-		if cfg.Peerstore != nil {
-			return fmt.Errorf("cannot specify multiple peerstore options")
-		}
-
-		cfg.Peerstore = ps
-		return nil
-	}
-}
-
-func PrivateNetwork(prot pnet.Protector) Option {
-	return func(cfg *Config) error {
-		if cfg.Protector != nil {
-			return fmt.Errorf("cannot specify multiple private network options")
-		}
-
-		cfg.Protector = prot
-		return nil
-	}
-}
-
-func BandwidthReporter(rep metrics.Reporter) Option {
-	return func(cfg *Config) error {
-		if cfg.Reporter != nil {
-			return fmt.Errorf("cannot specify multiple bandwidth reporter options")
-		}
-
-		cfg.Reporter = rep
-		return nil
-	}
-}
-
-func Identity(sk crypto.PrivKey) Option {
-	return func(cfg *Config) error {
-		if cfg.PeerKey != nil {
-			return fmt.Errorf("cannot specify multiple identities")
-		}
-
-		cfg.PeerKey = sk
 		return nil
 	}
 }
 
+// New constructs a new libp2p node with the given options (falling back on
+// reasonable defaults).
+//
+// Canceling the passed context will stop the returned libp2p node.
 func New(ctx context.Context, opts ...Option) (host.Host, error) {
-	var cfg Config
-	for _, opt := range opts {
-		if err := opt(&cfg); err != nil {
-			return nil, err
-		}
-	}
-
-	return newWithCfg(ctx, &cfg)
+	return NewWithoutDefaults(ctx, append(opts, FallbackDefaults)...)
 }
 
-func newWithCfg(ctx context.Context, cfg *Config) (host.Host, error) {
-	// If no key was given, generate a random 2048 bit RSA key
-	if cfg.PeerKey == nil {
-		priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, rand.Reader)
-		if err != nil {
-			return nil, err
-		}
-		cfg.PeerKey = priv
-	}
-
-	// Obtain Peer ID from public key
-	pid, err := peer.IDFromPublicKey(cfg.PeerKey.GetPublic())
-	if err != nil {
-		return nil, err
-	}
-
-	// Create a new blank peerstore if none was passed in
-	ps := cfg.Peerstore
-	if ps == nil {
-		ps = pstore.NewPeerstore()
-	}
-
-	// Set default muxer if none was passed in
-	muxer := cfg.Muxer
-	if muxer == nil {
-		muxer = DefaultMuxer()
-	}
-
-	// If secio is disabled, don't add our private key to the peerstore
-	if !cfg.DisableSecio {
-		ps.AddPrivKey(pid, cfg.PeerKey)
-		ps.AddPubKey(pid, cfg.PeerKey.GetPublic())
-	}
-
-	swrm, err := swarm.NewSwarmWithProtector(ctx, cfg.ListenAddrs, pid, ps, cfg.Protector, muxer, cfg.Reporter)
-	if err != nil {
+// NewWithoutDefaults constructs a new libp2p node with the given options but
+// *without* falling back on reasonable defaults.
+//
+// Warning: This function should not be considered a stable interface. We may
+// choose to add required services at any time and, by using this function, you
+// opt-out of any defaults we may provide.
+func NewWithoutDefaults(ctx context.Context, opts ...Option) (host.Host, error) {
+	var cfg Config
+	if err := cfg.Apply(opts...); err != nil {
 		return nil, err
 	}
-
-	netw := (*swarm.Network)(swrm)
-
-	hostOpts := &bhost.HostOpts{}
-
-	if cfg.EnableNAT {
-		hostOpts.NATManager = bhost.NewNATManager(netw)
-	}
-
-	return bhost.NewHost(ctx, netw, hostOpts)
-}
-
-func DefaultMuxer() mux.Transport {
-	// Set up stream multiplexer
-	tpt := msmux.NewBlankTransport()
-
-	// By default, support yamux and multiplex
-	tpt.AddTransport("/yamux/1.0.0", yamux.DefaultTransport)
-	tpt.AddTransport("/mplex/6.3.0", mplex.DefaultTransport)
-
-	return tpt
-}
-
-func Defaults(cfg *Config) error {
-	// Create a multiaddress that listens on a random port on all interfaces
-	addr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/0")
-	if err != nil {
-		return err
-	}
-
-	cfg.ListenAddrs = []ma.Multiaddr{addr}
-	cfg.Peerstore = pstore.NewPeerstore()
-	cfg.Muxer = DefaultMuxer()
-	return nil
+	return cfg.NewNode(ctx)
 }

libp2p_test.go

@@ -3,6 +3,7 @@ package libp2p
 import (
 	"context"
 	"fmt"
+	"strings"
 	"testing"
 
 	crypto "github.com/libp2p/go-libp2p-crypto"
@@ -10,10 +11,32 @@ import (
 )
 
 func TestNewHost(t *testing.T) {
-	_, err := makeRandomHost(t, 9000)
+	h, err := makeRandomHost(t, 9000)
 	if err != nil {
 		t.Fatal(err)
 	}
+	h.Close()
+}
+
+func TestBadTransportConstructor(t *testing.T) {
+	ctx := context.Background()
+	h, err := New(ctx, Transport(func() {}))
+	if err == nil {
+		h.Close()
+		t.Fatal("expected an error")
+	}
+	if !strings.Contains(err.Error(), "libp2p_test.go") {
+		t.Error("expected error to contain debugging info")
+	}
+}
+
+func TestInsecure(t *testing.T) {
+	ctx := context.Background()
+	h, err := New(ctx, NoSecurity)
+	if err != nil {
+		t.Fatal(err)
+	}
+	h.Close()
 }
 
 func makeRandomHost(t *testing.T, port int) (host.Host, error) {
@@ -26,7 +49,9 @@ func makeRandomHost(t *testing.T, port int) (host.Host, error) {
 	opts := []Option{
 		ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", port)),
 		Identity(priv),
-		Muxer(DefaultMuxer()),
+		DefaultTransports,
+		DefaultMuxers,
+		DefaultSecurity,
 		NATPortMap(),
 	}
 

options.go

+package libp2p
+
+// This file contains all libp2p configuration options (except the defaults,
+// those are in defaults.go)
+
+import (
+	"fmt"
+	"net"
+
+	config "github.com/libp2p/go-libp2p/config"
+	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
+
+	circuit "github.com/libp2p/go-libp2p-circuit"
+	crypto "github.com/libp2p/go-libp2p-crypto"
+	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
+	pnet "github.com/libp2p/go-libp2p-interface-pnet"
+	metrics "github.com/libp2p/go-libp2p-metrics"
+	pstore "github.com/libp2p/go-libp2p-peerstore"
+	filter "github.com/libp2p/go-maddr-filter"
+	ma "github.com/multiformats/go-multiaddr"
+)
+
+// ListenAddrStrings configures libp2p to listen on the given (unparsed)
+// addresses.
+func ListenAddrStrings(s ...string) Option {
+	return func(cfg *Config) error {
+		for _, addrstr := range s {
+			a, err := ma.NewMultiaddr(addrstr)
+			if err != nil {
+				return err
+			}
+			cfg.ListenAddrs = append(cfg.ListenAddrs, a)
+		}
+		return nil
+	}
+}
+
+// ListenAddrs configures libp2p to listen on the given addresses.
+func ListenAddrs(addrs ...ma.Multiaddr) Option {
+	return func(cfg *Config) error {
+		cfg.ListenAddrs = append(cfg.ListenAddrs, addrs...)
+		return nil
+	}
+}
+
+// Security configures libp2p to use the given security transport (or transport
+// constructor).
+//
+// Name is the protocol name.
+//
+// The transport can be a constructed security.Transport or a function taking
+// any subset of this libp2p node's:
+// * Public key
+// * Private key
+// * Peer ID
+// * Host
+// * Network
+// * Peerstore
+func Security(name string, tpt interface{}) Option {
+	stpt, err := config.SecurityConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		if cfg.Insecure {
+			return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
+		}
+		cfg.SecurityTransports = append(cfg.SecurityTransports, config.MsSecC{SecC: stpt, ID: name})
+		return nil
+	}
+}
+
+// NoSecurity is an option that completely disables all transport security.
+// It's incompatible with all other transport security protocols.
+var NoSecurity Option = func(cfg *Config) error {
+	if len(cfg.SecurityTransports) > 0 {
+		return fmt.Errorf("cannot use security transports with an insecure libp2p configuration")
+	}
+	cfg.Insecure = true
+	return nil
+}
+
+// Muxer configures libp2p to use the given stream multiplexer (or stream
+// multiplexer constructor).
+//
+// Name is the protocol name.
+//
+// The transport can be a constructed mux.Transport or a function taking any
+// subset of this libp2p node's:
+// * Peer ID
+// * Host
+// * Network
+// * Peerstore
+func Muxer(name string, tpt interface{}) Option {
+	mtpt, err := config.MuxerConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		cfg.Muxers = append(cfg.Muxers, config.MsMuxC{MuxC: mtpt, ID: name})
+		return nil
+	}
+}
+
+// Transport configures libp2p to use the given transport (or transport
+// constructor).
+//
+// The transport can be a constructed transport.Transport or a function taking
+// any subset of this libp2p node's:
+// * Transport Upgrader (*tptu.Upgrader)
+// * Host
+// * Stream muxer (muxer.Transport)
+// * Security transport (security.Transport)
+// * Private network protector (pnet.Protector)
+// * Peer ID
+// * Private Key
+// * Public Key
+// * Address filter (filter.Filter)
+// * Peerstore
+func Transport(tpt interface{}) Option {
+	tptc, err := config.TransportConstructor(tpt)
+	err = traceError(err, 1)
+	return func(cfg *Config) error {
+		if err != nil {
+			return err
+		}
+		cfg.Transports = append(cfg.Transports, tptc)
+		return nil
+	}
+}
+
+// Peerstore configures libp2p to use the given peerstore.
+func Peerstore(ps pstore.Peerstore) Option {
+	return func(cfg *Config) error {
+		if cfg.Peerstore != nil {
+			return fmt.Errorf("cannot specify multiple peerstore options")
+		}
+
+		cfg.Peerstore = ps
+		return nil
+	}
+}
+
+// PrivateNetwork configures libp2p to use the given private network protector.
+func PrivateNetwork(prot pnet.Protector) Option {
+	return func(cfg *Config) error {
+		if cfg.Protector != nil {
+			return fmt.Errorf("cannot specify multiple private network options")
+		}
+
+		cfg.Protector = prot
+		return nil
+	}
+}
+
+// BandwidthReporter configures libp2p to use the given bandwidth reporter.
+func BandwidthReporter(rep metrics.Reporter) Option {
+	return func(cfg *Config) error {
+		if cfg.Reporter != nil {
+			return fmt.Errorf("cannot specify multiple bandwidth reporter options")
+		}
+
+		cfg.Reporter = rep
+		return nil
+	}
+}
+
+// Identity configures libp2p to use the given private key to identify itself.
+func Identity(sk crypto.PrivKey) Option {
+	return func(cfg *Config) error {
+		if cfg.PeerKey != nil {
+			return fmt.Errorf("cannot specify multiple identities")
+		}
+
+		cfg.PeerKey = sk
+		return nil
+	}
+}
+
+// ConnectionManager configures libp2p to use the given connection manager.
+func ConnectionManager(connman ifconnmgr.ConnManager) Option {
+	return func(cfg *Config) error {
+		if cfg.ConnManager != nil {
+			return fmt.Errorf("cannot specify multiple connection managers")
+		}
+		cfg.ConnManager = connman
+		return nil
+	}
+}
+
+// AddrsFactory configures libp2p to use the given address factory.
+func AddrsFactory(factory config.AddrsFactory) Option {
+	return func(cfg *Config) error {
+		if cfg.AddrsFactory != nil {
+			return fmt.Errorf("cannot specify multiple address factories")
+		}
+		cfg.AddrsFactory = factory
+		return nil
+	}
+}
+
+// EnableRelay configures libp2p to enable the relay transport.
+func EnableRelay(options ...circuit.RelayOpt) Option {
+	return func(cfg *Config) error {
+		cfg.Relay = true
+		cfg.RelayOpts = options
+		return nil
+	}
+}
+
+// FilterAddresses configures libp2p to never dial nor accept connections from
+// the given addresses.
+func FilterAddresses(addrs ...*net.IPNet) Option {
+	return func(cfg *Config) error {
+		if cfg.Filters == nil {
+			cfg.Filters = filter.NewFilters()
+		}
+		for _, addr := range addrs {
+			cfg.Filters.AddDialFilter(addr)
+		}
+		return nil
+	}
+}
+
+// NATPortMap configures libp2p to use the default NATManager. The default
+// NATManager will attempt to open a port in your network's firewall using UPnP.
+func NATPortMap() Option {
+	return NATManager(bhost.NewNATManager)
+}
+
+// NATManager will configure libp2p to use the requested NATManager. This
+// function should be passed a NATManager *constructor* that takes a libp2p Network.
+func NATManager(nm config.NATManagerC) Option {
+	return func(cfg *Config) error {
+		if cfg.NATManager != nil {
+			return fmt.Errorf("cannot specify multiple NATManagers")
+		}
+		cfg.NATManager = nm
+		return nil
+	}
+}

p2p/discovery/mdns_test.go

@@ -8,7 +8,7 @@ import (
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
 
 	host "github.com/libp2p/go-libp2p-host"
-	netutil "github.com/libp2p/go-libp2p-netutil"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 
 	pstore "github.com/libp2p/go-libp2p-peerstore"
 )
@@ -28,8 +28,8 @@ func TestMdnsDiscovery(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	a := bhost.New(netutil.GenSwarmNetwork(t, ctx))
-	b := bhost.New(netutil.GenSwarmNetwork(t, ctx))
+	a := bhost.New(swarmt.GenSwarm(t, ctx))
+	b := bhost.New(swarmt.GenSwarm(t, ctx))
 
 	sa, err := NewMdnsService(ctx, a, time.Second, "someTag")
 	if err != nil {

p2p/host/basic/basic_host.go

@@ -9,10 +9,8 @@ import (
 
 	logging "github.com/ipfs/go-log"
 	goprocess "github.com/jbenet/goprocess"
-	circuit "github.com/libp2p/go-libp2p-circuit"
+	goprocessctx "github.com/jbenet/goprocess/context"
 	ifconnmgr "github.com/libp2p/go-libp2p-interface-connmgr"
-	metrics "github.com/libp2p/go-libp2p-metrics"
-	mstream "github.com/libp2p/go-libp2p-metrics/stream"
 	inet "github.com/libp2p/go-libp2p-net"
 	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
@@ -67,8 +65,6 @@ type BasicHost struct {
 	negtimeout time.Duration
 
 	proc goprocess.Process
-
-	bwc metrics.Reporter
 }
 
 // HostOpts holds options that can be passed to NewHost in order to
@@ -97,25 +93,14 @@ type HostOpts struct {
 
 	// NATManager takes care of setting NAT port mappings, and discovering external addresses.
 	// If omitted, this will simply be disabled.
-	NATManager NATManager
-
-	// BandwidthReporter is used for collecting aggregate metrics of the
-	// bandwidth used by various protocols.
-	BandwidthReporter metrics.Reporter
+	NATManager func(inet.Network) NATManager
 
 	// ConnManager is a libp2p connection manager
 	ConnManager ifconnmgr.ConnManager
-
-	// Relay indicates whether the host should use circuit relay transport
-	EnableRelay bool
-
-	// RelayOpts are options for the relay transport; only meaningful when Relay=true
-	RelayOpts []circuit.RelayOpt
 }
 
 // NewHost constructs a new *BasicHost and activates it by attaching its stream and connection handlers to the given inet.Network.
 func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost, error) {
-	ctx, cancel := context.WithCancel(ctx)
 	h := &BasicHost{
 		network:    net,
 		mux:        msmux.NewMultistreamMuxer(),
@@ -124,11 +109,10 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
 		maResolver: madns.DefaultResolver,
 	}
 
-	h.proc = goprocess.WithTeardown(func() error {
+	h.proc = goprocessctx.WithContextAndTeardown(ctx, func() error {
 		if h.natmgr != nil {
 			h.natmgr.Close()
 		}
-		cancel()
 		return h.Network().Close()
 	})
 
@@ -152,18 +136,13 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
 	}
 
 	if opts.NATManager != nil {
-		h.natmgr = opts.NATManager
+		h.natmgr = opts.NATManager(net)
 	}
 
 	if opts.MultiaddrResolver != nil {
 		h.maResolver = opts.MultiaddrResolver
 	}
 
-	if opts.BandwidthReporter != nil {
-		h.bwc = opts.BandwidthReporter
-		h.ids.Reporter = opts.BandwidthReporter
-	}
-
 	if opts.ConnManager == nil {
 		h.cmgr = &ifconnmgr.NullConnMgr{}
 	} else {
@@ -173,20 +152,16 @@ func NewHost(ctx context.Context, net inet.Network, opts *HostOpts) (*BasicHost,
 
 	net.SetConnHandler(h.newConnHandler)
 	net.SetStreamHandler(h.newStreamHandler)
-
-	if opts.EnableRelay {
-		err := circuit.AddRelayTransport(ctx, h, opts.RelayOpts...)
-		if err != nil {
-			h.Close()
-			return nil, err
-		}
-	}
-
 	return h, nil
 }
 
 // New constructs and sets up a new *BasicHost with given Network and options.
-// Three options can be passed: NATPortMap, AddrsFactory, and metrics.Reporter.
+// The following options can be passed:
+// * NATPortMap
+// * AddrsFactory
+// * ifconnmgr.ConnManager
+// * madns.Resolver
+//
 // This function is deprecated in favor of NewHost and HostOpts.
 func New(net inet.Network, opts ...interface{}) *BasicHost {
 	hostopts := &HostOpts{}
@@ -196,10 +171,8 @@ func New(net inet.Network, opts ...interface{}) *BasicHost {
 		case Option:
 			switch o {
 			case NATPortMap:
-				hostopts.NATManager = newNatManager(net)
+				hostopts.NATManager = NewNATManager
 			}
-		case metrics.Reporter:
-			hostopts.BandwidthReporter = o
 		case AddrsFactory:
 			hostopts.AddrsFactory = AddrsFactory(o)
 		case ifconnmgr.ConnManager:
@@ -270,10 +243,6 @@ func (h *BasicHost) newStreamHandler(s inet.Stream) {
 	}
 
 	s.SetProtocol(protocol.ID(protoID))
-
-	if h.bwc != nil {
-		s = mstream.WrapStream(s, h.bwc)
-	}
 	log.Debugf("protocol negotiation took %s", took)
 
 	go handle(protoID, s)
@@ -366,10 +335,6 @@ func (h *BasicHost) NewStream(ctx context.Context, p peer.ID, pids ...protocol.I
 	s.SetProtocol(selpid)
 	h.Peerstore().AddProtocols(p, selected)
 
-	if h.bwc != nil {
-		s = mstream.WrapStream(s, h.bwc)
-	}
-
 	return s, nil
 }
 
@@ -403,10 +368,6 @@ func (h *BasicHost) newStream(ctx context.Context, p peer.ID, pid protocol.ID) (
 
 	s.SetProtocol(pid)
 
-	if h.bwc != nil {
-		s = mstream.WrapStream(s, h.bwc)
-	}
-
 	lzcon := msmux.NewMSSelect(s, string(pid))
 	return &streamWrapper{
 		Stream: s,
@@ -423,8 +384,7 @@ func (h *BasicHost) Connect(ctx context.Context, pi pstore.PeerInfo) error {
 	// absorb addresses into peerstore
 	h.Peerstore().AddAddrs(pi.ID, pi.Addrs, pstore.TempAddrTTL)
 
-	cs := h.Network().ConnsToPeer(pi.ID)
-	if len(cs) > 0 {
+	if h.Network().Connectedness(pi.ID) == inet.Connected {
 		return nil
 	}
 
@@ -471,7 +431,7 @@ func (h *BasicHost) resolveAddrs(ctx context.Context, pi pstore.PeerInfo) ([]ma.
 // dialPeer opens a connection to peer, and makes sure to identify
 // the connection once it has been opened.
 func (h *BasicHost) dialPeer(ctx context.Context, p peer.ID) error {
-	log.Debugf("host %s dialing %s", h.ID, p)
+	log.Debugf("host %s dialing %s", h.ID(), p)
 	c, err := h.Network().DialPeer(ctx, p)
 	if err != nil {
 		return err
@@ -536,11 +496,6 @@ func (h *BasicHost) Close() error {
 	return h.proc.Close()
 }
 
-// GetBandwidthReporter exposes the Host's bandiwth metrics reporter
-func (h *BasicHost) GetBandwidthReporter() metrics.Reporter {
-	return h.bwc
-}
-
 type streamWrapper struct {
 	inet.Stream
 	rw io.ReadWriter

p2p/host/basic/basic_host_test.go

@@ -8,11 +8,13 @@ import (
 	"testing"
 	"time"
 
+	testutil "github.com/libp2p/go-testutil"
+
 	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
-	testutil "github.com/libp2p/go-libp2p-netutil"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
 	protocol "github.com/libp2p/go-libp2p-protocol"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 	ma "github.com/multiformats/go-multiaddr"
 	madns "github.com/multiformats/go-multiaddr-dns"
 )
@@ -20,8 +22,8 @@ import (
 func TestHostSimple(t *testing.T) {
 
 	ctx := context.Background()
-	h1 := New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := New(swarmt.GenSwarm(t, ctx))
+	h2 := New(swarmt.GenSwarm(t, ctx))
 	defer h1.Close()
 	defer h2.Close()
 
@@ -74,7 +76,7 @@ func TestHostAddrsFactory(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	h := New(testutil.GenSwarmNetwork(t, ctx), AddrsFactory(addrsFactory))
+	h := New(swarmt.GenSwarm(t, ctx), AddrsFactory(addrsFactory))
 	defer h.Close()
 
 	addrs := h.Addrs()
@@ -87,8 +89,8 @@ func TestHostAddrsFactory(t *testing.T) {
 }
 
 func getHostPair(ctx context.Context, t *testing.T) (host.Host, host.Host) {
-	h1 := New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := New(swarmt.GenSwarm(t, ctx))
+	h2 := New(swarmt.GenSwarm(t, ctx))
 
 	h2pi := h2.Peerstore().PeerInfo(h2.ID())
 	if err := h1.Connect(ctx, h2pi); err != nil {
@@ -193,8 +195,8 @@ func TestHostProtoPreknowledge(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	h1 := New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := New(swarmt.GenSwarm(t, ctx))
+	h2 := New(swarmt.GenSwarm(t, ctx))
 
 	conn := make(chan protocol.ID)
 	handler := func(s inet.Stream) {
@@ -358,7 +360,7 @@ func TestAddrResolution(t *testing.T) {
 	}
 	resolver := &madns.Resolver{Backend: backend}
 
-	h := New(testutil.GenSwarmNetwork(t, ctx), resolver)
+	h := New(swarmt.GenSwarm(t, ctx), resolver)
 	defer h.Close()
 
 	pi, err := pstore.InfoFromP2pAddr(p2paddr1)

p2p/host/routed/routed.go

@@ -47,7 +47,7 @@ func Wrap(h host.Host, r Routing) *RoutedHost {
 // given peer, it will use its routing system to try to find some.
 func (rh *RoutedHost) Connect(ctx context.Context, pi pstore.PeerInfo) error {
 	// first, check if we're already connected.
-	if len(rh.Network().ConnsToPeer(pi.ID)) > 0 {
+	if rh.Network().Connectedness(pi.ID) == inet.Connected {
 		return nil
 	}
 

p2p/net/mock/mock_conn.go

@@ -118,12 +118,12 @@ func (c *conn) NewStream() (inet.Stream, error) {
 	return s, nil
 }
 
-func (c *conn) GetStreams() ([]inet.Stream, error) {
+func (c *conn) GetStreams() []inet.Stream {
 	var out []inet.Stream
 	for e := c.streams.Front(); e != nil; e = e.Next() {
 		out = append(out, e.Value.(*stream))
 	}
-	return out, nil
+	return out
 }
 
 // LocalMultiaddr is the Multiaddr on this side

p2p/net/mock/mock_test.go

@@ -582,3 +582,57 @@ func TestLimitedStreams(t *testing.T) {
 		t.Fatal("Expected 2ish seconds but got ", time.Since(before))
 	}
 }
+
+func TestStreamsWithLatency(t *testing.T) {
+	latency := time.Millisecond * 500
+
+	mn, err := WithNPeers(context.Background(), 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// configure the Mocknet with some latency and link/connect its peers
+	mn.SetLinkDefaults(LinkOptions{Latency: latency})
+	mn.LinkAll()
+	mn.ConnectAllButSelf()
+
+	msg := []byte("ping")
+	mln := len(msg)
+
+	var wg sync.WaitGroup
+
+	// we'll write once to a single stream
+	wg.Add(1)
+
+	handler := func(s inet.Stream) {
+		b := make([]byte, mln)
+
+		if _, err := io.ReadFull(s, b); err != nil {
+			t.Fatal(err)
+		}
+
+		wg.Done()
+		s.Close()
+	}
+
+	mn.Hosts()[0].SetStreamHandler(protocol.TestingID, handler)
+	mn.Hosts()[1].SetStreamHandler(protocol.TestingID, handler)
+
+	s, err := mn.Hosts()[0].NewStream(context.Background(), mn.Hosts()[1].ID(), protocol.TestingID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// writing to the stream will be subject to our configured latency
+	checkpoint := time.Now()
+	if _, err := s.Write(msg); err != nil {
+		t.Fatal(err)
+	}
+	wg.Wait()
+
+	delta := time.Since(checkpoint)
+	tolerance := time.Millisecond * 100
+	if !within(delta, latency, tolerance) {
+		t.Fatalf("Expected write to take ~%s (+/- %s), but took %s", latency.String(), tolerance.String(), delta.String())
+	}
+}

p2p/protocol/identify/id.go

@@ -13,8 +13,6 @@ import (
 	ic "github.com/libp2p/go-libp2p-crypto"
 	host "github.com/libp2p/go-libp2p-host"
 	lgbl "github.com/libp2p/go-libp2p-loggables"
-	metrics "github.com/libp2p/go-libp2p-metrics"
-	mstream "github.com/libp2p/go-libp2p-metrics/stream"
 	inet "github.com/libp2p/go-libp2p-net"
 	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
@@ -44,7 +42,6 @@ var ClientVersion = "go-libp2p/3.3.4"
 type IDService struct {
 	Host host.Host
 
-	Reporter metrics.Reporter
 	// connections undergoing identification
 	// for wait purposes
 	currid map[inet.Conn]chan struct{}
@@ -64,7 +61,7 @@ func NewIDService(h host.Host) *IDService {
 		Host:   h,
 		currid: make(map[inet.Conn]chan struct{}),
 	}
-	h.SetStreamHandler(ID, s.RequestHandler)
+	h.SetStreamHandler(ID, s.requestHandler)
 	h.Network().Notify((*netNotifiee)(s))
 	return s
 }
@@ -95,21 +92,17 @@ func (ids *IDService) IdentifyConn(c inet.Conn) {
 		c.Close()
 		return
 	}
-	defer s.Close()
+	defer inet.FullClose(s)
 
 	s.SetProtocol(ID)
 
-	if ids.Reporter != nil {
-		s = mstream.WrapStream(s, ids.Reporter)
-	}
-
 	// ok give the response to our handler.
 	if err := msmux.SelectProtoOrFail(ID, s); err != nil {
 		log.Event(context.TODO(), "IdentifyOpenFailed", c.RemotePeer(), logging.Metadata{"error": err})
 		return
 	}
 
-	ids.ResponseHandler(s)
+	ids.responseHandler(s)
 
 	ids.currmu.Lock()
 	_, found := ids.currid[c]
@@ -122,14 +115,10 @@ func (ids *IDService) IdentifyConn(c inet.Conn) {
 	}
 }
 
-func (ids *IDService) RequestHandler(s inet.Stream) {
-	defer s.Close()
+func (ids *IDService) requestHandler(s inet.Stream) {
+	defer inet.FullClose(s)
 	c := s.Conn()
 
-	if ids.Reporter != nil {
-		s = mstream.WrapStream(s, ids.Reporter)
-	}
-
 	w := ggio.NewDelimitedWriter(s)
 	mes := pb.Identify{}
 	ids.populateMessage(&mes, s.Conn())
@@ -139,8 +128,7 @@ func (ids *IDService) RequestHandler(s inet.Stream) {
 		c.RemotePeer(), c.RemoteMultiaddr())
 }
 
-func (ids *IDService) ResponseHandler(s inet.Stream) {
-	defer s.Close()
+func (ids *IDService) responseHandler(s inet.Stream) {
 	c := s.Conn()
 
 	r := ggio.NewDelimitedReader(s, 2048)
@@ -267,7 +255,7 @@ func (ids *IDService) consumeReceivedPubKey(c inet.Conn, kb []byte) {
 
 	newKey, err := ic.UnmarshalPublicKey(kb)
 	if err != nil {
-		log.Errorf("%s cannot unmarshal key from remote peer: %s", lp, rp)
+		log.Warningf("%s cannot unmarshal key from remote peer: %s, %s", lp, rp, err)
 		return
 	}
 

p2p/protocol/identify/id_test.go

@@ -6,9 +6,9 @@ import (
 	"time"
 
 	ic "github.com/libp2p/go-libp2p-crypto"
-	testutil "github.com/libp2p/go-libp2p-netutil"
 	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 	identify "github.com/libp2p/go-libp2p/p2p/protocol/identify"
 
 	blhost "github.com/libp2p/go-libp2p-blankhost"
@@ -20,8 +20,8 @@ func subtestIDService(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	h1 := blhost.NewBlankHost(testutil.GenSwarmNetwork(t, ctx))
-	h2 := blhost.NewBlankHost(testutil.GenSwarmNetwork(t, ctx))
+	h1 := blhost.NewBlankHost(swarmt.GenSwarm(t, ctx))
+	h2 := blhost.NewBlankHost(swarmt.GenSwarm(t, ctx))
 
 	h1p := h1.ID()
 	h2p := h2.ID()
@@ -65,7 +65,7 @@ func subtestIDService(t *testing.T) {
 	ids2.IdentifyConn(c[0])
 
 	addrs := h1.Peerstore().Addrs(h1p)
-	addrs = append(addrs, c[0].RemoteMultiaddr(), forgetMe)
+	addrs = append(addrs, forgetMe)
 
 	// and the protocol versions.
 	t.Log("test peer2 has peer1 addrs correctly")

p2p/protocol/ping/ping_test.go

@@ -5,17 +5,17 @@ import (
 	"testing"
 	"time"
 
-	netutil "github.com/libp2p/go-libp2p-netutil"
 	peer "github.com/libp2p/go-libp2p-peer"
 	pstore "github.com/libp2p/go-libp2p-peerstore"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
 )
 
 func TestPing(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	h1 := bhost.New(netutil.GenSwarmNetwork(t, ctx))
-	h2 := bhost.New(netutil.GenSwarmNetwork(t, ctx))
+	h1 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h2 := bhost.New(swarmt.GenSwarm(t, ctx))
 
 	err := h1.Connect(ctx, pstore.PeerInfo{
 		ID:    h2.ID(),

p2p/test/backpressure/backpressure_test.go

@@ -13,9 +13,9 @@ import (
 	logging "github.com/ipfs/go-log"
 	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
-	testutil "github.com/libp2p/go-libp2p-netutil"
 	peer "github.com/libp2p/go-libp2p-peer"
 	protocol "github.com/libp2p/go-libp2p-protocol"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 )
 
 var log = logging.Logger("backpressure")
@@ -137,8 +137,8 @@ a problem.
 	// ok that's enough setup. let's do it!
 
 	ctx := context.Background()
-	h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h2 := bhost.New(swarmt.GenSwarm(t, ctx))
 
 	// setup receiver handler
 	h1.SetStreamHandler(protocol.TestingID, receiver)
@@ -274,8 +274,8 @@ func TestStBackpressureStreamWrite(t *testing.T) {
 
 	// setup the networks
 	ctx := context.Background()
-	h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h2 := bhost.New(swarmt.GenSwarm(t, ctx))
 
 	// setup sender handler on 1
 	h1.SetStreamHandler(protocol.TestingID, sender)

p2p/test/reconnects/reconnect_test.go

@@ -14,17 +14,10 @@ import (
 	logging "github.com/ipfs/go-log"
 	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
-	testutil "github.com/libp2p/go-libp2p-netutil"
 	protocol "github.com/libp2p/go-libp2p-protocol"
-	swarm "github.com/libp2p/go-libp2p-swarm"
-	ps "github.com/libp2p/go-peerstream"
+	swarmt "github.com/libp2p/go-libp2p-swarm/testing"
 )
 
-func init() {
-	// change the garbage collect timeout for testing.
-	ps.GarbageCollectTimeout = 10 * time.Millisecond
-}
-
 var log = logging.Logger("reconnect")
 
 func EchoStreamHandler(stream inet.Stream) {
@@ -109,8 +102,8 @@ func newSender() (chan sendChans, func(s inet.Stream)) {
 // TestReconnect tests whether hosts are able to disconnect and reconnect.
 func TestReconnect2(t *testing.T) {
 	ctx := context.Background()
-	h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h2 := bhost.New(swarmt.GenSwarm(t, ctx))
 	hosts := []host.Host{h1, h2}
 
 	h1.SetStreamHandler(protocol.TestingID, EchoStreamHandler)
@@ -129,11 +122,11 @@ func TestReconnect2(t *testing.T) {
 // TestReconnect tests whether hosts are able to disconnect and reconnect.
 func TestReconnect5(t *testing.T) {
 	ctx := context.Background()
-	h1 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h2 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h3 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h4 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
-	h5 := bhost.New(testutil.GenSwarmNetwork(t, ctx))
+	h1 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h2 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h3 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h4 := bhost.New(swarmt.GenSwarm(t, ctx))
+	h5 := bhost.New(swarmt.GenSwarm(t, ctx))
 	hosts := []host.Host{h1, h2, h3, h4, h5}
 
 	h1.SetStreamHandler(protocol.TestingID, EchoStreamHandler)
@@ -219,13 +212,11 @@ func SubtestConnSendDisc(t *testing.T, hosts []host.Host) {
 		// close connection
 		cs := h1.Network().Conns()
 		for _, c := range cs {
-			sc := c.(*swarm.Conn)
-			if sc.LocalPeer() > sc.RemotePeer() {
-				continue // only close it on one side.
+			if c.LocalPeer() > c.RemotePeer() {
+				continue
 			}
-
-			log.Debugf("closing: %s", sc.RawConn())
-			sc.Close()
+			log.Debugf("closing: %s", c)
+			c.Close()
 		}
 	}
 

package.json

@@ -14,29 +14,19 @@
       "version": "0.0.0"
     },
     {
-      "hash": "QmWSvDKkcno2UyDg13rUBwWfhRsdj7uR3daAq57VoG5QeN",
+      "hash": "QmNeRzgrSpwbMU7VKLRyfvbqf1nRrAiQ7fEXaBxWGT5Ygr",
       "name": "mdns",
-      "version": "0.1.1"
+      "version": "0.1.3"
     },
     {
-      "hash": "QmWBug6eBS7AxRdCDVuSY5CnSit7cS2XnPFYJWqWDumhCG",
-      "name": "go-msgio",
-      "version": "0.0.3"
-    },
-    {
-      "hash": "QmNiJuT8Ja3hMVpBHXv3Q6dwmperaQ6JjLtpMQgMCD7xvx",
+      "hash": "QmPdKqUcHGFdeSpvjVoaTRPPstGif9GBZb5Q56RVw9o69A",
       "name": "go-ipfs-util",
-      "version": "1.2.7"
-    },
-    {
-      "hash": "QmUusaX99BZoELh7dmPgirqRQ1FAmMnmnBn3oiqDFGBUSc",
-      "name": "go-keyspace",
-      "version": "1.0.0"
+      "version": "1.2.8"
     },
     {
-      "hash": "QmTnsezaB1wWNRHeHnYrm8K4d5i9wtyj3GsqjC3Rt5b5v5",
+      "hash": "QmbXRda5H2K3MSQyWWxTMtd8DWuguEBUCe6hpxfXVpFUGj",
       "name": "go-multistream",
-      "version": "0.3.6"
+      "version": "0.3.7"
     },
     {
       "hash": "Qmf7HqcW7LtCi1W8y2bdx2eJpze74jkbKqpByxgXikdbLF",
@@ -49,29 +39,14 @@
       "version": "1.0.0"
     },
     {
-      "hash": "QmTG23dvpBCBjqQwyDxV8CQT6jmS4PSftNr1VqHhE3MLy7",
+      "hash": "QmcVVHfdyv15GVPk7NrxdWjh2hLVccXnoD8j2tyQShiXJb",
       "name": "go-log",
-      "version": "1.4.1"
+      "version": "1.5.3"
     },
     {
-      "hash": "QmRK2LxanhK2gZq6k6R7vk5ZoYZk8ULSSTB7FzDsMUX6CB",
+      "hash": "QmV6FjemM1K8oXjrvuq3wuVWWoU2TLDPmNnKrxHzY3v6Ai",
       "name": "go-multiaddr-net",
-      "version": "1.5.7"
-    },
-    {
-      "hash": "QmZyZDi491cCNTLfAhwcaDii2Kg4pwKRkhqQzURGDvY6ua",
-      "name": "go-multihash",
-      "version": "1.0.7"
-    },
-    {
-      "hash": "QmSMZwvs3n4GBikZ7hKzT17c3bk65FmyZo2JqtJ16swqCv",
-      "name": "multiaddr-filter",
-      "version": "1.0.2"
-    },
-    {
-      "hash": "QmaPHkZLbQQbvcyavn8q1GFHg6o6yeceyHFSJ3Pjf3p3TQ",
-      "name": "go-crypto",
-      "version": "0.0.0"
+      "version": "1.6.3"
     },
     {
       "hash": "QmZ4Qi3GaRbjcx28Sme5eMH7RQjGkt8wHxt2a65oLaeFEV",
@@ -79,82 +54,45 @@
       "version": "0.0.0"
     },
     {
-      "hash": "QmWWQ2Txc2c6tqjsBpzg5Ar652cHPGNsQQp2SejkNmkUMb",
+      "hash": "QmYmsdtJ3HsodkePE3eU3TsCaP2YvPZJ4LoXnNkDE5Tpt7",
       "name": "go-multiaddr",
-      "version": "1.2.6"
-    },
-    {
-      "hash": "QmeYJHEk8UjVVZ4XCRTZe6dFQrb8pGWD81LYCgeLp8CvMB",
-      "name": "go-metrics",
-      "version": "0.0.0"
-    },
-    {
-      "hash": "QmYvsG72GsfLgUeSojXArjnU6L4Wmwk7wuAxtNLuyXcc1T",
-      "name": "randbo",
-      "version": "0.0.0"
-    },
-    {
-      "hash": "QmeQW4ayVqi7Jjay1SrP2wYydsH9KwSrzQBnqyC25gPFnG",
-      "name": "go-notifier",
-      "version": "1.0.0"
-    },
-    {
-      "hash": "QmWHgLqrghM9zw77nF6gdvT9ExQ2RB9pLxkd8sDHZf1rWb",
-      "name": "go-temp-err-catcher",
-      "version": "0.0.0"
-    },
-    {
-      "hash": "QmVXXxPsnDY16szK4gPy1oz4qKd8HHshemX1miZR2frtJo",
-      "name": "go-peerstream",
-      "version": "2.1.5"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmTy17Jm1foTnvUS9JXRhLbRQ3XuC64jPTjUfpB4mHz2QM",
-      "name": "mafmt",
-      "version": "1.2.5"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmTd4Jgb4nbJq5uR55KJgGLyHWmM3dovS21D1HcwRneSLu",
-      "name": "gorocheck",
-      "version": "0.0.0"
+      "version": "1.3.0"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmPDZJxtWGfcwLPazJxD4h3v3aDs43V7UNAVs3Jz1Wo7o4",
+      "hash": "QmRPkGkHLB72caXgdDYnoaWigXNWx95BcYDKV1n3KTEpaG",
       "name": "go-libp2p-loggables",
-      "version": "1.1.14"
+      "version": "1.1.18"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmP47neqyP4NR9CKbjVogZ8U9Gybxfcfsa8HtPSPSxwiA8",
+      "hash": "QmXzYnwYnJiDDV9y4QmbmtSeVyJ1R8HAmGnrnY2D6G3YcV",
       "name": "go-libp2p-secio",
-      "version": "1.2.7"
+      "version": "2.0.4"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmdeiKhUy1TVGBaKxt7y1QmBDLBdisSrLJ1x58Eoj4PXUh",
+      "hash": "QmZR2XWVVBCtbgBWnQhWk2xcQfaR3W8faQPriAiaaj7rsr",
       "name": "go-libp2p-peerstore",
-      "version": "1.4.17"
+      "version": "1.4.22"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmPUHzTLPZFYqv8WqcBTuMFYTgeom4uHHEaxzk7bd5GYZB",
+      "hash": "QmW5LxJm2Yo3S7uVsfLM7NsJn2QnKbvZD7uYsZVYR7YViE",
       "name": "go-libp2p-transport",
-      "version": "2.2.14"
+      "version": "3.0.5"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmdxKHpkZCTV3C7xdE1iJdPfFm5LVvMPvirdFmKu1TimzY",
+      "hash": "QmSggepaKhRfgEDiz2B6eGaCTK3TqDHXzK6F6HfsU7KPXt",
       "name": "go-tcp-transport",
-      "version": "1.2.9"
+      "version": "2.0.5"
     },
     {
       "author": "whyrusleeping",
-      "hash": "Qmf2UAmRwDG4TvnkQpHZWPAzw7rpCYVhxmRXmYxXr5LD1g",
+      "hash": "QmSW4uNHbvQia8iZDXzbwjiyHQtnyo9aFqfQAMasj3TJ6Y",
       "name": "go-maddr-filter",
-      "version": "1.1.6"
+      "version": "1.1.9"
     },
     {
       "author": "whyrusleeping",
@@ -164,69 +102,51 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmTGSre9j1otFgsr1opCUQDXTPSM6BTZnMWwPeA5nYJM7w",
-      "name": "go-addr-util",
-      "version": "1.2.7"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmUJzxQQ2kzwQubsMqBTr1NGDpLfh7pGA2E1oaJULcKDPq",
+      "hash": "QmcW4FGAt24fdK1jBgWQn3yP4R9ZLyWQqjozv9QK7epRhL",
       "name": "go-testutil",
-      "version": "1.2.1"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmaHsbK8b39AzQWEwDsysCutdJXyfa3k9oFh1cr6dfMhHT",
-      "name": "go-libp2p-conn",
-      "version": "1.7.6"
+      "version": "1.2.5"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmXoz9o2PT3tEzf7hicegwex5UgVP54n3k82K7jrWFyN86",
+      "hash": "QmPjvxTpVH8qJyQDnxnsxF9kv9jezKD1kozz1hs3fCGsNh",
       "name": "go-libp2p-net",
-      "version": "2.0.7"
+      "version": "3.0.5"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmVvu4bS5QLfS19ePkp5Wgzn2ZUma5oXTT9BgDFyQLxUZF",
+      "hash": "QmcoBbyTiL9PFjo1GFixJwqQ8mZLJ36CribuqyKmS1okPu",
       "name": "go-libp2p-metrics",
-      "version": "2.0.6"
-    },
-    {
-      "author": "whyrusleeping",
-      "hash": "QmYDNqBAMWVMHKndYR35Sd8PfEVWBiDmpHYkuRJTunJDeJ",
-      "name": "go-libp2p-interface-conn",
-      "version": "0.4.13"
+      "version": "2.1.3"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmfZTdmunzKzAGJrSvXXQbQ5kLLUiEMX5vdwux7iXkdk7D",
+      "hash": "Qmb8T6YBBsjYsVGfrihQLfCJveczZnneSBqBKkYEBWDjge",
       "name": "go-libp2p-host",
-      "version": "2.1.7"
+      "version": "3.0.4"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmRqfgh56f8CrqpwH7D2s6t8zQRsvPoftT3sp5Y6SUhNA3",
+      "hash": "QmemVjhp1UuWPQqrWSvPcaqH3QJRMjMqNm4T2RULMkDDQe",
       "name": "go-libp2p-swarm",
-      "version": "2.1.7"
+      "version": "3.0.6"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmXtFH52dAPCq5i4iYjr1g8xVFVJD3fwKWWyNHjVB4sHRp",
+      "hash": "QmW25V77H8nb1ucUe8BDUbR3QXLNzTearBLYMW5DqDVWd5",
       "name": "go-libp2p-nat",
-      "version": "0.0.8"
+      "version": "0.8.5"
     },
     {
       "author": "whyrusleeping",
-      "hash": "Qmb6BsZf6Y3kxffXMNTubGPF1w1bkHtpvhfYbmnwP3NQyw",
+      "hash": "QmcxUtMB5sJrXR3znSvkrDd2ghvwGM8rLRqwJiPUdgQwat",
       "name": "go-libp2p-netutil",
-      "version": "0.3.11"
+      "version": "0.4.4"
     },
     {
       "author": "whyrusleeping",
-      "hash": "Qmc64U41EEB4nPG7wxjEqFwKJajS2f8kk5q2TvUrQf78Xu",
+      "hash": "QmT1Q44YeQXSiK3LBXbXBRdxJAFZZSTarseqt7DVe9ASNA",
       "name": "go-libp2p-blankhost",
-      "version": "0.2.7"
+      "version": "0.3.4"
     },
     {
       "author": "whyrusleeping",
@@ -236,9 +156,9 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmNWCEvi7bPRcvqAV8AKLGVNoQdArWi7NJayka2SM4XtRe",
+      "hash": "QmcsgrV3nCAKjiHKZhKVXWc4oY3WBECJCqahXEMpHeMrev",
       "name": "go-smux-yamux",
-      "version": "2.0.1"
+      "version": "2.0.3"
     },
     {
       "author": "whyrusleeping",
@@ -248,39 +168,39 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmVniQJkdzLZaZwzwMdd3dJTvWiJ1DQEkreVy6hs6h7Vk5",
+      "hash": "QmWzjXAyBTygw6CeCTUnhJzhFucfxY5FJivSoiGuiSbPjS",
       "name": "go-smux-multistream",
-      "version": "2.0.0"
+      "version": "2.0.1"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmcJukH2sAFjY3HdBKq35WDzWoL3UUu2gt9wdfqZTUyM74",
+      "hash": "QmdVrMn1LhB4ybb8hMVaMLXnA8XRSewMnK6YqXKXoTcRvN",
       "name": "go-libp2p-peer",
-      "version": "2.3.2"
+      "version": "2.3.5"
     },
     {
       "author": "vyzo",
-      "hash": "QmZRbCo2gw7ghw5m7L77a8FvvQTVr62J4hmy8ozpdq7dHF",
+      "hash": "QmcQ56iqKP8ZRhRGLe5EReJVvrJZDaGzkuatrPv4Z1B6cG",
       "name": "go-libp2p-circuit",
-      "version": "2.0.12"
+      "version": "2.1.6"
     },
     {
       "author": "lgierth",
-      "hash": "QmQMRYmPn77CKRFf4YFjX3M5e6uw6DFAgsQffCX6mwZ4mA",
+      "hash": "QmfXU2MhWoegxHoeMd3A2ytL2P6CY4FfqGWc23LTNWBwZt",
       "name": "go-multiaddr-dns",
-      "version": "0.2.2"
+      "version": "0.2.4"
     },
     {
       "author": "why",
-      "hash": "QmfQNieWBPwmnUjXWPZbjJPzhNwFFabTb5RQ79dyVWGujQ",
+      "hash": "QmXuucFcuvAWYAJfhHV2h4BYreHEAsLSsiquosiXeuduTN",
       "name": "go-libp2p-interface-connmgr",
-      "version": "0.0.8"
+      "version": "0.0.11"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmenmFuirGzv8S1R3DyvbZ6tFmQapkGeDCebgYzni1Ntn3",
+      "hash": "QmZHiqdRuNXujvSPNu1ZWxxzV6a2WhoZpfYkesdgyaKF9f",
       "name": "go-smux-multiplex",
-      "version": "3.0.6"
+      "version": "3.0.11"
     },
     {
       "author": "multiformats",
@@ -289,10 +209,46 @@
       "version": "0.1.5"
     },
     {
-      "author": "satori",
-      "hash": "QmcBWojPoNh4qm7zvv4qiepvCnnc7ALS9qcp7TNwwxT1gT",
-      "name": "go.uuid",
-      "version": "1.1.0"
+      "author": "whyrusleeping",
+      "hash": "QmX4UrmHGPnFxwfsunZjPbykzyv8Frg9AVmNariXqrLsMs",
+      "name": "go-ws-transport",
+      "version": "2.0.5"
+    },
+    {
+      "author": "stebalien",
+      "hash": "QmZaZ4nkadScQtG7KaGUWyh24jz5tD8d6AyetJmGnMo49t",
+      "name": "go-conn-security-multistream",
+      "version": "0.1.4"
+    },
+    {
+      "author": "Stebalien",
+      "hash": "QmYMGCwtKbLXfh2MUTbLoP66N9Y24DSg8PFJRG21eE2qwv",
+      "name": "go-conn-security",
+      "version": "0.1.5"
+    },
+    {
+      "author": "libp2p",
+      "hash": "QmW7Ump7YyBMr712Ta3iEVh3ZYcfVvJaPryfbCnyE826b4",
+      "name": "go-libp2p-interface-pnet",
+      "version": "3.0.0"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmY9JXR3FupnYAYJWK9aMr9bCpqWKcToQ1tz8DVGTrHpHw",
+      "name": "go-stream-muxer",
+      "version": "3.0.0"
+    },
+    {
+      "author": "steb",
+      "hash": "Qma7AuxEA7dd1wAy95hTxXgxy4q7mU4Pyd1x4PRAzGP1fs",
+      "name": "go-libp2p-transport-upgrader",
+      "version": "0.1.5"
+    },
+    {
+      "author": "google",
+      "hash": "QmSSeQqc5QeuefkaM6JFV5tSF9knLUkXKVhW1eYRiqe72W",
+      "name": "uuid",
+      "version": "0.1.0"
     }
   ],
   "gxVersion": "0.4.0",
@@ -300,6 +256,6 @@
   "license": "MIT",
   "name": "go-libp2p",
   "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
-  "version": "5.0.17"
+  "version": "6.0.6"
 }