diff --git a/examples/hosts/main.go b/examples/hosts/main.go
index 0732e34ca74a4aee939893ac68139fde8ae814cf..8625df633c5d260a9ec24d1e2d06fe0e777c29c9 100644
--- a/examples/hosts/main.go
+++ b/examples/hosts/main.go
@@ -8,9 +8,9 @@ import (
 	"log"
 	"strings"
 
+	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
 	net "github.com/libp2p/go-libp2p-net"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
 	swarm "github.com/libp2p/go-libp2p/p2p/net/swarm"
 
diff --git a/p2p/discovery/mdns.go b/p2p/discovery/mdns.go
index 77e503f1fdb77b64b0b701224179f3e757a2b89e..1d616073e3768baff2a78118ec2f78cfd031e584 100644
--- a/p2p/discovery/mdns.go
+++ b/p2p/discovery/mdns.go
@@ -15,7 +15,7 @@ import (
 	logging "github.com/ipfs/go-log"
 	ma "github.com/jbenet/go-multiaddr"
 	manet "github.com/jbenet/go-multiaddr-net"
-	"github.com/libp2p/go-libp2p/p2p/host"
+	"github.com/libp2p/go-libp2p-host"
 	"github.com/whyrusleeping/mdns"
 )
 
diff --git a/p2p/discovery/mdns_test.go b/p2p/discovery/mdns_test.go
index f0282facffa263d8be1c0922fc9d5621e28e8aea..a1d26ef91126f8d67cb46c21757bb9ba8a31f7e0 100644
--- a/p2p/discovery/mdns_test.go
+++ b/p2p/discovery/mdns_test.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
+	host "github.com/libp2p/go-libp2p-host"
 	netutil "github.com/libp2p/go-libp2p/p2p/test/util"
 
 	pstore "github.com/ipfs/go-libp2p-peerstore"
diff --git a/p2p/host/basic/basic_host_test.go b/p2p/host/basic/basic_host_test.go
index a562139da1351794fb4cd550c15a7cd79a1fe067..da12989f00e95ad36c6ebbb2a194145922f44da7 100644
--- a/p2p/host/basic/basic_host_test.go
+++ b/p2p/host/basic/basic_host_test.go
@@ -7,9 +7,9 @@ import (
 	"testing"
 	"time"
 
+	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
 	protocol "github.com/libp2p/go-libp2p-protocol"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	testutil "github.com/libp2p/go-libp2p/p2p/test/util"
 )
 
diff --git a/p2p/host/host.go b/p2p/host/host.go
deleted file mode 100644
index 89d2db874c8c226748e88adc8a3217bb0b082b73..0000000000000000000000000000000000000000
--- a/p2p/host/host.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package host
-
-import (
-	"context"
-
-	peer "github.com/ipfs/go-libp2p-peer"
-	pstore "github.com/ipfs/go-libp2p-peerstore"
-	logging "github.com/ipfs/go-log"
-	ma "github.com/jbenet/go-multiaddr"
-	metrics "github.com/libp2p/go-libp2p-metrics"
-	inet "github.com/libp2p/go-libp2p-net"
-	protocol "github.com/libp2p/go-libp2p-protocol"
-	msmux "github.com/whyrusleeping/go-multistream"
-)
-
-var log = logging.Logger("github.com/libp2p/go-libp2p/p2p/host")
-
-// Host is an object participating in a p2p network, which
-// implements protocols or provides services. It handles
-// requests like a Server, and issues requests like a Client.
-// It is called Host because it is both Server and Client (and Peer
-// may be confusing).
-type Host interface {
-	// ID returns the (local) peer.ID associated with this Host
-	ID() peer.ID
-
-	// Peerstore returns the Host's repository of Peer Addresses and Keys.
-	Peerstore() pstore.Peerstore
-
-	// Returns the listen addresses of the Host
-	Addrs() []ma.Multiaddr
-
-	// Networks returns the Network interface of the Host
-	Network() inet.Network
-
-	// Mux returns the Mux multiplexing incoming streams to protocol handlers
-	Mux() *msmux.MultistreamMuxer
-
-	// Connect ensures there is a connection between this host and the peer with
-	// given peer.ID. Connect will absorb the addresses in pi into its internal
-	// peerstore. If there is not an active connection, Connect will issue a
-	// h.Network.Dial, and block until a connection is open, or an error is
-	// returned. // TODO: Relay + NAT.
-	Connect(ctx context.Context, pi pstore.PeerInfo) error
-
-	// SetStreamHandler sets the protocol handler on the Host's Mux.
-	// This is equivalent to:
-	//   host.Mux().SetHandler(proto, handler)
-	// (Threadsafe)
-	SetStreamHandler(pid protocol.ID, handler inet.StreamHandler)
-
-	// SetStreamHandlerMatch sets the protocol handler on the Host's Mux
-	// using a matching function for protocol selection.
-	SetStreamHandlerMatch(protocol.ID, func(string) bool, inet.StreamHandler)
-
-	// RemoveStreamHandler removes a handler on the mux that was set by
-	// SetStreamHandler
-	RemoveStreamHandler(pid protocol.ID)
-
-	// NewStream opens a new stream to given peer p, and writes a p2p/protocol
-	// header with given protocol.ID. If there is no connection to p, attempts
-	// to create one. If ProtocolID is "", writes no header.
-	// (Threadsafe)
-	NewStream(ctx context.Context, p peer.ID, pids ...protocol.ID) (inet.Stream, error)
-
-	// Close shuts down the host, its Network, and services.
-	Close() error
-
-	GetBandwidthReporter() metrics.Reporter
-}
diff --git a/p2p/host/match.go b/p2p/host/match.go
deleted file mode 100644
index 84b5def8f8be33c635263e832a4d252f7e480406..0000000000000000000000000000000000000000
--- a/p2p/host/match.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package host
-
-import (
-	"github.com/libp2p/go-libp2p-protocol"
-	"strings"
-
-	semver "github.com/coreos/go-semver/semver"
-)
-
-func MultistreamSemverMatcher(base protocol.ID) (func(string) bool, error) {
-	parts := strings.Split(string(base), "/")
-	vers, err := semver.NewVersion(parts[len(parts)-1])
-	if err != nil {
-		return nil, err
-	}
-
-	return func(check string) bool {
-		chparts := strings.Split(check, "/")
-		if len(chparts) != len(parts) {
-			return false
-		}
-
-		for i, v := range chparts[:len(chparts)-1] {
-			if parts[i] != v {
-				return false
-			}
-		}
-
-		chvers, err := semver.NewVersion(chparts[len(chparts)-1])
-		if err != nil {
-			return false
-		}
-
-		return vers.Major == chvers.Major && vers.Minor >= chvers.Minor
-	}, nil
-}
diff --git a/p2p/host/match_test.go b/p2p/host/match_test.go
deleted file mode 100644
index 14bb9553862d4c48297068dc87e247d03fc6e26d..0000000000000000000000000000000000000000
--- a/p2p/host/match_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package host
-
-import (
-	"testing"
-)
-
-func TestSemverMatching(t *testing.T) {
-	m, err := MultistreamSemverMatcher("/testing/4.3.5")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cases := map[string]bool{
-		"/testing/4.3.0":   true,
-		"/testing/4.3.7":   true,
-		"/testing/4.3.5":   true,
-		"/testing/4.2.7":   true,
-		"/testing/4.0.0":   true,
-		"/testing/5.0.0":   false,
-		"/cars/dogs/4.3.5": false,
-		"/foo/1.0.0":       false,
-		"":                 false,
-		"dogs":             false,
-		"/foo":             false,
-		"/foo/1.1.1.1":     false,
-	}
-
-	for p, ok := range cases {
-		if m(p) != ok {
-			t.Fatalf("expected %s to be %t", p, ok)
-		}
-	}
-}
diff --git a/p2p/host/routed/routed.go b/p2p/host/routed/routed.go
index 13552149c19a524d74209f2648548794b4a9c884..a9ba767b1493e260d825a782b6b1e75e6ee5a25d 100644
--- a/p2p/host/routed/routed.go
+++ b/p2p/host/routed/routed.go
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
+	host "github.com/libp2p/go-libp2p-host"
 
 	lgbl "github.com/ipfs/go-libp2p-loggables"
 	peer "github.com/ipfs/go-libp2p-peer"
diff --git a/p2p/net/mock/interface.go b/p2p/net/mock/interface.go
index c6018a2b62c2278173d6f2335c720b4fa6e63ed3..9e5a7bd4f70f5f406c8aa4b45e0c4e2ba8dbc2fa 100644
--- a/p2p/net/mock/interface.go
+++ b/p2p/net/mock/interface.go
@@ -10,7 +10,7 @@ import (
 	"io"
 	"time"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
+	host "github.com/libp2p/go-libp2p-host"
 
 	ic "github.com/ipfs/go-libp2p-crypto"
 	peer "github.com/ipfs/go-libp2p-peer"
diff --git a/p2p/net/mock/mock_net.go b/p2p/net/mock/mock_net.go
index f15b00a89c5c8c10aec0537efce28443d8247ca8..6d0fdcbd06d2f1d024a4e8f09c9e3e07ea19e515 100644
--- a/p2p/net/mock/mock_net.go
+++ b/p2p/net/mock/mock_net.go
@@ -6,7 +6,7 @@ import (
 	"sort"
 	"sync"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
+	host "github.com/libp2p/go-libp2p-host"
 	bhost "github.com/libp2p/go-libp2p/p2p/host/basic"
 	p2putil "github.com/libp2p/go-libp2p/p2p/test/util"
 
diff --git a/p2p/net/swarm/limiter.go b/p2p/net/swarm/limiter.go
index 5c8d235b8ef1b87fc169803749eb1bf867194ac8..bf4bcf0f5c180344439c7936f4b3e3a0e4c58564 100644
--- a/p2p/net/swarm/limiter.go
+++ b/p2p/net/swarm/limiter.go
@@ -7,11 +7,11 @@ import (
 	peer "github.com/ipfs/go-libp2p-peer"
 	ma "github.com/jbenet/go-multiaddr"
 	addrutil "github.com/libp2p/go-addr-util"
-	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
 )
 
 type dialResult struct {
-	Conn conn.Conn
+	Conn iconn.Conn
 	Err  error
 }
 
@@ -38,14 +38,14 @@ type dialLimiter struct {
 	fdLimit     int
 	waitingOnFd []*dialJob
 
-	dialFunc func(context.Context, peer.ID, ma.Multiaddr) (conn.Conn, error)
+	dialFunc func(context.Context, peer.ID, ma.Multiaddr) (iconn.Conn, error)
 
 	activePerPeer      map[peer.ID]int
 	perPeerLimit       int
 	waitingOnPeerLimit map[peer.ID][]*dialJob
 }
 
-type dialfunc func(context.Context, peer.ID, ma.Multiaddr) (conn.Conn, error)
+type dialfunc func(context.Context, peer.ID, ma.Multiaddr) (iconn.Conn, error)
 
 func newDialLimiter(df dialfunc) *dialLimiter {
 	return newDialLimiterWithParams(df, concurrentFdDials, defaultPerPeerRateLimit)
diff --git a/p2p/net/swarm/limiter_test.go b/p2p/net/swarm/limiter_test.go
index 7332c0e06a6f8c9aa9dd417777a189aec8d52558..31ac8435df837da0d49ab22ac39b60a8e4d0dcb7 100644
--- a/p2p/net/swarm/limiter_test.go
+++ b/p2p/net/swarm/limiter_test.go
@@ -10,7 +10,7 @@ import (
 
 	peer "github.com/ipfs/go-libp2p-peer"
 	ma "github.com/jbenet/go-multiaddr"
-	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
 	mafmt "github.com/whyrusleeping/mafmt"
 )
 
@@ -55,13 +55,13 @@ func tryDialAddrs(ctx context.Context, l *dialLimiter, p peer.ID, addrs []ma.Mul
 }
 
 func hangDialFunc(hang chan struct{}) dialfunc {
-	return func(ctx context.Context, p peer.ID, a ma.Multiaddr) (conn.Conn, error) {
+	return func(ctx context.Context, p peer.ID, a ma.Multiaddr) (iconn.Conn, error) {
 		if mafmt.UTP.Matches(a) {
-			return conn.Conn(nil), nil
+			return iconn.Conn(nil), nil
 		}
 
 		if tcpPortOver(a, 10) {
-			return conn.Conn(nil), nil
+			return iconn.Conn(nil), nil
 		}
 
 		<-hang
@@ -171,9 +171,9 @@ func TestFDLimiting(t *testing.T) {
 
 func TestTokenRedistribution(t *testing.T) {
 	hangchs := make(map[peer.ID]chan struct{})
-	df := func(ctx context.Context, p peer.ID, a ma.Multiaddr) (conn.Conn, error) {
+	df := func(ctx context.Context, p peer.ID, a ma.Multiaddr) (iconn.Conn, error) {
 		if tcpPortOver(a, 10) {
-			return (conn.Conn)(nil), nil
+			return (iconn.Conn)(nil), nil
 		}
 
 		<-hangchs[p]
@@ -260,9 +260,9 @@ func TestTokenRedistribution(t *testing.T) {
 }
 
 func TestStressLimiter(t *testing.T) {
-	df := func(ctx context.Context, p peer.ID, a ma.Multiaddr) (conn.Conn, error) {
+	df := func(ctx context.Context, p peer.ID, a ma.Multiaddr) (iconn.Conn, error) {
 		if tcpPortOver(a, 1000) {
-			return conn.Conn(nil), nil
+			return iconn.Conn(nil), nil
 		}
 
 		time.Sleep(time.Millisecond * time.Duration(5+rand.Intn(100)))
diff --git a/p2p/net/swarm/swarm_addr.go b/p2p/net/swarm/swarm_addr.go
index 87b0829da15df9759c18b3156af54ed7742706fa..0ab2c7ea1c552d473691561c09940e60a31bd06c 100644
--- a/p2p/net/swarm/swarm_addr.go
+++ b/p2p/net/swarm/swarm_addr.go
@@ -3,7 +3,7 @@ package swarm
 import (
 	ma "github.com/jbenet/go-multiaddr"
 	addrutil "github.com/libp2p/go-addr-util"
-	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
 )
 
 // ListenAddresses returns a list of addresses at which this swarm listens.
@@ -11,7 +11,7 @@ func (s *Swarm) ListenAddresses() []ma.Multiaddr {
 	listeners := s.swarm.Listeners()
 	addrs := make([]ma.Multiaddr, 0, len(listeners))
 	for _, l := range listeners {
-		if l2, ok := l.NetListener().(conn.Listener); ok {
+		if l2, ok := l.NetListener().(iconn.Listener); ok {
 			addrs = append(addrs, l2.Multiaddr())
 		}
 	}
diff --git a/p2p/net/swarm/swarm_conn.go b/p2p/net/swarm/swarm_conn.go
index 42fc8905dac4a77c24c23088b8670280a2ac350b..8128a3e6abbf96a2a965bf07c70852f62d4bd120 100644
--- a/p2p/net/swarm/swarm_conn.go
+++ b/p2p/net/swarm/swarm_conn.go
@@ -4,13 +4,12 @@ import (
 	"context"
 	"fmt"
 
-	inet "github.com/libp2p/go-libp2p-net"
-
 	ic "github.com/ipfs/go-libp2p-crypto"
 	peer "github.com/ipfs/go-libp2p-peer"
 	ma "github.com/jbenet/go-multiaddr"
 	ps "github.com/jbenet/go-peerstream"
-	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
+	inet "github.com/libp2p/go-libp2p-net"
 )
 
 // Conn is a simple wrapper around a ps.Conn that also exposes
@@ -33,12 +32,12 @@ func (c *Conn) StreamConn() *ps.Conn {
 	return (*ps.Conn)(c)
 }
 
-func (c *Conn) RawConn() conn.Conn {
+func (c *Conn) RawConn() iconn.Conn {
 	// righly panic if these things aren't true. it is an expected
 	// invariant that these Conns are all of the typewe expect:
 	// 		ps.Conn wrapping a conn.Conn
 	// if we get something else it is programmer error.
-	return (*ps.Conn)(c).NetConn().(conn.Conn)
+	return (*ps.Conn)(c).NetConn().(iconn.Conn)
 }
 
 func (c *Conn) String() string {
@@ -94,7 +93,7 @@ func (c *Conn) Close() error {
 
 func wrapConn(psc *ps.Conn) (*Conn, error) {
 	// grab the underlying connection.
-	if _, ok := psc.NetConn().(conn.Conn); !ok {
+	if _, ok := psc.NetConn().(iconn.Conn); !ok {
 		// this should never happen. if we see it ocurring it means that we added
 		// a Listener to the ps.Swarm that is NOT one of our net/conn.Listener.
 		return nil, fmt.Errorf("swarm connHandler: invalid conn (not a conn.Conn): %s", psc)
diff --git a/p2p/net/swarm/swarm_dial.go b/p2p/net/swarm/swarm_dial.go
index 29694df73b2aa13c241d7665776526587b093b37..bfe9f0382e5b15d7a620d4fb6a18d775797930fa 100644
--- a/p2p/net/swarm/swarm_dial.go
+++ b/p2p/net/swarm/swarm_dial.go
@@ -11,7 +11,7 @@ import (
 	peer "github.com/ipfs/go-libp2p-peer"
 	ma "github.com/jbenet/go-multiaddr"
 	addrutil "github.com/libp2p/go-addr-util"
-	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
 )
 
 // Diagram of dial sync:
@@ -284,7 +284,7 @@ func (s *Swarm) dial(ctx context.Context, p peer.ID) (*Conn, error) {
 	return swarmC, nil
 }
 
-func (s *Swarm) dialAddrs(ctx context.Context, p peer.ID, remoteAddrs <-chan ma.Multiaddr) (conn.Conn, error) {
+func (s *Swarm) dialAddrs(ctx context.Context, p peer.ID, remoteAddrs <-chan ma.Multiaddr) (iconn.Conn, error) {
 	log.Debugf("%s swarm dialing %s %s", s.local, p, remoteAddrs)
 
 	ctx, cancel := context.WithCancel(ctx)
@@ -344,7 +344,7 @@ func (s *Swarm) limitedDial(ctx context.Context, p peer.ID, a ma.Multiaddr, resp
 	})
 }
 
-func (s *Swarm) dialAddr(ctx context.Context, p peer.ID, addr ma.Multiaddr) (conn.Conn, error) {
+func (s *Swarm) dialAddr(ctx context.Context, p peer.ID, addr ma.Multiaddr) (iconn.Conn, error) {
 	log.Debugf("%s swarm dialing %s %s", s.local, p, addr)
 
 	connC, err := s.dialer.Dial(ctx, addr, p)
@@ -376,7 +376,7 @@ var ConnSetupTimeout = time.Minute * 5
 
 // dialConnSetup is the setup logic for a connection from the dial side. it
 // needs to add the Conn to the StreamSwarm, then run newConnSetup
-func dialConnSetup(ctx context.Context, s *Swarm, connC conn.Conn) (*Conn, error) {
+func dialConnSetup(ctx context.Context, s *Swarm, connC iconn.Conn) (*Conn, error) {
 
 	deadline, ok := ctx.Deadline()
 	if !ok {
diff --git a/p2p/net/swarm/swarm_listen.go b/p2p/net/swarm/swarm_listen.go
index 0c9d8597356fdfd53acc35362beb15dee52b861d..756084abc7591deb1333e5391f260dee904d4d40 100644
--- a/p2p/net/swarm/swarm_listen.go
+++ b/p2p/net/swarm/swarm_listen.go
@@ -8,6 +8,7 @@ import (
 	ma "github.com/jbenet/go-multiaddr"
 	ps "github.com/jbenet/go-peerstream"
 	conn "github.com/libp2p/go-libp2p-conn"
+	iconn "github.com/libp2p/go-libp2p-interface-conn"
 	mconn "github.com/libp2p/go-libp2p-metrics/conn"
 	inet "github.com/libp2p/go-libp2p-net"
 	transport "github.com/libp2p/go-libp2p-transport"
@@ -98,7 +99,7 @@ func (s *Swarm) addListener(tptlist transport.Listener) error {
 	return s.addConnListener(list)
 }
 
-func (s *Swarm) addConnListener(list conn.Listener) error {
+func (s *Swarm) addConnListener(list iconn.Listener) error {
 	// AddListener to the peerstream Listener. this will begin accepting connections
 	// and streams!
 	sl, err := s.swarm.AddListener(list)
diff --git a/p2p/protocol/identify/id.go b/p2p/protocol/identify/id.go
index 15042f5938582e714ac88cb4251133cb643e187d..0324248f6ed6590bea89e8141f6a3383b59a81d3 100644
--- a/p2p/protocol/identify/id.go
+++ b/p2p/protocol/identify/id.go
@@ -5,7 +5,6 @@ import (
 	"strings"
 	"sync"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	pb "github.com/libp2p/go-libp2p/p2p/protocol/identify/pb"
 
 	semver "github.com/coreos/go-semver/semver"
@@ -16,6 +15,7 @@ import (
 	pstore "github.com/ipfs/go-libp2p-peerstore"
 	logging "github.com/ipfs/go-log"
 	ma "github.com/jbenet/go-multiaddr"
+	host "github.com/libp2p/go-libp2p-host"
 	mstream "github.com/libp2p/go-libp2p-metrics/stream"
 	inet "github.com/libp2p/go-libp2p-net"
 	msmux "github.com/whyrusleeping/go-multistream"
diff --git a/p2p/protocol/identify/id_test.go b/p2p/protocol/identify/id_test.go
index e591857414ef1f05d0d3bc8d8275af29bfc52d7c..bc0c90f99d449944a0d199115ef8dee3c5ccbdd7 100644
--- a/p2p/protocol/identify/id_test.go
+++ b/p2p/protocol/identify/id_test.go
@@ -1,17 +1,17 @@
 package identify_test
 
 import (
+	"context"
 	"testing"
 	"time"
 
 	ic "github.com/ipfs/go-libp2p-crypto"
 	peer "github.com/ipfs/go-libp2p-peer"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	identify "github.com/libp2p/go-libp2p/p2p/protocol/identify"
 	testutil "github.com/libp2p/go-libp2p/p2p/test/util"
 
-	"context"
 	ma "github.com/jbenet/go-multiaddr"
+	host "github.com/libp2p/go-libp2p-host"
 )
 
 func subtestIDService(t *testing.T, postDialWait time.Duration) {
diff --git a/p2p/protocol/ping/ping.go b/p2p/protocol/ping/ping.go
index 2c9982e4d197ab42a91e5219790f229872e80470..ace786ee2983e90f542342eadc9f4d552b2ce1ab 100644
--- a/p2p/protocol/ping/ping.go
+++ b/p2p/protocol/ping/ping.go
@@ -10,8 +10,8 @@ import (
 	u "github.com/ipfs/go-ipfs-util"
 	peer "github.com/ipfs/go-libp2p-peer"
 	logging "github.com/ipfs/go-log"
+	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 )
 
 var log = logging.Logger("ping")
diff --git a/p2p/protocol/relay/relay.go b/p2p/protocol/relay/relay.go
index 85006b2a501cb07a22cf6ab739900562a13ef362..cef8d835fe5d24e40b30f6f91f1eec8a70e0eb2f 100644
--- a/p2p/protocol/relay/relay.go
+++ b/p2p/protocol/relay/relay.go
@@ -6,7 +6,7 @@ import (
 	"io"
 	"time"
 
-	host "github.com/libp2p/go-libp2p/p2p/host"
+	host "github.com/libp2p/go-libp2p-host"
 
 	peer "github.com/ipfs/go-libp2p-peer"
 	logging "github.com/ipfs/go-log"
diff --git a/p2p/test/backpressure/backpressure_test.go b/p2p/test/backpressure/backpressure_test.go
index 25cda403bed4ca0e16d92a0bf67d547f4b45e742..9bbb22b197004c9bd2d409a1318967ea768656f2 100644
--- a/p2p/test/backpressure/backpressure_test.go
+++ b/p2p/test/backpressure/backpressure_test.go
@@ -10,9 +10,9 @@ import (
 	u "github.com/ipfs/go-ipfs-util"
 	peer "github.com/ipfs/go-libp2p-peer"
 	logging "github.com/ipfs/go-log"
+	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
 	protocol "github.com/libp2p/go-libp2p-protocol"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	testutil "github.com/libp2p/go-libp2p/p2p/test/util"
 )
 
diff --git a/p2p/test/reconnects/reconnect_test.go b/p2p/test/reconnects/reconnect_test.go
index 7675c4d7a60f04b1cc7c85a9071aa7727604d36a..e3249f57b197cec2ff0eb6c58aa1b15c921365e6 100644
--- a/p2p/test/reconnects/reconnect_test.go
+++ b/p2p/test/reconnects/reconnect_test.go
@@ -11,9 +11,9 @@ import (
 	u "github.com/ipfs/go-ipfs-util"
 	logging "github.com/ipfs/go-log"
 	ps "github.com/jbenet/go-peerstream"
+	host "github.com/libp2p/go-libp2p-host"
 	inet "github.com/libp2p/go-libp2p-net"
 	protocol "github.com/libp2p/go-libp2p-protocol"
-	host "github.com/libp2p/go-libp2p/p2p/host"
 	swarm "github.com/libp2p/go-libp2p/p2p/net/swarm"
 	testutil "github.com/libp2p/go-libp2p/p2p/test/util"
 )
diff --git a/package.json b/package.json
index dd25227604257d25808a3ce3e74d653b639d30dd..6e28ab500c23f6a45228a3073e4027c7d1f4447f 100644
--- a/package.json
+++ b/package.json
@@ -215,20 +215,32 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmTaW4q1AbqMkpfDLUYzW18nW62GsrnFvtVcvR1pnaURm6",
+      "hash": "Qmd4eGc7VMmVZu225mdCzsagdWJBaAVHmmvNFYSvxSUeX5",
       "name": "go-libp2p-conn",
-      "version": "1.0.0"
+      "version": "1.1.0"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmSctCnUNkE7c7C2LGRGYrdmU9SDH3MtbAeueN7Jq1NN2q",
+      "hash": "Qmcr6YS5QCPwejhBxZk5iFEvVEHSVzewbLVMyc64zefaUf",
       "name": "go-libp2p-net",
       "version": "1.0.0"
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmS38TTyj47fP5NVNznxpw4KpFYSU9zHkCEfmuBSkHzb6d",
+      "hash": "QmbidKjoAxLVE2skY74Rfw1QafReyf4w2FZqA8Sd7MxoVd",
       "name": "go-libp2p-metrics",
+      "version": "1.1.0"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmRxzoGdQaN6HYyqWnT82NnLLHBAZbTUvxPEfTBTjU7KCn",
+      "name": "go-libp2p-interface-conn",
+      "version": "0.1.0"
+    },
+    {
+      "author": "whyrusleeping",
+      "hash": "QmaAyA9QMVdzCYHv7QJnKu4Dzk4zfnFrHw9itzP9kEUKYW",
+      "name": "go-libp2p-host",
       "version": "1.0.0"
     }
   ],