chore: release version v0.10.0

chore: update contributors
chore: update deps
2025-07-08 13:21:34 +00:00 · 2017-07-07 13:27:04 +01:00 · 2017-07-07 13:27:04 +01:00 · 2017-07-07 13:25:34 +01:00 · 2017-07-07 12:56:46 +01:00 · 2017-07-05 18:18:31 +01:00
53 changed files with 3270 additions and 58 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,6 +1,7 @@
 # Logs
 logs
 *.log
+npm-debug.log*

 # Runtime data
 pids
@ -23,5 +24,12 @@ coverage
 build/Release

 # Dependency directory
-# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+dist
--- a/.npmignore
+++ b/.npmignore
@ -0,0 +1,28 @@
+# Logs
+logs
+*.log
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+
+test
--- a/.travis.yml
+++ b/.travis.yml
@ -1,13 +1,36 @@
+sudo: false
 language: node_js
-node_js:
-  - "iojs"
-
-branches:
-  only:
-    - master
+matrix:
+  include:
+  - node_js: 4
+    env: CXX=g++-4.8
+  - node_js: 6
+    env:
+      - SAUCE=true
+      - CXX=g++-4.8
+  - node_js: stable
+    env: CXX=g++-4.8

+# Make sure we have new NPM.
 before_install:
-  - npm i -g npm
-  # Workaround for a permissions issue with Travis virtual machine images
+  - npm install -g npm
+
 script:
+  - npm run lint
  - npm test
+  - npm run coverage
+
+before_script:
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+
+after_success:
+  - npm run coverage-publish
+
+addons:
+  firefox: 'latest'
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,88 @@
+<a name="0.10.0"></a>
+# [0.10.0](https://github.com/libp2p/js-libp2p/compare/v0.9.1...v0.10.0) (2017-07-07)
+
+
+### Bug Fixes
+
+* added missing dep async ([45b0f61](https://github.com/libp2p/js-libp2p/commit/45b0f61))
+
+
+### Features
+
+* state events and query changes ([#100](https://github.com/libp2p/js-libp2p/issues/100)) ([73f2f6d](https://github.com/libp2p/js-libp2p/commit/73f2f6d))
+
+
+
+<a name="0.9.1"></a>
+## [0.9.1](https://github.com/libp2p/js-libp2p/compare/v0.9.0...v0.9.1) (2017-04-16)
+
+
+### Bug Fixes
+
+* do not use assert in async funcs ([#88](https://github.com/libp2p/js-libp2p/issues/88)) ([2e326e1](https://github.com/libp2p/js-libp2p/commit/2e326e1))
+
+
+
+<a name="0.9.0"></a>
+# [0.9.0](https://github.com/libp2p/js-libp2p/compare/v0.8.0...v0.9.0) (2017-04-06)
+
+
+
+<a name="0.8.0"></a>
+# [0.8.0](https://github.com/libp2p/js-libp2p/compare/v0.7.0...v0.8.0) (2017-03-31)
+
+
+### Bug Fixes
+
+* addition of ipfs id appendix must come before transport filtering ([291e79f](https://github.com/libp2p/js-libp2p/commit/291e79f))
+* avoid deleting nodes from peerBook ([300936f](https://github.com/libp2p/js-libp2p/commit/300936f))
+* correct method on peer-book ([031ecb3](https://github.com/libp2p/js-libp2p/commit/031ecb3))
+
+
+### Features
+
+* append peer id to multiaddr if not there ([59ea9c3](https://github.com/libp2p/js-libp2p/commit/59ea9c3))
+* not remove peer from peerBook on disconnect ([a4b41b0](https://github.com/libp2p/js-libp2p/commit/a4b41b0))
+
+
+
+<a name="0.7.0"></a>
+# [0.7.0](https://github.com/libp2p/js-libp2p/compare/v0.6.2...v0.7.0) (2017-03-29)
+
+
+### Features
+
+* update events to conform with [#74](https://github.com/libp2p/js-libp2p/issues/74) ([f73c045](https://github.com/libp2p/js-libp2p/commit/f73c045))
+
+
+
+<a name="0.6.2"></a>
+## [0.6.2](https://github.com/libp2p/js-libp2p/compare/v0.6.1...v0.6.2) (2017-03-28)
+
+
+
+<a name="0.6.1"></a>
+## [0.6.1](https://github.com/libp2p/js-libp2p/compare/v0.6.0...v0.6.1) (2017-03-27)
+
+
+
+<a name="0.6.0"></a>
+# [0.6.0](https://github.com/libp2p/js-libp2p/compare/v0.5.5...v0.6.0) (2017-03-27)
+
+
+### Bug Fixes
+
+* last touches ([2c23d9a](https://github.com/libp2p/js-libp2p/commit/2c23d9a))
+
+
+### Features
+
+* new super simplified API ([a6623c1](https://github.com/libp2p/js-libp2p/commit/a6623c1))
+
+
+
+<a name="0.5.5"></a>
+## [0.5.5](https://github.com/libp2p/js-libp2p/compare/v0.5.4...v0.5.5) (2017-03-21)
+
+
+
--- a/README.md
+++ b/README.md
@ -1,48 +1,307 @@
-js-libp2p
-=========
+<h1 align="center">
+  <a href="libp2p.io"><img width="250" src="https://github.com/libp2p/libp2p/blob/master/logo/alternates/libp2p-logo-alt-2.png?raw=true" alt="libp2p hex logo" /></a>
+</h1>

-[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io) [[![](https://img.shields.io/badge/freejs-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) ![Build Status](https://travis-ci.org/diasdavid/js-libp2p.svg?style=flat-square)](https://travis-ci.org/diasdavid/js-libp2p) ![](https://img.shields.io/badge/coverage-%3F-yellow.svg?style=flat-square) [![Dependency Status](https://david-dm.org/diasdavid/js-libp2p.svg?style=flat-square)](https://david-dm.org/diasdavid/js-libp2p) [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
+<h3 align="center">The JavaScript implementation of the libp2p Networking Stack.</h3>

-> Node.js implementation of libp2p
+<p align="center">
+  <a href="http://ipn.io"><img src="https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square" /></a>
+  <a href="http://libp2p.io/"><img src="https://img.shields.io/badge/project-libp2p-blue.svg?style=flat-square" /></a>
+  <a href="http://webchat.freenode.net/?channels=%23ipfs"><img src="https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square" /></a>
+  <a href="https://waffle.io/libp2p/libp2p"><img src="https://img.shields.io/badge/pm-waffle-blue.svg?style=flat-square" /></a>
+</p>

-## Interface
+<p align="center">
+  <a href="https://travis-ci.org/libp2p/js-libp2p"><img src="https://travis-ci.org/libp2p/js-libp2p.svg?branch=master" /></a>
+  <a href="https://circleci.com/gh/libp2p/js-libp2p"><img src="https://circleci.com/gh/libp2p/js-libp2p.svg?style=svg" /></a>
+  <a href="https://coveralls.io/github/libp2p/js-libp2p?branch=master"><img src="https://coveralls.io/repos/github/libp2p/js-libp2p/badge.svg?branch=master"></a>
+  <br>
+  <a href="https://david-dm.org/libp2p/js-libp2p"><img src="https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square" /></a>
+  <a href="https://github.com/feross/standard"><img src="https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square"></a>
+  <a href="https://github.com/RichardLitt/standard-readme"><img src="https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D3.0.0-orange.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D4.0.0-orange.svg?style=flat-square" /></a>
+  <br>
+</p>

-> **This is a work in progress, interface might change at anytime**
+## Table of Contents

-libp2p expects a [Record Store interface](https://github.com/diasdavid/abstract-record-store), a swarm and one or more Peer Routers that implement the [Peer Routing](https://github.com/diasdavid/abstract-peer-routing), the goal is to keep simplicity and plugability while the remaining modules execute the heavy lifting.
+- [Background](#background)
+- [Bundles](#bundles)
+- [Usage](#usage)
+  - [Install](#install)
+  - [API](#api)
+- [Development](#development)
+  - [Tests](#tests)
+  - [Packages](#packages)
+- [Contribute](#contribute)
+- [License](#license)

-libp2p becomes very simple and basically acts as a glue for every module that compose this library. Since it can be highly customized, it requires some setup. What we recommend is to have a libp2p build for the system you are developing taking into account in your needs (e.g. for a browser working version of libp2p that acts as the network layer of IPFS, we have a built and minified version that browsers can require)
+## Background

-### Setting everything up
+libp2p is the product of a long and arduous quest to understand the evolution of the Internet networking stack. In order to build P2P applications, dev have long had to made custom ad-hoc solutions to fit their needs, sometimes making some hard assumptions about their runtimes and the state of the network at the time of their development. Today, looking back more than 20 years, we see a clear pattern in the types of mechanisms built around the Internet Protocol, IP, which can be found throughout many layers of the OSI layer system, libp2p distils these mechanisms into flat categories and defines clear interfaces that once exposed, enable other protocols and applications to use and swap them, enabling upgradability and adaptability for the runtime, without breaking the API.

-```
-var Libp2p = require('libp2p')
+We are in the process of writting better documentation, blog posts, tutorials and a formal specification. Today you can find:

-// set up a Swarm, Peer Routing and Record Store instances, the last two are optional
+- [libp2p.io](https://libp2p.io)
+- [Specification (WIP)](https://github.com/libp2p/specs)
+- Talks
+  - [`libp2p <3 ethereum` at DEVCON2](https://ethereumfoundation.org/devcon/?session=libp2p) [video](https://www.youtube.com/watch?v=HxueJbeMVG4) [slides](https://ethereumfoundation.org/devcon/wp-content/uploads/2016/10/libp2p-HEART-devp2p-IPFS-PLUS-Ethereum-networking.pdf) [demo-1](https://ethereumfoundation.org/devcon/wp-content/uploads/2016/10/libp2p_demo1-1.mp4) [demo-2](https://ethereumfoundation.org/devcon/wp-content/uploads/2016/10/libp2p_demo2-1.mp4)
+- Articles
+  - [The overview of libp2p](https://github.com/libp2p/libp2p#description)

-var p2p = new Libp2p(swarm, [peerRouting, recordStore])
+To sum up, libp2p is a "network stack" -- a protocol suite -- that cleanly separates concerns, and enables sophisticated applications to only use the protocols they absolutely need, without giving up interoperability and upgradeability. libp2p grew out of IPFS, but it is built so that lots of people can use it, for lots of different projects.
+
+## Bundles
+
+With its modular nature, libp2p can be found being used in different projects with different sets of features, while preserving the same top level API. `js-libp2p` is only a skeleton and should not be installed directly, if you are looking for a prebundled libp2p stack, please check:
+
+- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/tree/master/src/core/runtime/libp2p-nodejs.js) - The libp2p build used by js-ipfs when run in Node.js
+- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/tree/master/src/core/runtime/libp2p-browser.js) - The libp2p build used by js-ipfs when run in a Browser (that supports WebRTC)
+
+If you have developed a libp2p bundle, please consider submitting it to this list so that it can be found easily by the users of libp2p.
+
+## Install
+
+Again, as noted above, this module is only a skeleton and should not be used directly other than libp2p bundle implementors that want to extend its code.
+
+```sh
+npm install --save libp2p
 ```

-### Dialing and listening
+## Usage

-p2p.swarm.dial(peerInfo, options, protocol, function (err, stream) {})
-p2p.swarm.handleProtocol(protocol, options, handlerFunction)
+### Extending libp2p skeleton

-### Using Peer Routing
+libp2p becomes very simple and basically acts as a glue for every module that compose this library. Since it can be highly customized, it requires some setup. What we recommend is to have a libp2p build for the system you are developing taking into account in your needs (e.g. for a browser working version of libp2p that acts as the network layer of IPFS, we have a built and minified version that browsers can require).

-p2p.routing.findPeers(key, function (err, peerInfos) {})
+**Example:**

-### Using Records
+```JavaScript
+// Creating a bundle that adds:
+//   transport: websockets + tcp
+//   stream-muxing: SPDY
+//   crypto-channel: secio
+//   discovery: multicast-dns

-p2p.record.get(key, function (err, records) {})
-p2p.record.store(key, record)
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const WS = require('libp2p-websockets')
+const spdy = require('libp2p-spdy')
+const secio = require('libp2p-secio')
+const MulticastDNS = require('libp2p-mdns')
+const DHT = require('libp2p-kad-dht')

-### Stats
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: [
+          spdy
+        ],
+        crypto: [
+          secio
+        ]
+      },
+      discovery: [
+        new MulticastDNS(peerInfo, 'your-identifier')
+      ],
+      // DHT is passed as its own enabling PeerRouting, ContentRouting and DHT itself components
+      dht: DHT
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+// Now all the nodes you create, will have TCP, WebSockets, SPDY, SECIO and MulticastDNS support.
+```
+
+### API
+
+#### Create a Node - `new libp2p.Node([peerInfo, peerBook, options])`
+
+> Creates an instance of the libp2p.Node.
+
+- `peerInfo`: instance of [PeerInfo][] that contains the [PeerId][], Keys and [multiaddrs][multiaddr] of the libp2p Node. Optional.
+- `peerBook`: instance of [PeerBook][] that contains the [PeerInfo][] of known peers. Optional.
+- `options`: Object containing custom options for the bundle.
+
+#### `libp2p.start(callback)`
+
+> Start the libp2p Node.
+
+`callback` is a function with the following `function (err) {}` signature, where `err` is an Error in case starting the node fails.
+
+#### `libp2p.stop(callback)`
+
+> Stop the libp2p Node.
+
+`callback` is a function with the following `function (err) {}` signature, where `err` is an Error in case stopping the node fails.
+
+#### `libp2p.dial(peer [, protocol, callback])`
+
+> Dials to another peer in the network.
+
+- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][]
+- `protocol`: String that defines the protocol (e.g '/ipfs/bitswap/1.1.0')
+
+`callback` is a function with the following `function (err, conn) {}` signature, where `err` is an Error in of failure to dial the connection and `conn` is a [Connection][] instance in case of a protocol selected, if not it is undefined.
+
+#### `libp2p.hangUp(peer, callback)
+
+> Closes an open connection with a peer, graciously.
+
+- `peer`: can be an instance of [PeerInfo][], [PeerId][] or [multiaddr][]
+
+`callback` is a function with the following `function (err) {}` signature, where `err` is an Error in case stopping the node fails.
+
+#### `libp2p.peerRouting.findPeer(id, callback)`
+
+> Looks up for multiaddrs of a peer in the DHT
+
+- `id`: instance of [PeerId][]
+
+#### `libp2p.contentRouting.findProviders(key, timeout, callback)`
+
+- `key`: Buffer
+- `timeout`: Number miliseconds
+
+#### `libp2p.contentRouting.provide(key, callback)`
+
+- `key`: Buffer
+
+#### `libp2p.dht.put(key, value, callback)`
+
+- `key`: Buffer
+- `value`: Buffer
+
+#### `libp2p.dht.get(key, callback)`
+
+- `key`: Buffer
+
+#### `libp2p.dht.getMany(key, nVals, callback)`
+
+- `key`: Buffer
+- `nVals`: Number
+
+#### `libp2p.handle(protocol, handlerFunc [, matchFunc])`
+
+> Handle new protocol
+
+- `protocol`: String that defines the protocol (e.g '/ipfs/bitswap/1.1.0')
+- `handlerFunc`: Function with signature `function (protocol, conn) {}`
+- `matchFunc`: Function for matching on protocol (exact matching, semver, etc). Default to exact match.
+
+#### `libp2p.unhandle(protocol)
+
+> Stop handling protocol
+
+- `protocol`: String that defines the protocol (e.g '/ipfs/bitswap/1.1.0')
+
+#### `libp2p.on('peer:discovery', (peer) => {})`
+
+> Peer has been discovered.
+
+- `peer`: instance of [PeerInfo][]
+
+#### `libp2p.on('peer:connect', (peer) => {})`
+
+> We connected to a new peer
+
+- `peer`: instance of [PeerInfo][]
+
+#### `libp2p.on('peer:disconnect', (peer) => {})`
+
+> We disconnected from Peer
+
+- `peer`: instance of [PeerInfo][]
+
+#### `libp2p.isOn()`
+
+> Check if libp2p is started
+
+#### `libp2p.ping(peer [, options], callback)`
+
+> Ping a node in the network
+
+#### `libp2p.peerBook`
+
+> PeerBook instance of the node
+
+#### `libp2p.peerInfo`
+
+> PeerInfo instance of the node
+
+---------------------
+
+`SOON™`
+
+#### `libp2p.findPeers`
+
+#### `libp2p.findProviders`
+
+#### `libp2p.record.put`
+
+#### `libp2p.record.get`
+
+[PeerInfo]: https://github.com/libp2p/js-peer-info
+[PeerId]: https://github.com/libp2p/js-peer-id
+[PeerBook]: https://github.com/libp2p/js-peer-book
+[multiaddr]: https://github.com/multiformats/js-multiaddr
+[Connection]: https://github.com/libp2p/interface-connection


+### Packages

-## Notes
+List of packages currently in existence for libp2p

-Img for ref (till we get a better graph)
+| Package | Version | Dependencies | DevDependencies |
+|---------|---------|--------------|-----------------|
+| **Transports**                                     |
+| [`libp2p-utp`](//github.com/libp2p/js-libp2p-utp) | [![npm](https://img.shields.io/npm/v/libp2p-utp.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-utp/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-utp.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-utp) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-utp/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-utp?type=dev) |
+| [`libp2p-websockets`](//github.com/libp2p/js-libp2p-websockets) | [![npm](https://img.shields.io/npm/v/libp2p-websockets.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-websockets/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-websockets.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websockets) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-websockets/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websockets?type=dev) |
+| [`libp2p-webrtc-star`](//github.com/libp2p/js-libp2p-webrtc-star) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-star/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-webrtc-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-webrtc-star/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star?type=dev) |
+| **Connection Upgrades**                            |
+| [`interface-connection`](//github.com/libp2p/interface-connection) | [![npm](https://img.shields.io/npm/v/interface-connection.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/interface-connection/releases) | [![Dependency Status](https://david-dm.org/libp2p/interface-connection.svg?style=flat-square)](https://david-dm.org/libp2p/interface-connection) | [![devDependency Status](https://david-dm.org/libp2p/interface-connection/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/interface-connection?type=dev) |
+| **Stream Muxers**                                  |
+| [`interface-stream-muxer`](//github.com/libp2p/interface-stream-muxer) | [![npm](https://img.shields.io/npm/v/interface-stream-muxer.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/interface-stream-muxer/releases) | [![Dependency Status](https://david-dm.org/libp2p/interface-stream-muxer.svg?style=flat-square)](https://david-dm.org/libp2p/interface-stream-muxer) | [![devDependency Status](https://david-dm.org/libp2p/interface-stream-muxer/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/interface-stream-muxer?type=dev) |
+| [`libp2p-spdy`](//github.com/libp2p/js-libp2p-spdy) | [![npm](https://img.shields.io/npm/v/libp2p-spdy.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-spdy/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-spdy.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-spdy) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-spdy/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-spdy?type=dev) |
+| [`libp2p-multiplex`](https://github.com/libp2p/js-libp2p-multiplex)
+| **Discovery**                                       |
+| [`libp2p-mdns-discovery`](//github.com/libp2p/js-libp2p-mdns-discovery) | [![npm](https://img.shields.io/npm/v/libp2p-mdns-discovery.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-mdns-discovery/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-mdns-discovery.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mdns-discovery) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-mdns-discovery/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mdns-discovery?type=dev) |
+| [`libp2p-railing`](//github.com/libp2p/js-libp2p-railing) | [![npm](https://img.shields.io/npm/v/libp2p-railing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-railing/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-railing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-railing) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-railing/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-railing?type=dev) |
+| **Crypto Channels**                                |
+| [`libp2p-secio`](//github.com/libp2p/js-libp2p-secio) | [![npm](https://img.shields.io/npm/v/libp2p-secio.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-secio/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-secio.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-secio) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-secio/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-secio?type=dev) |
+| **Peer Routing**                                     |
+| [`libp2p-kad-routing`](//github.com/libp2p/js-libp2p-kad-routing) | [![npm](https://img.shields.io/npm/v/libp2p-kad-routing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-routing/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-kad-routing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-routing) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-kad-routing/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-routing?type=dev) |
+| **Content Routing**                                |
+| [`interface-record-store`](//github.com/libp2p/interface-record-store) | [![npm](https://img.shields.io/npm/v/interface-record-store.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/interface-record-store/releases) | [![Dependency Status](https://david-dm.org/libp2p/interface-record-store.svg?style=flat-square)](https://david-dm.org/libp2p/interface-record-store) | [![devDependency Status](https://david-dm.org/libp2p/interface-record-store/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/interface-record-store?type=dev) |
+| [`libp2p-record`](//github.com/libp2p/js-libp2p-record) | [![npm](https://img.shields.io/npm/v/libp2p-record.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-record/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-record.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-record) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-record/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-record?type=dev) |
+| [`libp2p-distributed-record-store`](//github.com/libp2p/js-libp2p-distributed-record-store) | [![npm](https://img.shields.io/npm/v/undefined.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-distributed-record-store/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-distributed-record-store.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-distributed-record-store) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-distributed-record-store/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-distributed-record-store?type=dev) |
+| [`libp2p-kad-record-store`](//github.com/libp2p/js-libp2p-kad-record-store) | [![npm](https://img.shields.io/npm/v/libp2p-kad-record-store.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-record-store/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-kad-record-store.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-record-store) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-kad-record-store/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-record-store?type=dev) |
+| **Generics**                                        |
+| [`libp2p-swarm`](//github.com/libp2p/js-libp2p-swarm) | [![npm](https://img.shields.io/npm/v/libp2p-swarm.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-swarm/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-swarm.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-swarm) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-swarm/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-swarm?type=dev) |
+| [`libp2p-ping`](//github.com/libp2p/js-libp2p-ping) | [![npm](https://img.shields.io/npm/v/libp2p-ping.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-ping/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-libp2p-ping.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-ping) | [![devDependency Status](https://david-dm.org/libp2p/js-libp2p-ping/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-ping?type=dev) |
+| [`multistream-select`](//github.com/libp2p/js-multistream) | [![npm](https://img.shields.io/npm/v/multistream-select.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-multistream/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-multistream.svg?style=flat-square)](https://david-dm.org/libp2p/js-multistream) | [![devDependency Status](https://david-dm.org/libp2p/js-multistream/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-multistream?type=dev) |
+| **Data Types**                                      |
+| [`peer-book`](//github.com/libp2p/js-peer-book) | [![npm](https://img.shields.io/npm/v/peer-book.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-book/releases) | [![Dependency Status](https://david-dm.org/libp2p/js-peer-book.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-book) | [![devDependency Status](https://david-dm.org/libp2p/js-peer-book/dev-status.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-book?type=dev) |
+| [`peer-id`](https://github.com/libp2p/js-peer-id)

-![](https://cloud.githubusercontent.com/assets/1211152/9450620/a02e3a9c-4aa1-11e5-83fd-cd996a0a4b6f.png)
+## Contribute
+
+The libp2p implementation in JavaScript is a work in progress. As such, there are a few things you can do right now to help out:
+
+ - Go through the modules and **check out existing issues**. This would be especially useful for modules in active development. Some knowledge of IPFS/libp2p may be required, as well as the infrasture behind it - for instance, you may need to read up on p2p and more complex operations like muxing to be able to help technically.
+ - **Perform code reviews**. Most of this has been developed by @diasdavid, which means that more eyes will help a) speed the project along b) ensure quality and c) reduce possible future bugs.
+ - **Add tests**. There can never be enough tests.
+
+## License
+
+[MIT](LICENSE) © David Dias
--- a/circle.yml
+++ b/circle.yml
@ -0,0 +1,12 @@
+machine:
+  node:
+    version: stable
+
+dependencies:
+  pre:
+    - google-chrome --version
+    - wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
+    - sudo sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
+    - sudo apt-get update
+    - sudo apt-get --only-upgrade install google-chrome-stable
+    - google-chrome --version
--- a/examples/README.md
+++ b/examples/README.md
@ -0,0 +1,11 @@
+# `js-libp2p` Examples and Tutorials
+
+In this folder, you can find a variety of examples to help you get started in using js-libp2p, in Node.js and in the Browser. Every example as a specific purpose and some of each incorporate a full tutorial that you can follow through, helping you expand your knowledge about libp2p and p2p networks in general.
+
+Let us know if you find any issue or if you want to contribute and add a new tutorial, feel welcome to submit a PR, thank you!
+
+## Examples
+
+- [The standard echo net example with libp2p](./echo)
+- [A simple chat app with](./chat)
+- [See other nodes in the network using WebRTC Star discovery mechanism](./see-nodes)
--- a/examples/chat/README.md
+++ b/examples/chat/README.md
@ -0,0 +1 @@
+# Chat example with libp2p
--- a/examples/chat/src/dialer.js
+++ b/examples/chat/src/dialer.js
@ -0,0 +1,77 @@
+'use strict'
+/* eslint-disable no-console */
+
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const Node = require('./libp2p-bundle')
+const pull = require('pull-stream')
+const async = require('async')
+const Pushable = require('pull-pushable')
+const p = Pushable()
+let idListener
+
+async.parallel([
+  (callback) => {
+    PeerId.createFromJSON(require('./peer-id-dialer'), (err, idDialer) => {
+      if (err) {
+        throw err
+      }
+      callback(null, idDialer)
+    })
+  },
+  (callback) => {
+    PeerId.createFromJSON(require('./peer-id-listener'), (err, idListener) => {
+      if (err) {
+        throw err
+      }
+      callback(null, idListener)
+    })
+  }
+], (err, ids) => {
+  if (err) throw err
+  const peerDialer = new PeerInfo(ids[0])
+  peerDialer.multiaddr.add('/ip4/0.0.0.0/tcp/0')
+  const nodeDialer = new Node(peerDialer)
+
+  const peerListener = new PeerInfo(ids[1])
+  idListener = ids[1]
+  peerListener.multiaddr.add('/ip4/127.0.0.1/tcp/10333')
+  nodeDialer.start((err) => {
+    if (err) {
+      throw err
+    }
+
+    console.log('Dialer ready, listening on:')
+
+    peerListener.multiaddrs.forEach((ma) => {
+      console.log(ma.toString() + '/ipfs/' + idListener.toB58String())
+    })
+
+    nodeDialer.dialByPeerInfo(peerListener, '/chat/1.0.0', (err, conn) => {
+      if (err) {
+        throw err
+      }
+      console.log('nodeA dialed to nodeB on protocol: /chat/1.0.0')
+      console.log('Type a message and see what happens')
+      // Write operation. Data sent as a buffer
+      pull(
+        p,
+        conn
+      )
+      // Sink, data converted from buffer to utf8 string
+      pull(
+        conn,
+        pull.map((data) => {
+          return data.toString('utf8').replace('\n', '')
+        }),
+        pull.drain(console.log)
+      )
+
+      process.stdin.setEncoding('utf8')
+      process.openStdin().on('data', (chunk) => {
+        var data = chunk.toString()
+        p.push(data)
+      })
+    })
+  })
+})
--- a/examples/chat/src/libp2p-bundle.js
+++ b/examples/chat/src/libp2p-bundle.js
@ -0,0 +1,80 @@
+'use strict'
+
+const TCP = require('libp2p-tcp')
+const MulticastDNS = require('libp2p-mdns')
+const WS = require('libp2p-websockets')
+const Railing = require('libp2p-railing')
+const spdy = require('libp2p-spdy')
+const KadDHT = require('libp2p-kad-dht')
+const multiplex = require('libp2p-multiplex')
+const secio = require('libp2p-secio')
+const libp2p = require('../..')
+
+function mapMuxers (list) {
+  return list.map((pref) => {
+    if (typeof pref !== 'string') {
+      return pref
+    }
+    switch (pref.trim().toLowerCase()) {
+      case 'spdy': return spdy
+      case 'multiplex': return multiplex
+      default:
+        throw new Error(pref + ' muxer not available')
+    }
+  })
+}
+
+function getMuxers (muxers) {
+  const muxerPrefs = process.env.LIBP2P_MUXER
+  if (muxerPrefs && !muxers) {
+    return mapMuxers(muxerPrefs.split(','))
+  } else if (muxers) {
+    return mapMuxers(muxers)
+  } else {
+    return [multiplex, spdy]
+  }
+}
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: getMuxers(options.muxer),
+        crypto: [ secio ]
+      },
+      discovery: []
+    }
+
+    if (options.dht) {
+      modules.DHT = KadDHT
+    }
+
+    if (options.mdns) {
+      const mdns = new MulticastDNS(peerInfo, 'ipfs.local')
+      modules.discovery.push(mdns)
+    }
+
+    if (options.bootstrap) {
+      const r = new Railing(options.bootstrap)
+      modules.discovery.push(r)
+    }
+
+    if (options.modules && options.modules.transport) {
+      options.modules.transport.forEach((t) => modules.transport.push(t))
+    }
+
+    if (options.modules && options.modules.discovery) {
+      options.modules.discovery.forEach((d) => modules.discovery.push(d))
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node
--- a/examples/chat/src/listener.js
+++ b/examples/chat/src/listener.js
@ -0,0 +1,54 @@
+'use strict'
+/* eslint-disable no-console */
+
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const Node = require('./libp2p-bundle.js')
+const pull = require('pull-stream')
+const Pushable = require('pull-pushable')
+const p = Pushable()
+
+PeerId.createFromJSON(require('./peer-id-listener'), (err, idListener) => {
+  if (err) {
+    throw err
+  }
+  const peerListener = new PeerInfo(idListener)
+  peerListener.multiaddr.add('/ip4/0.0.0.0/tcp/10333')
+  const nodeListener = new Node(peerListener)
+
+  nodeListener.start((err) => {
+    if (err) {
+      throw err
+    }
+
+    nodeListener.swarm.on('peer-mux-established', (peerInfo) => {
+      console.log(peerInfo.id.toB58String())
+    })
+
+    nodeListener.handle('/chat/1.0.0', (protocol, conn) => {
+      pull(
+        p,
+        conn
+      )
+
+      pull(
+        conn,
+        pull.map((data) => {
+          return data.toString('utf8').replace('\n', '')
+        }),
+        pull.drain(console.log)
+      )
+
+      process.stdin.setEncoding('utf8')
+      process.openStdin().on('data', (chunk) => {
+        var data = chunk.toString()
+        p.push(data)
+      })
+    })
+
+    console.log('Listener ready, listening on:')
+    peerListener.multiaddrs.forEach((ma) => {
+      console.log(ma.toString() + '/ipfs/' + idListener.toB58String())
+    })
+  })
+})
--- a/examples/chat/src/peer-id-dialer.json
+++ b/examples/chat/src/peer-id-dialer.json
@ -0,0 +1,5 @@
+{
+  "id": "Qma3GsJmB47xYuyahPZPSadh1avvxfyYQwk8R3UnFrQ6aP",
+  "privKey": "CAASpwkwggSjAgEAAoIBAQCaNSDOjPz6T8HZsf7LDpxiQRiN2OjeyIHUS05p8QWOr3EFUCFsC31R4moihE5HN+FxNalUyyFZU//yjf1pdnlMJqrVByJSMa+y2y4x2FucpoCAO97Tx+iWzwlZ2UXEUXM1Y81mhPbeWXy+wP2xElTgIER0Tsn/thoA0SD2u9wJuVvM7dB7cBcHYmqV6JH+KWCedRTum6O1BssqP/4Lbm2+rkrbZ4+oVRoU2DRLoFhKqwqLtylrbuj4XOI3XykMXV5+uQXz1JzubNOB9lsc6K+eRC+w8hhhDuFMgzkZ4qomCnx3uhO67KaICd8yqqBa6PJ/+fBM5Xk4hjyR40bwcf41AgMBAAECggEAZnrCJ6IYiLyyRdr9SbKXCNDb4YByGYPEi/HT1aHgIJfFE1PSMjxcdytxfyjP4JJpVtPjiT9JFVU2ddoYu5qJN6tGwjVwgJEWg1UXmPaAw1T/drjS94kVsAs82qICtFmwp52Apg3dBZ0Qwq/8qE1XbG7lLyohIbfCBiL0tiPYMfkcsN9gnFT/kFCX0LVs2pa9fHCRMY9rqCc4/rWJa1w8sMuQ23y4lDaxKF9OZVvOHFQkbBDrkquWHE4r55fchCz/rJklkPJUNENuncBRu0/2X+p4IKFD1DnttXNwb8j4LPiSlLro1T0hiUr5gO2QmdYwXFF63Q3mjQy0+5I4eNbjjQKBgQDZvZy3gUKS/nQNkYfq9za80uLbIj/cWbO+ZZjXCsj0fNIcQFJcKMBoA7DjJvu2S/lf86/41YHkPdmrLAEQAkJ+5BBNOycjYK9minTEjIMMmZDTXXugZ62wnU6F46uLkgEChTqEP57Y6xwwV+JaEDFEsW5N1eE9lEVX9nGIr4phMwKBgQC1TazLuEt1WBx/iUT83ita7obXqoKNzwsS/MWfY2innzYZKDOqeSYZzLtt9uTtp4X4uLyPbYs0qFYhXLsUYMoGHNN8+NdjoyxCjQRJRBkMtaNR0lc5lVDWl3bTuJovjFCgAr9uqJrmI5OHcCIk/cDpdWb3nWaMihVlePmiTcTy9wKBgQCU0u7c1jKkudqks4XM6a+2HAYGdUBk4cLjLhnrUWnNAcuyl5wzdX8dGPi8KZb+IKuQE8WBNJ2VXVj7kBYh1QmSJVunDflQSvNYCOaKuOeRoxzD+y9Wkca74qkbBmPn/6FFEb7PSZTO+tPHjyodGNgz9XpJJRjQuBk1aDJtlF3m1QKBgE5SAr5ym65SZOU3UGUIOKRsfDW4Q/OsqDUImvpywCgBICaX9lHDShFFHwau7FA52ScL7vDquoMB4UtCOtLfyQYA9995w9oYCCurrVlVIJkb8jSLcADBHw3EmqF1kq3NqJqm9TmBfoDCh52vdCCUufxgKh33kfBOSlXuf7B8dgMbAoGAZ3r0/mBQX6S+s5+xCETMTSNv7TQzxgtURIpVs+ZVr2cMhWhiv+n0Omab9X9Z50se8cWl5lkvx8vn3D/XHHIPrMF6qk7RAXtvReb+PeitNvm0odqjFv0J2qki6fDs0HKwq4kojAXI1Md8Th0eobNjsy21fEEJT7uKMJdovI/SErI=",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCaNSDOjPz6T8HZsf7LDpxiQRiN2OjeyIHUS05p8QWOr3EFUCFsC31R4moihE5HN+FxNalUyyFZU//yjf1pdnlMJqrVByJSMa+y2y4x2FucpoCAO97Tx+iWzwlZ2UXEUXM1Y81mhPbeWXy+wP2xElTgIER0Tsn/thoA0SD2u9wJuVvM7dB7cBcHYmqV6JH+KWCedRTum6O1BssqP/4Lbm2+rkrbZ4+oVRoU2DRLoFhKqwqLtylrbuj4XOI3XykMXV5+uQXz1JzubNOB9lsc6K+eRC+w8hhhDuFMgzkZ4qomCnx3uhO67KaICd8yqqBa6PJ/+fBM5Xk4hjyR40bwcf41AgMBAAE="
+}
--- a/examples/chat/src/peer-id-listener.json
+++ b/examples/chat/src/peer-id-listener.json
@ -0,0 +1,5 @@
+{
+  "id": "QmcrQZ6RJdpYuGvZqD5QEHAv6qX4BrQLJLQPQUrTrzdcgm",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQDLZZcGcbe4urMBVlcHgN0fpBymY+xcr14ewvamG70QZODJ1h9sljlExZ7byLiqRB3SjGbfpZ1FweznwNxWtWpjHkQjTVXeoM4EEgDSNO/Cg7KNlU0EJvgPJXeEPycAZX9qASbVJ6EECQ40VR/7+SuSqsdL1hrmG1phpIju+D64gLyWpw9WEALfzMpH5I/KvdYDW3N4g6zOD2mZNp5y1gHeXINHWzMF596O72/6cxwyiXV1eJ000k1NVnUyrPjXtqWdVLRk5IU1LFpoQoXZU5X1hKj1a2qt/lZfH5eOrF/ramHcwhrYYw1txf8JHXWO/bbNnyemTHAvutZpTNrsWATfAgMBAAECggEAQj0obPnVyjxLFZFnsFLgMHDCv9Fk5V5bOYtmxfvcm50us6ye+T8HEYWGUa9RrGmYiLweuJD34gLgwyzE1RwptHPj3tdNsr4NubefOtXwixlWqdNIjKSgPlaGULQ8YF2tm/kaC2rnfifwz0w1qVqhPReO5fypL+0ShyANVD3WN0Fo2ugzrniCXHUpR2sHXSg6K+2+qWdveyjNWog34b7CgpV73Ln96BWae6ElU8PR5AWdMnRaA9ucA+/HWWJIWB3Fb4+6uwlxhu2L50Ckq1gwYZCtGw63q5L4CglmXMfIKnQAuEzazq9T4YxEkp+XDnVZAOgnQGUBYpetlgMmkkh9qQKBgQDvsEs0ThzFLgnhtC2Jy//ZOrOvIAKAZZf/mS08AqWH3L0/Rjm8ZYbLsRcoWU78sl8UFFwAQhMRDBP9G+RPojWVahBL/B7emdKKnFR1NfwKjFdDVaoX5uNvZEKSl9UubbC4WZJ65u/cd5jEnj+w3ir9G8n+P1gp/0yBz02nZXFgSwKBgQDZPQr4HBxZL7Kx7D49ormIlB7CCn2i7mT11Cppn5ifUTrp7DbFJ2t9e8UNk6tgvbENgCKXvXWsmflSo9gmMxeEOD40AgAkO8Pn2R4OYhrwd89dECiKM34HrVNBzGoB5+YsAno6zGvOzLKbNwMG++2iuNXqXTk4uV9GcI8OnU5ZPQKBgCZUGrKSiyc85XeiSGXwqUkjifhHNh8yH8xPwlwGUFIZimnD4RevZI7OEtXw8iCWpX2gg9XGuyXOuKORAkF5vvfVriV4e7c9Ad4Igbj8mQFWz92EpV6NHXGCpuKqRPzXrZrNOA9PPqwSs+s9IxI1dMpk1zhBCOguWx2m+NP79NVhAoGBAI6WSoTfrpu7ewbdkVzTWgQTdLzYNe6jmxDf2ZbKclrf7lNr/+cYIK2Ud5qZunsdBwFdgVcnu/02czeS42TvVBgs8mcgiQc/Uy7yi4/VROlhOnJTEMjlU2umkGc3zLzDgYiRd7jwRDLQmMrYKNyEr02HFKFn3w8kXSzW5I8rISnhAoGBANhchHVtJd3VMYvxNcQb909FiwTnT9kl9pkjhwivx+f8/K8pDfYCjYSBYCfPTM5Pskv5dXzOdnNuCj6Y2H/9m2SsObukBwF0z5Qijgu1DsxvADVIKZ4rzrGb4uSEmM6200qjJ/9U98fVM7rvOraakrhcf9gRwuspguJQnSO9cLj6",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDLZZcGcbe4urMBVlcHgN0fpBymY+xcr14ewvamG70QZODJ1h9sljlExZ7byLiqRB3SjGbfpZ1FweznwNxWtWpjHkQjTVXeoM4EEgDSNO/Cg7KNlU0EJvgPJXeEPycAZX9qASbVJ6EECQ40VR/7+SuSqsdL1hrmG1phpIju+D64gLyWpw9WEALfzMpH5I/KvdYDW3N4g6zOD2mZNp5y1gHeXINHWzMF596O72/6cxwyiXV1eJ000k1NVnUyrPjXtqWdVLRk5IU1LFpoQoXZU5X1hKj1a2qt/lZfH5eOrF/ramHcwhrYYw1txf8JHXWO/bbNnyemTHAvutZpTNrsWATfAgMBAAE="
+}
--- a/examples/echo/README.md
+++ b/examples/echo/README.md
@ -0,0 +1 @@
+# Echo example with libp2p
--- a/examples/echo/src/dialer.js
+++ b/examples/echo/src/dialer.js
@ -0,0 +1,56 @@
+'use strict'
+/* eslint-disable no-console */
+
+/*
+ * Dialer Node
+ */
+
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const Node = require('./libp2p-bundle')
+const pull = require('pull-stream')
+const async = require('async')
+
+async.parallel([
+  (cb) => PeerId.createFromJSON(require('./id-d'), cb),
+  (cb) => PeerId.createFromJSON(require('./id-l'), cb)
+], (err, ids) => {
+  if (err) { throw err }
+
+  // Dialer
+  const dialerId = ids[0]
+  const dialerPeerInfo = new PeerInfo(dialerId)
+  dialerPeerInfo.multiaddr.add('/ip4/0.0.0.0/tcp/0')
+  const dialerNode = new Node(dialerPeerInfo)
+
+  // Peer to Dial
+  const listenerPeerInfo = new PeerInfo(ids[1])
+  const listenerId = ids[1]
+  const listenerMultiaddr = '/ip4/127.0.0.1/tcp/10333/ipfs/' +
+      listenerId.toB58String()
+  listenerPeerInfo.multiaddr.add(listenerMultiaddr)
+
+  dialerNode.start((err) => {
+    if (err) { throw err }
+
+    console.log('Dialer ready, listening on:')
+    dialerPeerInfo.multiaddrs.forEach((ma) => console.log(ma.toString() +
+          '/ipfs/' + dialerId.toB58String()))
+
+    console.log('Dialing to peer:', listenerMultiaddr.toString())
+    dialerNode.dialByPeerInfo(listenerPeerInfo, '/echo/1.0.0', (err, conn) => {
+      if (err) { throw err }
+
+      console.log('nodeA dialed to nodeB on protocol: /echo/1.0.0')
+
+      pull(
+        pull.values(['hey']),
+        conn,
+        pull.collect((err, data) => {
+          if (err) { throw err }
+          console.log('received echo:', data.toString())
+        })
+      )
+    })
+  })
+})
--- a/examples/echo/src/id-d.json
+++ b/examples/echo/src/id-d.json
@ -0,0 +1,5 @@
+{
+  "id": "Qma3GsJmB47xYuyahPZPSadh1avvxfyYQwk8R3UnFrQ6aP",
+  "privKey": "CAASpwkwggSjAgEAAoIBAQCaNSDOjPz6T8HZsf7LDpxiQRiN2OjeyIHUS05p8QWOr3EFUCFsC31R4moihE5HN+FxNalUyyFZU//yjf1pdnlMJqrVByJSMa+y2y4x2FucpoCAO97Tx+iWzwlZ2UXEUXM1Y81mhPbeWXy+wP2xElTgIER0Tsn/thoA0SD2u9wJuVvM7dB7cBcHYmqV6JH+KWCedRTum6O1BssqP/4Lbm2+rkrbZ4+oVRoU2DRLoFhKqwqLtylrbuj4XOI3XykMXV5+uQXz1JzubNOB9lsc6K+eRC+w8hhhDuFMgzkZ4qomCnx3uhO67KaICd8yqqBa6PJ/+fBM5Xk4hjyR40bwcf41AgMBAAECggEAZnrCJ6IYiLyyRdr9SbKXCNDb4YByGYPEi/HT1aHgIJfFE1PSMjxcdytxfyjP4JJpVtPjiT9JFVU2ddoYu5qJN6tGwjVwgJEWg1UXmPaAw1T/drjS94kVsAs82qICtFmwp52Apg3dBZ0Qwq/8qE1XbG7lLyohIbfCBiL0tiPYMfkcsN9gnFT/kFCX0LVs2pa9fHCRMY9rqCc4/rWJa1w8sMuQ23y4lDaxKF9OZVvOHFQkbBDrkquWHE4r55fchCz/rJklkPJUNENuncBRu0/2X+p4IKFD1DnttXNwb8j4LPiSlLro1T0hiUr5gO2QmdYwXFF63Q3mjQy0+5I4eNbjjQKBgQDZvZy3gUKS/nQNkYfq9za80uLbIj/cWbO+ZZjXCsj0fNIcQFJcKMBoA7DjJvu2S/lf86/41YHkPdmrLAEQAkJ+5BBNOycjYK9minTEjIMMmZDTXXugZ62wnU6F46uLkgEChTqEP57Y6xwwV+JaEDFEsW5N1eE9lEVX9nGIr4phMwKBgQC1TazLuEt1WBx/iUT83ita7obXqoKNzwsS/MWfY2innzYZKDOqeSYZzLtt9uTtp4X4uLyPbYs0qFYhXLsUYMoGHNN8+NdjoyxCjQRJRBkMtaNR0lc5lVDWl3bTuJovjFCgAr9uqJrmI5OHcCIk/cDpdWb3nWaMihVlePmiTcTy9wKBgQCU0u7c1jKkudqks4XM6a+2HAYGdUBk4cLjLhnrUWnNAcuyl5wzdX8dGPi8KZb+IKuQE8WBNJ2VXVj7kBYh1QmSJVunDflQSvNYCOaKuOeRoxzD+y9Wkca74qkbBmPn/6FFEb7PSZTO+tPHjyodGNgz9XpJJRjQuBk1aDJtlF3m1QKBgE5SAr5ym65SZOU3UGUIOKRsfDW4Q/OsqDUImvpywCgBICaX9lHDShFFHwau7FA52ScL7vDquoMB4UtCOtLfyQYA9995w9oYCCurrVlVIJkb8jSLcADBHw3EmqF1kq3NqJqm9TmBfoDCh52vdCCUufxgKh33kfBOSlXuf7B8dgMbAoGAZ3r0/mBQX6S+s5+xCETMTSNv7TQzxgtURIpVs+ZVr2cMhWhiv+n0Omab9X9Z50se8cWl5lkvx8vn3D/XHHIPrMF6qk7RAXtvReb+PeitNvm0odqjFv0J2qki6fDs0HKwq4kojAXI1Md8Th0eobNjsy21fEEJT7uKMJdovI/SErI=",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCaNSDOjPz6T8HZsf7LDpxiQRiN2OjeyIHUS05p8QWOr3EFUCFsC31R4moihE5HN+FxNalUyyFZU//yjf1pdnlMJqrVByJSMa+y2y4x2FucpoCAO97Tx+iWzwlZ2UXEUXM1Y81mhPbeWXy+wP2xElTgIER0Tsn/thoA0SD2u9wJuVvM7dB7cBcHYmqV6JH+KWCedRTum6O1BssqP/4Lbm2+rkrbZ4+oVRoU2DRLoFhKqwqLtylrbuj4XOI3XykMXV5+uQXz1JzubNOB9lsc6K+eRC+w8hhhDuFMgzkZ4qomCnx3uhO67KaICd8yqqBa6PJ/+fBM5Xk4hjyR40bwcf41AgMBAAE="
+}
--- a/examples/echo/src/id-l.json
+++ b/examples/echo/src/id-l.json
@ -0,0 +1,5 @@
+{
+  "id": "QmcrQZ6RJdpYuGvZqD5QEHAv6qX4BrQLJLQPQUrTrzdcgm",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQDLZZcGcbe4urMBVlcHgN0fpBymY+xcr14ewvamG70QZODJ1h9sljlExZ7byLiqRB3SjGbfpZ1FweznwNxWtWpjHkQjTVXeoM4EEgDSNO/Cg7KNlU0EJvgPJXeEPycAZX9qASbVJ6EECQ40VR/7+SuSqsdL1hrmG1phpIju+D64gLyWpw9WEALfzMpH5I/KvdYDW3N4g6zOD2mZNp5y1gHeXINHWzMF596O72/6cxwyiXV1eJ000k1NVnUyrPjXtqWdVLRk5IU1LFpoQoXZU5X1hKj1a2qt/lZfH5eOrF/ramHcwhrYYw1txf8JHXWO/bbNnyemTHAvutZpTNrsWATfAgMBAAECggEAQj0obPnVyjxLFZFnsFLgMHDCv9Fk5V5bOYtmxfvcm50us6ye+T8HEYWGUa9RrGmYiLweuJD34gLgwyzE1RwptHPj3tdNsr4NubefOtXwixlWqdNIjKSgPlaGULQ8YF2tm/kaC2rnfifwz0w1qVqhPReO5fypL+0ShyANVD3WN0Fo2ugzrniCXHUpR2sHXSg6K+2+qWdveyjNWog34b7CgpV73Ln96BWae6ElU8PR5AWdMnRaA9ucA+/HWWJIWB3Fb4+6uwlxhu2L50Ckq1gwYZCtGw63q5L4CglmXMfIKnQAuEzazq9T4YxEkp+XDnVZAOgnQGUBYpetlgMmkkh9qQKBgQDvsEs0ThzFLgnhtC2Jy//ZOrOvIAKAZZf/mS08AqWH3L0/Rjm8ZYbLsRcoWU78sl8UFFwAQhMRDBP9G+RPojWVahBL/B7emdKKnFR1NfwKjFdDVaoX5uNvZEKSl9UubbC4WZJ65u/cd5jEnj+w3ir9G8n+P1gp/0yBz02nZXFgSwKBgQDZPQr4HBxZL7Kx7D49ormIlB7CCn2i7mT11Cppn5ifUTrp7DbFJ2t9e8UNk6tgvbENgCKXvXWsmflSo9gmMxeEOD40AgAkO8Pn2R4OYhrwd89dECiKM34HrVNBzGoB5+YsAno6zGvOzLKbNwMG++2iuNXqXTk4uV9GcI8OnU5ZPQKBgCZUGrKSiyc85XeiSGXwqUkjifhHNh8yH8xPwlwGUFIZimnD4RevZI7OEtXw8iCWpX2gg9XGuyXOuKORAkF5vvfVriV4e7c9Ad4Igbj8mQFWz92EpV6NHXGCpuKqRPzXrZrNOA9PPqwSs+s9IxI1dMpk1zhBCOguWx2m+NP79NVhAoGBAI6WSoTfrpu7ewbdkVzTWgQTdLzYNe6jmxDf2ZbKclrf7lNr/+cYIK2Ud5qZunsdBwFdgVcnu/02czeS42TvVBgs8mcgiQc/Uy7yi4/VROlhOnJTEMjlU2umkGc3zLzDgYiRd7jwRDLQmMrYKNyEr02HFKFn3w8kXSzW5I8rISnhAoGBANhchHVtJd3VMYvxNcQb909FiwTnT9kl9pkjhwivx+f8/K8pDfYCjYSBYCfPTM5Pskv5dXzOdnNuCj6Y2H/9m2SsObukBwF0z5Qijgu1DsxvADVIKZ4rzrGb4uSEmM6200qjJ/9U98fVM7rvOraakrhcf9gRwuspguJQnSO9cLj6",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDLZZcGcbe4urMBVlcHgN0fpBymY+xcr14ewvamG70QZODJ1h9sljlExZ7byLiqRB3SjGbfpZ1FweznwNxWtWpjHkQjTVXeoM4EEgDSNO/Cg7KNlU0EJvgPJXeEPycAZX9qASbVJ6EECQ40VR/7+SuSqsdL1hrmG1phpIju+D64gLyWpw9WEALfzMpH5I/KvdYDW3N4g6zOD2mZNp5y1gHeXINHWzMF596O72/6cxwyiXV1eJ000k1NVnUyrPjXtqWdVLRk5IU1LFpoQoXZU5X1hKj1a2qt/lZfH5eOrF/ramHcwhrYYw1txf8JHXWO/bbNnyemTHAvutZpTNrsWATfAgMBAAE="
+}
--- a/examples/echo/src/libp2p-bundle.js
+++ b/examples/echo/src/libp2p-bundle.js
@ -0,0 +1,80 @@
+'use strict'
+
+const TCP = require('libp2p-tcp')
+const MulticastDNS = require('libp2p-mdns')
+const WS = require('libp2p-websockets')
+const Railing = require('libp2p-railing')
+const spdy = require('libp2p-spdy')
+const KadDHT = require('libp2p-kad-dht')
+const multiplex = require('libp2p-multiplex')
+const secio = require('libp2p-secio')
+const libp2p = require('../../..')
+
+function mapMuxers (list) {
+  return list.map((pref) => {
+    if (typeof pref !== 'string') {
+      return pref
+    }
+    switch (pref.trim().toLowerCase()) {
+      case 'spdy': return spdy
+      case 'multiplex': return multiplex
+      default:
+        throw new Error(pref + ' muxer not available')
+    }
+  })
+}
+
+function getMuxers (muxers) {
+  const muxerPrefs = process.env.LIBP2P_MUXER
+  if (muxerPrefs && !muxers) {
+    return mapMuxers(muxerPrefs.split(','))
+  } else if (muxers) {
+    return mapMuxers(muxers)
+  } else {
+    return [multiplex, spdy]
+  }
+}
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: getMuxers(options.muxer),
+        crypto: [ secio ]
+      },
+      discovery: []
+    }
+
+    if (options.dht) {
+      modules.DHT = KadDHT
+    }
+
+    if (options.mdns) {
+      const mdns = new MulticastDNS(peerInfo, 'ipfs.local')
+      modules.discovery.push(mdns)
+    }
+
+    if (options.bootstrap) {
+      const r = new Railing(options.bootstrap)
+      modules.discovery.push(r)
+    }
+
+    if (options.modules && options.modules.transport) {
+      options.modules.transport.forEach((t) => modules.transport.push(t))
+    }
+
+    if (options.modules && options.modules.discovery) {
+      options.modules.discovery.forEach((d) => modules.discovery.push(d))
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node
--- a/examples/echo/src/listener.js
+++ b/examples/echo/src/listener.js
@ -0,0 +1,44 @@
+'use strict'
+/* eslint-disable no-console */
+
+/*
+ * Listener Node
+ */
+
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const Node = require('./libp2p-bundle')
+const pull = require('pull-stream')
+const series = require('async/series')
+
+let listenerId
+let listenerNode
+
+series([
+  (cb) => {
+    PeerId.createFromJSON(require('./id-l'), (err, id) => {
+      if (err) { return cb(err) }
+      listenerId = id
+      cb()
+    })
+  },
+  (cb) => {
+    const listenerPeerInfo = new PeerInfo(listenerId)
+    listenerPeerInfo.multiaddr.add('/ip4/0.0.0.0/tcp/10333')
+    listenerNode = new Node(listenerPeerInfo)
+
+    listenerNode.swarm.on('peer-mux-established', (peerInfo) => {
+      console.log('received dial to me from:', peerInfo.id.toB58String())
+    })
+
+    listenerNode.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+    listenerNode.start(cb)
+  }
+], (err) => {
+  if (err) { throw err }
+
+  console.log('Listener ready, listening on:')
+  listenerNode.peerInfo.multiaddrs.forEach((ma) => {
+    console.log(ma.toString() + '/ipfs/' + listenerId.toB58String())
+  })
+})
--- a/examples/see-nodes/.gitignore
+++ b/examples/see-nodes/.gitignore
@ -0,0 +1 @@
+bundle.js
--- a/examples/see-nodes/README.md
+++ b/examples/see-nodes/README.md
@ -0,0 +1,12 @@
+# See nodes
+
+> See other nodes in the network using WebRTC Star Discovery
+
+# Try it out
+
+```
+# After having run `npm install` at the root of the repo.
+> npm install
+> npm start
+# open your browser in port :9090
+```
--- a/examples/see-nodes/package.json
+++ b/examples/see-nodes/package.json
@ -0,0 +1,22 @@
+{
+  "name": "see-nodes",
+  "version": "0.0.0",
+  "description": "See other nodes in the network using WebRTC Star discovery mechanism",
+  "main": "src/index.js",
+  "scripts": {
+    "bundle": "browserify src/index.js > public/bundle.js",
+    "serve": "static public -p 9090 -H '{\"Cache-Control\": \"no-cache, must-revalidate\"}'",
+    "mon": "nodemon --exec \"npm run start\" --ignore public/bundle.js",
+    "start": "npm run bundle && npm run serve"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "browserify": "^14.0.0",
+    "browserify-optional": "^1.0.0",
+    "concat-stream": "^1.6.0",
+    "detect-dom-ready": "^1.0.2",
+    "node-static": "^0.7.9",
+    "nodemon": "^1.11.0"
+  },
+  "dependencies": {}
+}
--- a/examples/see-nodes/public/index.html
+++ b/examples/see-nodes/public/index.html
@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8"/>
+    <title>p2p mapper</title>
+  </head>
+  <body>
+    <h1>p2p mapper</h1>
+    <div id="my-peer"></div>
+    <div id="swarm"></div>
+
+    <script src="bundle.js"></script>
+  </body>
+</html>
--- a/examples/see-nodes/src/create-node.js
+++ b/examples/see-nodes/src/create-node.js
@ -0,0 +1,24 @@
+'use strict'
+
+const PeerInfo = require('peer-info')
+const Node = require('./libp2p-bundle')
+
+function createNode (callback) {
+  PeerInfo.create((err, peerInfo) => {
+    if (err) {
+      return callback(err)
+    }
+
+    const peerIdStr = peerInfo.id.toB58String()
+    const ma = `/libp2p-webrtc-star/dns4/star-signal.cloud.ipfs.team/wss/ipfs/${peerIdStr}`
+
+    peerInfo.multiaddrs.add(ma)
+
+    const node = new Node(peerInfo, undefined, { webRTCStar: true })
+
+    node.idStr = peerIdStr
+    callback(null, node)
+  })
+}
+
+module.exports = createNode
--- a/examples/see-nodes/src/index.js
+++ b/examples/see-nodes/src/index.js
@ -0,0 +1,58 @@
+'use strict'
+
+const domReady = require('detect-dom-ready')
+const createNode = require('./create-node')
+
+domReady(() => {
+  const myPeerDiv = document.getElementById('my-peer')
+  const swarmDiv = document.getElementById('swarm')
+
+  createNode((err, node) => {
+    if (err) {
+      return console.log('Could not create the Node, check if your browser has WebRTC Support', err)
+    }
+
+    node.on('peer:discovery', (peerInfo) => {
+      console.log('Discovered a peer')
+      const idStr = peerInfo.id.toB58String()
+      console.log('Discovered: ' + idStr)
+
+      node.dial(peerInfo, (err, conn) => {
+        if (err) { return console.log('Failed to dial:', idStr) }
+      })
+    })
+
+    node.on('peer:connect', (peerInfo) => {
+      const idStr = peerInfo.id.toB58String()
+      console.log('Got connection to: ' + idStr)
+      const connDiv = document.createElement('div')
+      connDiv.innerHTML = 'Connected to: ' + idStr
+      connDiv.id = idStr
+      swarmDiv.append(connDiv)
+    })
+
+    node.on('peer:disconnect', (peerInfo) => {
+      const idStr = peerInfo.id.toB58String()
+      console.log('Lost connection to: ' + idStr)
+      document.getElementById(idStr).remove()
+    })
+
+    node.start((err) => {
+      if (err) {
+        return console.log('WebRTC not supported')
+      }
+
+      const idStr = node.peerInfo.id.toB58String()
+
+      const idDiv = document
+        .createTextNode('Node is ready. ID: ' + idStr)
+
+      myPeerDiv.append(idDiv)
+
+      console.log('Node is listening o/')
+
+      // NOTE: to stop the node
+      // node.stop((err) => {})
+    })
+  })
+})
--- a/examples/see-nodes/src/libp2p-bundle.js
+++ b/examples/see-nodes/src/libp2p-bundle.js
@ -0,0 +1,27 @@
+'use strict'
+
+const WebRTCStar = require('libp2p-webrtc-star')
+const multiplex = require('libp2p-multiplex')
+const spdy = require('libp2p-spdy')
+const secio = require('libp2p-secio')
+const libp2p = require('../../..')
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+    const wstar = new WebRTCStar()
+
+    const modules = {
+      transport: [wstar],
+      connection: {
+        muxer: [multiplex, spdy],
+        crypto: [secio]
+      },
+      discovery: [wstar.discovery]
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node
--- a/gulpfile.js
+++ b/gulpfile.js
@ -0,0 +1,55 @@
+'use strict'
+
+const gulp = require('gulp')
+const Node = require('./test/nodejs-bundle/nodejs-bundle.js')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const pull = require('pull-stream')
+
+const sigServer = require('libp2p-webrtc-star/src/sig-server')
+let server
+
+let node
+const rawPeer = require('./test/browser-bundle/peer.json')
+
+gulp.task('libnode:start', (done) => {
+  let count = 0
+  const ready = () => ++count === 2 ? done() : null
+
+  sigServer.start({ port: 15555 }, (err, _server) => {
+    if (err) {
+      throw err
+    }
+    server = _server
+    ready()
+  })
+
+  PeerId.createFromJSON(rawPeer, (err, peerId) => {
+    if (err) {
+      return done(err)
+    }
+    const peer = new PeerInfo(peerId)
+
+    peer.multiaddrs.add('/ip4/127.0.0.1/tcp/9200/ws')
+
+    node = new Node(peer)
+    node.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+    node.start(() => ready())
+  })
+})
+
+gulp.task('libnode:stop', (done) => {
+  setTimeout(() => node.stop((err) => {
+    if (err) {
+      return done(err)
+    }
+    server.stop(done)
+  }), 2000)
+})
+
+gulp.task('test:browser:before', ['libnode:start'])
+gulp.task('test:node:before', ['libnode:start'])
+gulp.task('test:browser:after', ['libnode:stop'])
+gulp.task('test:node:after', ['libnode:stop'])
+
+require('aegir/gulp')(gulp)
--- a/img/js-libp2p-ipfs-browser.png
+++ b/img/js-libp2p-ipfs-browser.png
--- a/img/js-libp2p-ipfs.png
+++ b/img/js-libp2p-ipfs.png
--- a/img/js-libp2p.png
+++ b/img/js-libp2p.png
--- a/img/libp2p-arch.png
+++ b/img/libp2p-arch.png
--- a/img/libp2p-logos.sketch
+++ b/img/libp2p-logos.sketch
--- a/package.json
+++ b/package.json
@ -1,32 +1,82 @@
 {
  "name": "libp2p",
-  "version": "0.1.1",
-  "description": "Node.js implementation of libp2p",
+  "version": "0.10.0",
+  "description": "JavaScript Skeleton for libp2p bundles",
  "main": "src/index.js",
  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "gulp test",
+    "test:node": "gulp test:node",
+    "test:browser": "gulp test:browser --dom",
+    "release": "gulp release --dom",
+    "release-minor": "gulp release --type minor --dom",
+    "release-major": "gulp release --type major --dom",
+    "build": "gulp build",
+    "lint": "aegir-lint",
+    "coverage": "aegir-coverage",
+    "coverage-publish": "aegir-coverage publish"
  },
  "repository": {
    "type": "git",
-    "url": "https://github.com/diasdavid/js-libp2p.git"
+    "url": "https://github.com/libp2p/js-libp2p.git"
  },
  "keywords": [
    "IPFS"
  ],
  "engines": {
-    "node": "^4.0.0"
+    "node": ">=4.0.0",
+    "npm": ">=3.0.0"
  },
-  "pre-commit": [],
+  "pre-commit": [
+    "lint",
+    "test"
+  ],
  "author": "David Dias <daviddias@ipfs.io>",
  "license": "MIT",
  "bugs": {
-    "url": "https://github.com/diasdavid/js-libp2p/issues"
+    "url": "https://github.com/libp2p/js-libp2p/issues"
  },
-  "homepage": "https://github.com/diasdavid/js-libp2p",
+  "homepage": "https://github.com/libp2p/js-libp2p",
  "devDependencies": {
-    "code": "^1.5.0",
-    "lab": "^5.17.0",
-    "pre-commit": "^1.1.1",
-    "standard": "^5.3.1"
-  }
+    "aegir": "^11.0.2",
+    "chai": "^4.0.2",
+    "cids": "^0.5.0",
+    "dirty-chai": "^2.0.0",
+    "electron-webrtc": "^0.3.0",
+    "libp2p-kad-dht": "^0.2.0",
+    "libp2p-mdns": "^0.7.0",
+    "libp2p-multiplex": "^0.4.3",
+    "libp2p-railing": "^0.5.1",
+    "libp2p-secio": "^0.6.8",
+    "libp2p-spdy": "^0.10.6",
+    "libp2p-swarm": "^0.29.1",
+    "libp2p-tcp": "^0.10.1",
+    "libp2p-webrtc-star": "^0.11.0",
+    "libp2p-websockets": "^0.10.0",
+    "lodash.times": "^4.3.2",
+    "mafmt": "^2.1.8",
+    "pre-commit": "^1.2.2",
+    "pull-goodbye": "0.0.2",
+    "pull-serializer": "^0.3.2",
+    "pull-stream": "^3.6.0",
+    "safe-buffer": "^5.1.1",
+    "wrtc": "0.0.62"
+  },
+  "dependencies": {
+    "async": "^2.5.0",
+    "libp2p-ping": "~0.3.2",
+    "libp2p-swarm": "~0.29.1",
+    "mafmt": "^2.1.8",
+    "multiaddr": "^2.3.0",
+    "peer-book": "~0.4.0",
+    "peer-id": "~0.8.7",
+    "peer-info": "~0.9.2"
+  },
+  "contributors": [
+    "David Dias <daviddias.p@gmail.com>",
+    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "Pedro Teixeira <i@pgte.me>",
+    "Richard Littauer <richard.littauer@gmail.com>",
+    "greenkeeperio-bot <support@greenkeeper.io>",
+    "mayerwin <mayerwin@users.noreply.github.com>"
+  ]
 }
--- a/src/index.js
+++ b/src/index.js
@ -1,18 +1,321 @@
+'use strict'

-exports = module.exports = Libp2p
+const EventEmitter = require('events').EventEmitter
+const assert = require('assert')

-function Libp2p (swarm, peerRouting, recordStore) {
-  var self = this
+const setImmediate = require('async/setImmediate')
+const each = require('async/each')
+const series = require('async/series')

-  if (!(self instanceof Libp2p)) {
-    throw new Error('Must be called with new')
+const Ping = require('libp2p-ping')
+const Swarm = require('libp2p-swarm')
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const PeerBook = require('peer-book')
+const mafmt = require('mafmt')
+const multiaddr = require('multiaddr')
+
+exports = module.exports
+
+const NOT_STARTED_ERROR_MESSAGE = 'The libp2p node is not started yet'
+
+class Node extends EventEmitter {
+  constructor (_modules, _peerInfo, _peerBook, _options) {
+    super()
+    assert(_modules, 'requires modules to equip libp2p with features')
+    assert(_peerInfo, 'requires a PeerInfo instance')
+
+    this.modules = _modules
+    this.peerInfo = _peerInfo
+    this.peerBook = _peerBook || new PeerBook()
+    this._isStarted = false
+
+    this.swarm = new Swarm(this.peerInfo, this.peerBook)
+
+    // Attach stream multiplexers
+    if (this.modules.connection.muxer) {
+      let muxers = this.modules.connection.muxer
+      muxers = Array.isArray(muxers) ? muxers : [muxers]
+      muxers.forEach((muxer) => this.swarm.connection.addStreamMuxer(muxer))
+
+      // If muxer exists, we can use Identify
+      this.swarm.connection.reuse()
+
+      // Received incommind dial and muxer upgrade happened,
+      // reuse this muxed connection
+      this.swarm.on('peer-mux-established', (peerInfo) => {
+        this.emit('peer:connect', peerInfo)
+        this.peerBook.put(peerInfo)
+      })
+
+      this.swarm.on('peer-mux-closed', (peerInfo) => {
+        this.emit('peer:disconnect', peerInfo)
+      })
+    }
+
+    // Attach crypto channels
+    if (this.modules.connection.crypto) {
+      let cryptos = this.modules.connection.crypto
+      cryptos = Array.isArray(cryptos) ? cryptos : [cryptos]
+      cryptos.forEach((crypto) => {
+        this.swarm.connection.crypto(crypto.tag, crypto.encrypt)
+      })
+    }
+
+    // Attach discovery mechanisms
+    if (this.modules.discovery) {
+      let discoveries = this.modules.discovery
+      discoveries = Array.isArray(discoveries) ? discoveries : [discoveries]
+
+      discoveries.forEach((discovery) => {
+        discovery.on('peer', (peerInfo) => this.emit('peer:discovery', peerInfo))
+      })
+    }
+
+    // Mount default protocols
+    Ping.mount(this.swarm)
+
+    // dht provided components (peerRouting, contentRouting, dht)
+    if (_modules.DHT) {
+      this._dht = new this.modules.DHT(this, 20, _options.DHT && _options.DHT.datastore)
+    }
+
+    this.peerRouting = {
+      findPeer: (id, callback) => {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.findPeer(id, callback)
+      }
+    }
+
+    this.contentRouting = {
+      findProviders: (key, timeout, callback) => {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.findProviders(key, timeout, callback)
+      },
+      provide: (key, callback) => {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.provide(key, callback)
+      }
+    }
+
+    this.dht = {
+      put: (key, value, callback) => {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.put(key, value, callback)
+      },
+      get: (key, callback) => {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.get(key, callback)
+      },
+      getMany (key, nVals, callback) {
+        if (!this._dht) {
+          return callback(new Error('DHT is not available'))
+        }
+
+        this._dht.getMany(key, nVals, callback)
+      }
+    }
  }

-  if (!swarm) {
-    throw new Error('a swarm must be passed')
+  /*
+   * Start the libp2p node
+   *   - create listeners on the multiaddrs the Peer wants to listen
+   */
+  start (callback) {
+    if (!this.modules.transport) {
+      return callback(new Error('no transports were present'))
+    }
+
+    let ws
+    let transports = this.modules.transport
+
+    transports = Array.isArray(transports) ? transports : [transports]
+
+    // so that we can have webrtc-star addrs without adding manually the id
+    const maOld = []
+    const maNew = []
+    this.peerInfo.multiaddrs.forEach((ma) => {
+      if (!mafmt.IPFS.matches(ma)) {
+        maOld.push(ma)
+        maNew.push(ma.encapsulate('/ipfs/' + this.peerInfo.id.toB58String()))
+      }
+    })
+    this.peerInfo.multiaddrs.replace(maOld, maNew)
+    const multiaddrs = this.peerInfo.multiaddrs.toArray()
+
+    transports.forEach((transport) => {
+      if (transport.filter(multiaddrs).length > 0) {
+        this.swarm.transport.add(
+          transport.tag || transport.constructor.name, transport)
+      } else if (transport.constructor &&
+                 transport.constructor.name === 'WebSockets') {
+        // TODO find a cleaner way to signal that a transport is always
+        // used for dialing, even if no listener
+        ws = transport
+      }
+    })
+
+    series([
+      (cb) => this.swarm.listen(cb),
+      (cb) => {
+        if (ws) {
+          // always add dialing on websockets
+          this.swarm.transport.add(ws.tag || ws.constructor.name, ws)
+        }
+
+        // all transports need to be setup before discover starts
+        if (this.modules.discovery) {
+          return each(this.modules.discovery, (d, cb) => d.start(cb), cb)
+        }
+        cb()
+      },
+      (cb) => {
+        // TODO: chicken-and-egg problem:
+        // have to set started here because DHT requires libp2p is already started
+        this._isStarted = true
+        if (this._dht) {
+          return this._dht.start(cb)
+        }
+        cb()
+      },
+      (cb) => {
+        this.emit('start')
+        cb()
+      }
+    ], callback)
  }

-  self.swarm = swarm
-  self.routing = peerRouting
-  self.record = recordStore
+  /*
+   * Stop the libp2p node by closing its listeners and open connections
+   */
+  stop (callback) {
+    this._isStarted = false
+
+    if (this.modules.discovery) {
+      this.modules.discovery.forEach((discovery) => {
+        setImmediate(() => discovery.stop(() => {}))
+      })
+    }
+
+    series([
+      (cb) => {
+        if (this._dht) {
+          return this._dht.stop(cb)
+        }
+        cb()
+      },
+      (cb) => this.swarm.close(cb),
+      (cb) => {
+        this.emit('stop')
+        cb()
+      }
+    ], callback)
+  }
+
+  isStarted () {
+    return this._isStarted
+  }
+
+  ping (peer, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      callback(null, new Ping(this.swarm, peerInfo))
+    })
+  }
+
+  dial (peer, protocol, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
+
+    if (typeof protocol === 'function') {
+      callback = protocol
+      protocol = undefined
+    }
+
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      this.swarm.dial(peerInfo, protocol, (err, conn) => {
+        if (err) {
+          return callback(err)
+        }
+        this.peerBook.put(peerInfo)
+        callback(null, conn)
+      })
+    })
+  }
+
+  hangUp (peer, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
+
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      this.swarm.hangUp(peerInfo, callback)
+    })
+  }
+
+  handle (protocol, handlerFunc, matchFunc) {
+    this.swarm.handle(protocol, handlerFunc, matchFunc)
+  }
+
+  unhandle (protocol) {
+    this.swarm.unhandle(protocol)
+  }
+
+  /*
+   * Helper method to check the data type of peer and convert it to PeerInfo
+   */
+  _getPeerInfo (peer, callback) {
+    let p
+    // PeerInfo
+    if (PeerInfo.isPeerInfo(peer)) {
+      p = peer
+    // Multiaddr instance (not string)
+    } else if (multiaddr.isMultiaddr(peer)) {
+      const peerIdB58Str = peer.getPeerId()
+      try {
+        p = this.peerBook.get(peerIdB58Str)
+      } catch (err) {
+        p = new PeerInfo(PeerId.createFromB58String(peerIdB58Str))
+      }
+      p.multiaddrs.add(peer)
+    // PeerId
+    } else if (PeerId.isPeerId(peer)) {
+      const peerIdB58Str = peer.toB58String()
+      try {
+        p = this.peerBook.get(peerIdB58Str)
+      } catch (err) {
+        return this.peerRouting.findPeer(peer, callback)
+      }
+    } else {
+      return setImmediate(() => callback(new Error('peer type not recognized')))
+    }
+
+    setImmediate(() => callback(null, p))
+  }
 }
+
+module.exports = Node
--- a/test/base.js
+++ b/test/base.js
@ -0,0 +1,14 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+
+const libp2p = require('../src')
+
+describe('libp2p', () => {
+  it('the skeleton is fine, now go build your own libp2p bundle', () => {
+    expect(libp2p).to.exist()
+  })
+})
--- a/test/browser-bundle/browser-bundle.js
+++ b/test/browser-bundle/browser-bundle.js
@ -0,0 +1,67 @@
+'use strict'
+
+const WS = require('libp2p-websockets')
+const WebRTCStar = require('libp2p-webrtc-star')
+const spdy = require('libp2p-spdy')
+const multiplex = require('libp2p-multiplex')
+const secio = require('libp2p-secio')
+const Railing = require('libp2p-railing')
+const libp2p = require('../..')
+
+function mapMuxers (list) {
+  return list.map((pref) => {
+    if (typeof pref !== 'string') {
+      return pref
+    }
+    switch (pref.trim().toLowerCase()) {
+      case 'spdy':
+        return spdy
+      case 'multiplex':
+        return multiplex
+      default:
+        throw new Error(pref + ' muxer not available')
+    }
+  })
+}
+
+function getMuxers (options) {
+  if (options) {
+    return mapMuxers(options)
+  } else {
+    return [multiplex, spdy]
+  }
+}
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+    const webRTCStar = new WebRTCStar()
+
+    const modules = {
+      transport: [
+        new WS(),
+        webRTCStar
+      ],
+      connection: {
+        muxer: getMuxers(options.muxer),
+        crypto: [
+          secio
+        ]
+      },
+      discovery: []
+    }
+
+    if (options.webRTCStar) {
+      modules.discovery.push(webRTCStar.discovery)
+    }
+
+    if (options.bootstrap) {
+      const r = new Railing(options.bootstrap)
+      modules.discovery.push(r)
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node
--- a/test/browser-bundle/peer.json
+++ b/test/browser-bundle/peer.json
@ -0,0 +1,5 @@
+{
+  "id": "Qmex1SSsueWFsUfjdkugJ5zhcnjddAt8TxcnDLUXKD9Sx7",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQCXzV127CvVHOGMzvsn/U+/32JM58KA6k0FSCCeNFzNowiDS/vV5eezGN5AFoxsF6icWLoaczz7l9RdVD+I/t6PEt9X7XUdrDCtSS8WmAcCgvZWSSf7yAd3jT4GSZDUIgIEeRZsERDt/yVqTLwsZ1G9dMIeh8sbf2zwjTXZIWaRM6o4lq3DYFfzLvJUXlJodxPogU7l7nLkITPUv+yQAMcVHizbNwJvwiETKYeUj73/m/wEPAlnFESexDstxNiIwE/FH8Ao50QPZRO6E6Jb0hhYSI/4CLRdrzDFm/Vzplei3Wr2DokSROaNyeG37VAueyA+pDqn84um+L9uXLwbv5FbAgMBAAECggEAdBUzV/GaQ0nmoQrWvOnUxmFIho7kCjkh1NwnNVPNc+Msa1r7pcI9wJNPwap8j1w4L/cZuYhOJgcg+o2mWFiuULKZ4F9Ro/M89gZ038457g2/2pPu43c/Xoi/2YcAHXg0Gr+OCe2zCIyITBWKAFqyAzL6DubAxrJW2Ezj1LrZ+EZgMyzbh/go/eEGSJaaGkINeAkY144DqDWWWvzyhKhryipsGkZGEkVy9xJgMEI3ipVvuPez2XAvoyyeuinBBLe+Z2vY5G50XXzbIMhIQGLncHf9MwTv6wt1ilyOSLOXK0BoQbB76J3R3is5dSULXXP9r8VocjLBEkmBuf4FXAKzoQKBgQDNNS4F1XE1gxD8LPkL+aB/hi6eVHVPhr+w0I/9ATikcLGeUfBM2Gd6cZRPFtNVrv1p6ZF1D1UyGDknGbDBSQd9wLUgb0fDoo3jKYMGWq6G+VvaP5rzWQeBV8YV2EhSmUk1i6kiYe2ZE8WyrPie7iwpQIY60e2A8Ly0GKZiBZUcHQKBgQC9YDAVsGnEHFVFkTDpvw5HwEzCgTb2A3NgkGY3rTYZ7L6AFjqCYmUwFB8Fmbyc4kdFWNh8wfmq5Qrvl49NtaeukiqWKUUlB8uPdztB1P0IahA2ks0owStZlRifmwfgYyMd4xE17lhaOgQQJZZPxmP0F6mdOvb3YJafNURCdMS51wKBgEvvIM+h0tmFXXSjQ6kNvzlRMtD92ccKysYn9xAdMpOO6/r0wSH+dhQWEVZO0PcE4NsfReb2PIVj90ojtIdhebcr5xpQc1LORQjJJKXmSmzBux6AqNrhl+hhzXfp56FA/Zkly/lgGWaqrV5XqUxOP+Mn8EO1yNgMvRc7g94DyNB1AoGBAKLBuXHalXwDsdHBUB2Eo3xNLGt6bEcRfia+0+sEBdxQGQWylQScFkU09dh1YaIf44sZKa5HdBFJGpYCVxo9hmjFnK5Dt/Z0daHOonIY4INLzLVqg8KECoLKXkhGEIXsDjFQhukn+G1LMVTDSSU055DQiWjlVX4UWD9qo0jOXIkvAoGBAMP50p2X6PsWWZUuuR7i1JOJHRyQZPWdHh9p8SSLnCtEpHYZfJr4INXNmhnSiB/3TUnHix2vVKjosjMTCk/CjfzXV2H41WPOLZ2/Pi3SxCicWIRj4kCcWhkEuIF2jGkg1+jmNiCl/zNMaBOAIP3QbDPtqOWbYlPd2YIzdj6WQ6R4",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCXzV127CvVHOGMzvsn/U+/32JM58KA6k0FSCCeNFzNowiDS/vV5eezGN5AFoxsF6icWLoaczz7l9RdVD+I/t6PEt9X7XUdrDCtSS8WmAcCgvZWSSf7yAd3jT4GSZDUIgIEeRZsERDt/yVqTLwsZ1G9dMIeh8sbf2zwjTXZIWaRM6o4lq3DYFfzLvJUXlJodxPogU7l7nLkITPUv+yQAMcVHizbNwJvwiETKYeUj73/m/wEPAlnFESexDstxNiIwE/FH8Ao50QPZRO6E6Jb0hhYSI/4CLRdrzDFm/Vzplei3Wr2DokSROaNyeG37VAueyA+pDqn84um+L9uXLwbv5FbAgMBAAE="
+}
--- a/test/browser-bundle/webrtc-star-only.js
+++ b/test/browser-bundle/webrtc-star-only.js
@ -0,0 +1,121 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+const Node = require('./browser-bundle')
+
+describe('libp2p-ipfs-browser (webrtc only)', () => {
+  let peer1
+  let peer2
+  let node1
+  let node2
+
+  it('create two peerInfo with webrtc-star addrs', (done) => {
+    parallel([
+      (cb) => PeerId.create({ bits: 1024 }, cb),
+      (cb) => PeerId.create({ bits: 1024 }, cb)
+    ], (err, ids) => {
+      expect(err).to.not.exist()
+
+      peer1 = new PeerInfo(ids[0])
+      const ma1 = '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + ids[0].toB58String()
+      peer1.multiaddrs.add(ma1)
+
+      peer2 = new PeerInfo(ids[1])
+      const ma2 = '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + ids[1].toB58String()
+      peer2.multiaddrs.add(ma2)
+
+      done()
+    })
+  })
+
+  it('create two libp2p nodes with those peers', (done) => {
+    node1 = new Node(peer1, null, { webRTCStar: true })
+    node2 = new Node(peer2, null, { webRTCStar: true })
+    done()
+  })
+
+  it('listen on the two libp2p nodes', (done) => {
+    parallel([
+      (cb) => node1.start(cb),
+      (cb) => node2.start(cb)
+    ], done)
+  })
+
+  it('handle a protocol on the first node', () => {
+    node2.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+  })
+
+  it('dial from the second node to the first node', (done) => {
+    node1.dial(peer2, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        const text = 'hello'
+        const peers1 = node1.peerBook.getAll()
+        expect(Object.keys(peers1)).to.have.length(1)
+
+        const peers2 = node2.peerBook.getAll()
+        expect(Object.keys(peers2)).to.have.length(1)
+
+        pull(
+          pull.values([Buffer(text)]),
+          conn,
+          pull.collect((err, data) => {
+            expect(err).to.not.exist()
+            expect(data[0].toString()).to.equal(text)
+            done()
+          })
+        )
+      }
+    })
+  })
+
+  it('node1 hangUp node2', (done) => {
+    node1.hangUp(peer2, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        const peers = node1.peerBook.getAll()
+        expect(Object.keys(peers)).to.have.length(1)
+        expect(Object.keys(node1.swarm.muxedConns)).to.have.length(0)
+        done()
+      }
+    })
+  })
+
+  it('create a third node and check that discovery works', (done) => {
+    let counter = 0
+
+    function check () {
+      if (++counter === 3) {
+        expect(Object.keys(node1.swarm.muxedConns).length).to.equal(1)
+        expect(Object.keys(node2.swarm.muxedConns).length).to.equal(1)
+        done()
+      }
+    }
+
+    PeerId.create((err, id3) => {
+      expect(err).to.not.exist()
+
+      const peer3 = new PeerInfo(id3)
+      const ma3 = '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + id3.toB58String()
+      peer3.multiaddrs.add(ma3)
+
+      node1.on('peer:discovery', (peerInfo) => node1.dial(peerInfo, check))
+      node2.on('peer:discovery', (peerInfo) => node2.dial(peerInfo, check))
+
+      const node3 = new Node(peer3, null, { webRTCStar: true })
+      node3.start(check)
+    })
+  })
+})
--- a/test/browser-bundle/websockets-only.js
+++ b/test/browser-bundle/websockets-only.js
@ -0,0 +1,201 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const pull = require('pull-stream')
+const goodbye = require('pull-goodbye')
+const serializer = require('pull-serializer')
+const Buffer = require('safe-buffer').Buffer
+
+const Node = require('./browser-bundle')
+const rawPeer = require('./peer.json')
+
+describe('libp2p-ipfs-browser (websockets only)', () => {
+  let peerB
+  let nodeA
+
+  before((done) => {
+    const ma = '/ip4/127.0.0.1/tcp/9200/ws/ipfs/' + rawPeer.id
+
+    PeerId.createFromPrivKey(rawPeer.privKey, (err, id) => {
+      if (err) {
+        return done(err)
+      }
+
+      peerB = new PeerInfo(id)
+      peerB.multiaddrs.add(ma)
+      done()
+    })
+  })
+
+  after((done) => nodeA.stop(done))
+
+  it('create libp2pNode', (done) => {
+    PeerInfo.create((err, peerInfo) => {
+      expect(err).to.not.exist()
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+
+      nodeA = new Node(peerInfo)
+      done()
+    })
+  })
+
+  it('create libp2pNode with multiplex only', (done) => {
+    PeerInfo.create((err, peerInfo) => {
+      expect(err).to.not.exist()
+
+      const b = new Node(peerInfo, null, { muxer: ['multiplex'] })
+      expect(b.modules.connection.muxer).to.eql([require('libp2p-multiplex')])
+      done()
+    })
+  })
+
+  it('start libp2pNode', (done) => {
+    nodeA.start(done)
+  })
+
+  // General connectivity tests
+
+  it('libp2p.dial using Multiaddr nodeA to nodeB', (done) => {
+    nodeA.dial(peerB.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+
+      setTimeout(check, 500) // Some time for Identify to finish
+
+      function check () {
+        const peers = nodeA.peerBook.getAll()
+        expect(Object.keys(peers)).to.have.length(1)
+        done()
+      }
+    })
+  })
+
+  it('libp2p.dial using Multiaddr on Protocol nodeA to nodeB', (done) => {
+    nodeA.dial(peerB.multiaddrs.toArray()[0], '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+
+      const peers = nodeA.peerBook.getAll()
+      expect(Object.keys(peers)).to.have.length(1)
+
+      pull(
+        pull.values([Buffer.from('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.eql([Buffer.from('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('libp2p.hangUp using Multiaddr nodeA to nodeB', (done) => {
+    nodeA.hangUp(peerB.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+
+      setTimeout(check, 500)
+
+      function check () {
+        const peers = nodeA.peerBook.getAll()
+        expect(Object.keys(peers)).to.have.length(1)
+        expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+        done()
+      }
+    })
+  })
+
+  it('libp2p.dial using PeerInfo nodeA to nodeB', (done) => {
+    nodeA.dial(peerB, (err) => {
+      expect(err).to.not.exist()
+
+      setTimeout(check, 500) // Some time for Identify to finish
+
+      function check () {
+        const peers = nodeA.peerBook.getAll()
+        expect(Object.keys(peers)).to.have.length(1)
+        done()
+      }
+    })
+  })
+
+  it('libp2p.dial using PeerInfo on Protocol nodeA to nodeB', (done) => {
+    nodeA.dial(peerB, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+      const peers = nodeA.peerBook.getAll()
+      expect(err).to.not.exist()
+      expect(Object.keys(peers)).to.have.length(1)
+
+      pull(
+        pull.values([Buffer.from('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.eql([Buffer.from('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('libp2p.hangUp using PeerInfo nodeA to nodeB', (done) => {
+    nodeA.hangUp(peerB, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        const peers = nodeA.peerBook.getAll()
+        expect(err).to.not.exist()
+        expect(Object.keys(peers)).to.have.length(1)
+        expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+        done()
+      }
+    })
+  })
+
+  describe('stress', () => {
+    it('one big write', (done) => {
+      nodeA.dial(peerB, '/echo/1.0.0', (err, conn) => {
+        expect(err).to.not.exist()
+        const rawMessage = Buffer.alloc(100000)
+        rawMessage.fill('a')
+
+        const s = serializer(goodbye({
+          source: pull.values([rawMessage]),
+          sink: pull.collect((err, results) => {
+            expect(err).to.not.exist()
+            expect(results).to.have.length(1)
+            expect(Buffer.from(results[0])).to.have.length(rawMessage.length)
+            done()
+          })
+        }))
+        pull(s, conn, s)
+      })
+    })
+
+    it('many writes', (done) => {
+      nodeA.dial(peerB, '/echo/1.0.0', (err, conn) => {
+        expect(err).to.not.exist()
+
+        const s = serializer(goodbye({
+          source: pull(
+            pull.infinite(),
+            pull.take(1000),
+            pull.map((val) => Buffer.from(val.toString()))
+          ),
+          sink: pull.collect((err, result) => {
+            expect(err).to.not.exist()
+            expect(result).to.have.length(1000)
+            done()
+          })
+        }))
+
+        pull(s, conn, s)
+      })
+    })
+  })
+})
--- a/test/browser.js
+++ b/test/browser.js
@ -0,0 +1,7 @@
+'use strict'
+
+const w = require('webrtcsupport')
+
+require('./base')
+require('./browser-bundle/websockets-only')
+if (w.support) { require('./browser-bundle/webrtc-star-only') }
--- a/test/node.js
+++ b/test/node.js
@ -0,0 +1,10 @@
+'use strict'
+
+require('./base')
+require('./nodejs-bundle/tcp')
+require('./nodejs-bundle/tcp+websockets')
+require('./nodejs-bundle/tcp+websockets+webrtc-star')
+require('./nodejs-bundle/stream-muxing')
+require('./nodejs-bundle/discovery')
+require('./nodejs-bundle/peer-routing')
+require('./nodejs-bundle/content-routing')
--- a/test/nodejs-bundle/content-routing.js
+++ b/test/nodejs-bundle/content-routing.js
@ -0,0 +1,90 @@
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ["error", 8] */
+
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const _times = require('lodash.times')
+const CID = require('cids')
+
+describe('.contentRouting', () => {
+  let nodeA
+  let nodeB
+  let nodeC
+  let nodeD
+  let nodeE
+
+  before((done) => {
+    const tasks = _times(5, () => (cb) => {
+      createNode('/ip4/0.0.0.0/tcp/0', {
+        mdns: false,
+        dht: true
+      }, (err, node) => {
+        expect(err).to.not.exist()
+        node.start((err) => cb(err, node))
+      })
+    })
+
+    parallel(tasks, (err, nodes) => {
+      expect(err).to.not.exist()
+      nodeA = nodes[0]
+      nodeB = nodes[1]
+      nodeC = nodes[2]
+      nodeD = nodes[3]
+      nodeE = nodes[4]
+
+      parallel([
+        (cb) => nodeA.dial(nodeB.peerInfo, cb),
+        (cb) => nodeB.dial(nodeC.peerInfo, cb),
+        (cb) => nodeC.dial(nodeD.peerInfo, cb),
+        (cb) => nodeD.dial(nodeE.peerInfo, cb),
+        (cb) => nodeE.dial(nodeA.peerInfo, cb)
+      ], done)
+    })
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb),
+      (cb) => nodeC.stop(cb),
+      (cb) => nodeD.stop(cb),
+      (cb) => nodeE.stop(cb)
+    ], done)
+  })
+
+  describe('le ring', () => {
+    const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
+
+    it('let kbucket get filled', (done) => {
+      setTimeout(() => done(), 250)
+    })
+
+    it('nodeA.contentRouting.provide', (done) => {
+      nodeA.contentRouting.provide(cid, done)
+    })
+
+    it('nodeE.contentRouting.findProviders for existing record', (done) => {
+      nodeE.contentRouting.findProviders(cid, 5000, (err, providers) => {
+        expect(err).to.not.exist()
+        expect(providers).to.have.length.above(0)
+        done()
+      })
+    })
+
+    it('nodeC.contentRouting.findProviders for non existing record (timeout)', (done) => {
+      const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSnnnn')
+
+      nodeE.contentRouting.findProviders(cid, 5000, (err, providers) => {
+        expect(err).to.not.exist()
+        expect(providers).to.have.length(0)
+        done()
+      })
+    })
+  })
+})
--- a/test/nodejs-bundle/discovery.js
+++ b/test/nodejs-bundle/discovery.js
@ -0,0 +1,99 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const signalling = require('libp2p-webrtc-star/src/sig-server')
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('discovery', () => {
+  let nodeA
+  let nodeB
+  let port = 24642
+  let ss
+
+  function setup (options) {
+    before((done) => {
+      port++
+      parallel([
+        (cb) => {
+          signalling.start({ port: port }, (err, server) => {
+            expect(err).to.not.exist()
+            ss = server
+            cb()
+          })
+        },
+        (cb) => createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          `/libp2p-webrtc-star/ip4/127.0.0.1/tcp/${port}/ws`
+        ], options, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          `/libp2p-webrtc-star/ip4/127.0.0.1/tcp/${port}/ws`
+        ], options, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], done)
+    })
+
+    after((done) => {
+      parallel([
+        (cb) => nodeA.stop(cb),
+        (cb) => nodeB.stop(cb),
+        (cb) => ss.stop(done)
+      ], done)
+    })
+  }
+
+  describe('MulticastDNS', () => {
+    setup({ mdns: true })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+
+  // TODO needs a delay (this test is already long)
+  describe.skip('WebRTCStar', () => {
+    setup({ webRTCStar: true })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+
+  describe('MulticastDNS + WebRTCStar', () => {
+    setup({
+      webRTCStar: true,
+      mdns: true
+    })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+})
--- a/test/nodejs-bundle/nodejs-bundle.js
+++ b/test/nodejs-bundle/nodejs-bundle.js
@ -0,0 +1,80 @@
+'use strict'
+
+const TCP = require('libp2p-tcp')
+const MulticastDNS = require('libp2p-mdns')
+const WS = require('libp2p-websockets')
+const Railing = require('libp2p-railing')
+const spdy = require('libp2p-spdy')
+const KadDHT = require('libp2p-kad-dht')
+const multiplex = require('libp2p-multiplex')
+const secio = require('libp2p-secio')
+const libp2p = require('../..')
+
+function mapMuxers (list) {
+  return list.map((pref) => {
+    if (typeof pref !== 'string') {
+      return pref
+    }
+    switch (pref.trim().toLowerCase()) {
+      case 'spdy': return spdy
+      case 'multiplex': return multiplex
+      default:
+        throw new Error(pref + ' muxer not available')
+    }
+  })
+}
+
+function getMuxers (muxers) {
+  const muxerPrefs = process.env.LIBP2P_MUXER
+  if (muxerPrefs && !muxers) {
+    return mapMuxers(muxerPrefs.split(','))
+  } else if (muxers) {
+    return mapMuxers(muxers)
+  } else {
+    return [multiplex, spdy]
+  }
+}
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: getMuxers(options.muxer),
+        crypto: [ secio ]
+      },
+      discovery: []
+    }
+
+    if (options.dht) {
+      modules.DHT = KadDHT
+    }
+
+    if (options.mdns) {
+      const mdns = new MulticastDNS(peerInfo, 'ipfs.local')
+      modules.discovery.push(mdns)
+    }
+
+    if (options.bootstrap) {
+      const r = new Railing(options.bootstrap)
+      modules.discovery.push(r)
+    }
+
+    if (options.modules && options.modules.transport) {
+      options.modules.transport.forEach((t) => modules.transport.push(t))
+    }
+
+    if (options.modules && options.modules.discovery) {
+      options.modules.discovery.forEach((d) => modules.discovery.push(d))
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node
--- a/test/nodejs-bundle/peer-routing.js
+++ b/test/nodejs-bundle/peer-routing.js
@ -0,0 +1,94 @@
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ["error", 8] */
+
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const _times = require('lodash.times')
+
+describe('.peerRouting', () => {
+  let nodeA
+  let nodeB
+  let nodeC
+  let nodeD
+  let nodeE
+
+  before((done) => {
+    const tasks = _times(5, () => (cb) => {
+      createNode('/ip4/0.0.0.0/tcp/0', {
+        mdns: false,
+        dht: true
+      }, (err, node) => {
+        expect(err).to.not.exist()
+        node.start((err) => cb(err, node))
+      })
+    })
+
+    parallel(tasks, (err, nodes) => {
+      expect(err).to.not.exist()
+      nodeA = nodes[0]
+      nodeB = nodes[1]
+      nodeC = nodes[2]
+      nodeD = nodes[3]
+      nodeE = nodes[4]
+
+      parallel([
+        (cb) => nodeA.dial(nodeB.peerInfo, cb),
+        (cb) => nodeB.dial(nodeC.peerInfo, cb),
+        (cb) => nodeC.dial(nodeD.peerInfo, cb),
+        (cb) => nodeD.dial(nodeE.peerInfo, cb),
+        (cb) => nodeE.dial(nodeA.peerInfo, cb)
+      ], done)
+    })
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb),
+      (cb) => nodeC.stop(cb),
+      (cb) => nodeD.stop(cb),
+      (cb) => nodeE.stop(cb)
+    ], done)
+  })
+
+  describe('el ring', () => {
+    it('let kbucket get filled', (done) => {
+      setTimeout(() => done(), 250)
+    })
+
+    it('nodeA.dial by Id to node C', (done) => {
+      nodeA.dial(nodeC.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeB.dial by Id to node D', (done) => {
+      nodeB.dial(nodeD.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeC.dial by Id to node E', (done) => {
+      nodeC.dial(nodeE.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeB.peerRouting.findPeer(nodeE.peerInfo.id)', (done) => {
+      nodeB.peerRouting.findPeer(nodeE.peerInfo.id, (err, peerInfo) => {
+        expect(err).to.not.exist()
+        expect(nodeE.peerInfo.id.toB58String()).to.equal(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+})
--- a/test/nodejs-bundle/spawn-libp2p-node.js
+++ b/test/nodejs-bundle/spawn-libp2p-node.js
@ -0,0 +1,30 @@
+#! /usr/bin/env node
+
+'use strict'
+
+const Node = require('./nodejs-bundle')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const pull = require('pull-stream')
+
+const idBak = require('./test-data/test-id.json')
+
+PeerId.createFromJSON(idBak, (err, peerId) => {
+  if (err) {
+    throw err
+  }
+
+  const peerInfo = new PeerInfo(peerId)
+
+  peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/12345')
+
+  const node = new Node(peerInfo)
+
+  node.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+
+  node.start((err) => {
+    if (err) { throw err }
+
+    console.log('Spawned node started, env:', process.env.LIBP2P_MUXER)
+  })
+})
--- a/test/nodejs-bundle/stream-muxing.js
+++ b/test/nodejs-bundle/stream-muxing.js
@ -0,0 +1,207 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+function test (nodeA, nodeB, callback) {
+  nodeA.dial(nodeB.peerInfo, '/echo/1.0.0', (err, conn) => {
+    expect(err).to.not.exist()
+
+    pull(
+      pull.values([new Buffer('hey')]),
+      conn,
+      pull.collect((err, data) => {
+        expect(err).to.not.exist()
+        expect(data).to.be.eql([new Buffer('hey')])
+        callback()
+      })
+    )
+  })
+}
+
+function teardown (nodeA, nodeB, callback) {
+  parallel([
+    (cb) => nodeA.stop(cb),
+    (cb) => nodeB.stop(cb)
+  ], callback)
+}
+
+describe('stream muxing', (done) => {
+  it('spdy only', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('multiplex only', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('spdy + multiplex', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('spdy + multiplex switched order', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex', 'spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('one without the other fails to establish a muxedConn', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => {
+        // it will just 'warm up a conn'
+        expect(Object.keys(nodeA.swarm.muxers)).to.have.length(1)
+        expect(Object.keys(nodeB.swarm.muxers)).to.have.length(1)
+
+        nodeA.dial(nodeB.peerInfo, (err) => {
+          expect(err).to.not.exist()
+          expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+          cb()
+        })
+      },
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+})
--- a/test/nodejs-bundle/tcp+websockets+webrtc-star.js
+++ b/test/nodejs-bundle/tcp+websockets+webrtc-star.js
@ -0,0 +1,246 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const signalling = require('libp2p-webrtc-star/src/sig-server')
+const WStar = require('libp2p-webrtc-star')
+const wrtc = require('wrtc')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP + WebSockets + WebRTCStar', () => {
+  let nodeAll
+  let nodeTCP
+  let nodeWS
+  let nodeWStar
+
+  let ss
+
+  before((done) => {
+    parallel([
+      (cb) => {
+        signalling.start({ port: 24642 }, (err, server) => {
+          expect(err).to.not.exist()
+          ss = server
+          cb()
+        })
+      },
+      (cb) => {
+        const wstar = new WStar({wrtc: wrtc})
+        createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          '/ip4/127.0.0.1/tcp/25011/ws',
+          '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/24642/ws'
+        ], {
+          modules: {
+            transport: [wstar],
+            discovery: [wstar.discovery]
+          }
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeAll = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      },
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCP = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/127.0.0.1/tcp/25022/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+
+      (cb) => {
+        const wstar = new WStar({wrtc: wrtc})
+
+        createNode([
+          '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/24642/ws'
+        ], {
+          modules: {
+            transport: [wstar],
+            discovery: [wstar.discovery]
+          }
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeWStar = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      }
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeAll.stop(cb),
+      (cb) => nodeTCP.stop(cb),
+      (cb) => nodeWS.stop(cb),
+      (cb) => nodeWStar.stop(cb),
+      (cb) => ss.stop(done)
+    ], done)
+  })
+
+  it('nodeAll.dial nodeTCP using PeerInfo', (done) => {
+    nodeAll.dial(nodeTCP.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeTCP using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeTCP.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.dial nodeWS using PeerInfo', (done) => {
+    nodeAll.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeWS using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.dial nodeWStar using PeerInfo', (done) => {
+    nodeAll.dial(nodeWStar.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(3)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWStar.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeWStar using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeWStar.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(3)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWStar.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWStar.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+})
--- a/test/nodejs-bundle/tcp+websockets.js
+++ b/test/nodejs-bundle/tcp+websockets.js
@ -0,0 +1,167 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+// const multiaddr = require('multiaddr')
+// const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP + WebSockets', () => {
+  let nodeTCP
+  let nodeTCPnWS
+  let nodeWS
+
+  before((done) => {
+    parallel([
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCP = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0',
+        '/ip4/127.0.0.1/tcp/25011/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCPnWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/127.0.0.1/tcp/25022/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      })
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeTCP.stop(cb),
+      (cb) => nodeTCPnWS.stop(cb),
+      (cb) => nodeWS.stop(cb)
+    ], done)
+  })
+
+  it('nodeTCP.dial nodeTCPnWS using PeerInfo', (done) => {
+    nodeTCP.dial(nodeTCPnWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCP.hangUp nodeTCPnWS using PeerInfo', (done) => {
+    nodeTCP.hangUp(nodeTCPnWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(0)
+
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCPnWS.dial nodeWS using PeerInfo', (done) => {
+    nodeTCPnWS.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCPnWS.hangUp nodeWS using PeerInfo', (done) => {
+    nodeTCPnWS.hangUp(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(0)
+
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  // Until https://github.com/libp2p/js-libp2p/issues/46 is resolved
+  // Everynode will be able to dial in WebSockets
+  it.skip('nodeTCP.dial nodeWS using PeerInfo is unsuccesful', (done) => {
+    nodeTCP.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.exist()
+      done()
+    })
+  })
+})
--- a/test/nodejs-bundle/tcp.js
+++ b/test/nodejs-bundle/tcp.js
@ -0,0 +1,234 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP only', () => {
+  let nodeA
+  let nodeB
+
+  before((done) => {
+    parallel([
+      (cb) => createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+        expect(err).to.not.exist()
+        nodeA = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+        expect(err).to.not.exist()
+        nodeB = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      })
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb)
+    ], done)
+  })
+
+  it('nodeA.dial nodeB using PeerInfo without proto (warmup)', (done) => {
+    nodeA.dial(nodeB.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(err).to.not.exist()
+            expect(Object.keys(peers)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(err).to.not.exist()
+            expect(Object.keys(peers)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using PeerInfo', (done) => {
+    nodeA.dial(nodeB.peerInfo, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+
+      pull(
+        pull.values([new Buffer('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.be.eql([new Buffer('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('nodeA.hangUp nodeB using PeerInfo (first)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using multiaddr', (done) => {
+    nodeA.dial(nodeB.peerInfo.multiaddrs.toArray()[0], '/echo/1.0.0', (err, conn) => {
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        expect(err).to.not.exist()
+        series([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], () => {
+          pull(
+            pull.values([new Buffer('hey')]),
+            conn,
+            pull.collect((err, data) => {
+              expect(err).to.not.exist()
+              expect(data).to.be.eql([new Buffer('hey')])
+              done()
+            })
+          )
+        })
+      }
+    })
+  })
+
+  it('nodeA.hangUp nodeB using multiaddr (second)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using PeerId', (done) => {
+    nodeA.dial(nodeB.peerInfo.id, '/echo/1.0.0', (err, conn) => {
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        expect(err).to.not.exist()
+        series([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], () => {
+          pull(
+            pull.values([new Buffer('hey')]),
+            conn,
+            pull.collect((err, data) => {
+              expect(err).to.not.exist()
+              expect(data).to.be.eql([new Buffer('hey')])
+              done()
+            })
+          )
+        })
+      }
+    })
+  })
+
+  it('nodeA.hangUp nodeB using PeerId (third)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+})
--- a/test/nodejs-bundle/test-data/test-id.json
+++ b/test/nodejs-bundle/test-data/test-id.json
@ -0,0 +1,5 @@
+{
+  "id": "QmaG17D4kfTB2RNUCr16bSfVvUVt2Xn3rPYeqQDvnVcXFr",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQDBpXRrSLoVhP8C4YI0nm+YTb7UIe+xT9dwaMzKcGsH2zzz1lfxl54e1XNO+6Ut+If5jswpydgHhn9nGPod53sUIR2m+BiHOAH/Blgfa1nUKUkspts1MH3z5ZaO6Xo336Y0Uaw7UqfeIzKliTM6bpev2XIHyu0v/VJ2mylzfbDLMWqZs/shE3xwCJCD/PxoVpTlr/SzzF7MdgDMxkyiC3iLZ5Zkm+baPbi3mpKM0ue25Thedcc0KFjhQrjBfy5FPamrsMn5fnnoHwnQl9u7UWigzeC+7X+38EML1sVrV37ExxHPtM6882Ivjc7VN6zFHOHD2c9eVfbShkIf8YkVQUcFAgMBAAECggEAVE1mgGo58LJknml0WNn8tS5rfEiF5AhhPyOwvBTy04nDYFgZEykxgjTkrSbqgzfmYmOjSDICJUyNXGHISYqDz4CXOyBY9U0RuWeWp58BjVan75N4bRB+VNbHk9HbDkYEQlSoCW9ze0aRfvVa4v5QdRLSDMhwN+stokrsYcX/WIWYTM2e2jW+qQOzS8SJl7wYsgtd3WikrxwXkRL3sCMHEcgcPhoKacoD5Yr9cB0IC5vzhu4t/WMa+N2UEndcKGAbXsh8kA7BPFM6lqnEpOHpWEVEAYasAwFGUvUN9GwhtqpaNNS2sG6Nrz95cC99Nqx58uIXcTAJm3Fh/WfKJ6I1xQKBgQD+g7A5OSWw+i/zhTKVPJg93/eohViL0dGZT9Tf0/VslsFl00FwnZmBKA6BJ6ZL3hD00OcqIL3m6EzZ4q38U97XZxf2OUsPPJtl+Avqtlk16AHRHB9I17LGXJ30xZRkxL665oLms0D2T4NIZZX/uVMoS18lRvCZj1aEYQFCrZYgowKBgQDCxtA695S0vl6E3Q4G6MrDZK+2JqjaGL0XTnpHWiAjnk2lnV2CCZnWpEHT+ebF2fWx5nYQo5sugc6bS+4k9jRNUgxf2sQieZYCBjbnjCEVrPTm/dPTkaw1CQ/ox5/R1/Elbw8vteF9uUAvR0FL8Ss1Dqw6B2SxdTowxMy6qQ7sNwKBgG2N3eMj2DeP2egm45kdliK8L2yYyX6V+HTXyjf2kuQFGIZuIvMIw7S2u1eY65ooon/fFEIsCdJFGB+J1X6R05BAzi2sh8StP+7qkKadi1UK4w1R352JS2jbIRrlmXSuw7LL2njXnBTqMQaOw7xp14O2vePb32EaNBGTd+ltsvulAoGBALGIc4370oA4MIDb2Ag2MXKNmJbnf+piuB/BOTVGEZtFlDKLUArR43W/+/xRgKX/97FyhVS/OxfV21Kzj9oCy0NasMrB5RojRraLoYnFsPZH0mWlIGlsEtG4c9bR9XtYX4WmR+pN1r04mCc/xGWK6b4PpK2zxXT2i9ad2pmctGxbAoGBAIcp0UML5QCqvLmcob2/6PCRaYAxJBb9lDqOHredMgQih2hGnHFCyKk9eBAbFf/KN0guJTBDaAJRclcxsLLn7rV6grMNt+0EUepm7tWT0z5j8gNGbGGhuGDdqcmfJTc2EMdQrfhzYDN3rL1v3l+Ujwla2khL2ozE7SQ/KVeA1saY",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBpXRrSLoVhP8C4YI0nm+YTb7UIe+xT9dwaMzKcGsH2zzz1lfxl54e1XNO+6Ut+If5jswpydgHhn9nGPod53sUIR2m+BiHOAH/Blgfa1nUKUkspts1MH3z5ZaO6Xo336Y0Uaw7UqfeIzKliTM6bpev2XIHyu0v/VJ2mylzfbDLMWqZs/shE3xwCJCD/PxoVpTlr/SzzF7MdgDMxkyiC3iLZ5Zkm+baPbi3mpKM0ue25Thedcc0KFjhQrjBfy5FPamrsMn5fnnoHwnQl9u7UWigzeC+7X+38EML1sVrV37ExxHPtM6882Ivjc7VN6zFHOHD2c9eVfbShkIf8YkVQUcFAgMBAAE="
+}
--- a/test/nodejs-bundle/turbolence.js
+++ b/test/nodejs-bundle/turbolence.js
@ -0,0 +1,84 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const multiaddr = require('multiaddr')
+const spawn = require('child_process').spawn
+const path = require('path')
+// const map = require('async/map')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('Turbolence tests', () => {
+  let nodeA
+  let nodeSpawn
+
+  before((done) => {
+    createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+      expect(err).to.not.exist()
+      nodeA = node
+      node.handle('/echo/1.0.0', echo)
+      node.start(done)
+    })
+  })
+
+  after((done) => nodeA.stop(done))
+
+  it('spawn a node in a different process', (done) => {
+    const filePath = path.join(__dirname, './spawn-libp2p-node.js')
+
+    nodeSpawn = spawn(filePath, { env: process.env })
+
+    let spawned = false
+
+    nodeSpawn.stdout.on('data', (data) => {
+      // console.log(data.toString())
+      if (!spawned) {
+        spawned = true
+        done()
+      }
+    })
+
+    nodeSpawn.stderr.on('data', (data) => console.log(data.toString()))
+  })
+
+  it('connect nodeA to that node', (done) => {
+    const spawnedId = require('./test-data/test-id.json')
+    const maddr = multiaddr('/ip4/127.0.0.1/tcp/12345/ipfs/' + spawnedId.id)
+
+    nodeA.dial(maddr, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+      const peers = nodeA.peerBook.getAll()
+
+      expect(Object.keys(peers)).to.have.length(1)
+
+      pull(
+        pull.values([new Buffer('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.eql([new Buffer('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('crash that node, ensure nodeA continues going steady', (done) => {
+    // TODO investigate why CI crashes
+    setTimeout(() => nodeSpawn.kill('SIGKILL'), 1000)
+    // nodeSpawn.kill('SIGKILL')
+    setTimeout(check, 5000)
+
+    function check () {
+      const peers = nodeA.peerBook.getAll()
+      expect(Object.keys(peers)).to.have.length(1)
+      expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+      done()
+    }
+  })
+})
--- a/test/nodejs-bundle/utils.js
+++ b/test/nodejs-bundle/utils.js
@ -0,0 +1,43 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const Node = require('./nodejs-bundle')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+
+function createNode (multiaddrs, options, callback) {
+  if (typeof options === 'function') {
+    callback = options
+    options = {}
+  }
+
+  if (!Array.isArray(multiaddrs)) {
+    multiaddrs = [multiaddrs]
+  }
+
+  waterfall([
+    (cb) => PeerId.create({ bits: 1024 }, cb),
+    (peerId, cb) => PeerInfo.create(peerId, cb),
+    (peerInfo, cb) => {
+      multiaddrs.map((ma) => peerInfo.multiaddrs.add(ma))
+      cb(null, peerInfo)
+    },
+    (peerInfo, cb) => {
+      const node = new Node(peerInfo, undefined, options)
+      cb(null, node)
+    }
+  ], callback)
+}
+
+function echo (protocol, conn) {
+  pull(conn, conn)
+}
+
+module.exports = {
+  createNode: createNode,
+  echo: echo
+}
Author	SHA1	Message	Date
David Dias	b6e41922a7	chore: release version v0.10.0	2017-07-07 13:27:04 +01:00
David Dias	195673c2d3	chore: update contributors	2017-07-07 13:27:04 +01:00
David Dias	647d10fe10	chore: update deps	2017-07-07 13:25:34 +01:00
Pedro Teixeira	73f2f6d050	feat: state events and query changes (#100 )	2017-07-07 12:56:46 +01:00
David Dias	2d40f3ad6a	docs: update header of the README (#97 )	2017-07-05 18:18:31 +01:00
David Dias	13452c959e	docs: rm bundles from table	2017-07-05 18:08:10 +01:00
David Dias	547c4dbd33	docs: refactor examples (#96 )	2017-07-05 12:12:51 +01:00
David Dias	606fa737b8	WIP - feat: convergence (#94 ) * feat: convergence * structure examples	2017-07-04 11:43:45 +01:00
David Dias	e3870f3f8a	Merge pull request #90 from libp2p/fix/missing-dep-async fix: added missing dep async	2017-06-28 19:29:44 +01:00
Pedro Teixeira	45b0f61824	fix: added missing dep async	2017-06-17 14:29:19 +01:00
David Dias	0263b899e3	chore: release version v0.9.1	2017-04-16 16:54:49 +01:00
David Dias	fb92e672ee	chore: update contributors	2017-04-16 16:54:49 +01:00
David Dias	2e326e1619	fix: do not use assert in async funcs (#88 )	2017-04-16 16:54:31 +01:00
David Dias	e4e9761c99	Fix docs	2017-04-16 11:56:34 +01:00
David Dias	a5b7de1b6b	chore: release version v0.9.0	2017-04-06 15:50:57 -04:00
David Dias	9a7a381f85	chore: update contributors	2017-04-06 15:50:56 -04:00
David Dias	1f00855e6e	chore: update deps	2017-04-06 15:46:13 -04:00
Friedel Ziegelmayer	8aa932a491	[WIP] Awesome DHT (#86 ) * feat: integrate dht * better interfaces * docs: add documentation for peerRouting, contentRouting, dht * fix: take in passed datastore * fix: update usage of _getPeerInfo * fix: getPeerInfo * docs: update docs * moar	2017-04-06 15:45:23 -04:00
David Dias	babb90fe17	chore: release version v0.8.0	2017-03-31 16:19:24 +01:00
David Dias	2f9070a725	chore: update contributors	2017-03-31 16:19:24 +01:00
David Dias	a48ec65961	Merge pull request #85 from libp2p/feat/advanced-peer-book fix: correct method on peer-book	2017-03-31 16:18:37 +01:00
David Dias	031ecb3fe7	fix: correct method on peer-book	2017-03-31 16:17:59 +01:00
David Dias	c6bdd869be	Merge pull request #76 from libp2p/feat/advanced-peer-book fix: avoid deleting nodes from peerBook	2017-03-31 16:17:18 +01:00
David Dias	dee0340806	chore: update to latest peer-info, peer-book and libp2p-swarm	2017-03-31 15:52:20 +01:00
David Dias	a4b41b0f9a	feat: not remove peer from peerBook on disconnect	2017-03-30 07:20:45 +01:00
David Dias	291e79fc99	fix: addition of ipfs id appendix must come before transport filtering	2017-03-29 21:02:37 +01:00
David Dias	59ea9c388f	feat: append peer id to multiaddr if not there	2017-03-29 20:02:54 +01:00
David Dias	300936f2f3	fix: avoid deleting nodes from peerBook	2017-03-29 18:03:00 +01:00
David Dias	9f4ec2a915	chore: release version v0.7.0	2017-03-29 08:03:58 +01:00
David Dias	c7f4368007	chore: update contributors	2017-03-29 08:03:58 +01:00
David Dias	9ff04779f5	Merge pull request #75 from libp2p/feat/update-peer-events feat: Feat/update peer events	2017-03-29 08:03:13 +01:00
David Dias	f73c045767	feat: update events to conform with #74	2017-03-29 07:32:46 +01:00
David Dias	8840c9b250	docs: document new events	2017-03-29 07:32:29 +01:00
David Dias	df4c99df4a	chore: release version v0.6.2	2017-03-28 12:44:52 +01:00
David Dias	6e05a0b239	chore: update contributors	2017-03-28 12:44:52 +01:00
David Dias	c781abc30c	chore: deps	2017-03-28 12:43:00 +01:00
David Dias	6a66931ba4	chore: release version v0.6.1	2017-03-27 16:48:53 +01:00
David Dias	426fc27b26	chore: update contributors	2017-03-27 16:48:52 +01:00
David Dias	d6325dee90	chore: update deps	2017-03-27 16:48:41 +01:00
David Dias	f74bc0596d	chore: release version v0.6.0	2017-03-27 15:48:46 +01:00
David Dias	8f9e82b0fb	chore: update contributors	2017-03-27 15:48:46 +01:00
David Dias	9724fa190e	chore: update deps	2017-03-27 15:46:10 +01:00
David Dias	721da9ab41	Merge pull request #64 from libp2p/feat/new-api feat: Formalising the API	2017-03-27 15:45:41 +01:00
David Dias	d27bd2b912	cr	2017-03-27 15:43:08 +01:00
David Dias	2c23d9a718	fix: last touches	2017-03-27 14:42:05 +01:00
David Dias	a6623c1ba2	feat: new super simplified API	2017-03-27 12:26:34 +01:00
David Dias	5d4d94e75f	docs: finish API documentation	2017-03-24 18:20:14 +00:00
David Dias	a4b97b9627	docs: libp2p API	2017-03-24 17:07:08 +00:00
David Dias	3584209947	docs: update readme, add base class extending example and start listing API calls	2017-03-24 16:02:57 +00:00
Friedel Ziegelmayer	b5209fc456	chore: release version v0.5.5	2017-03-21 17:06:34 +01:00
Friedel Ziegelmayer	932d8772da	chore: update contributors	2017-03-21 17:06:33 +01:00
Friedel Ziegelmayer	baee2b7945	chore(deps): update	2017-03-21 17:04:56 +01:00
David Dias	153f8884fa	Merge pull request #54 from libp2p/greenkeeper-aegir-10.0.0 Update aegir to version 10.0.0 🚀	2017-02-13 18:05:01 -08:00
David Dias	b71f77dcf7	chore: release version v0.5.4	2017-02-10 23:19:27 -08:00
David Dias	8dc8e0530b	chore: update contributors	2017-02-10 23:19:27 -08:00
David Dias	4ed0ce16af	chore: update deps	2017-02-10 23:17:30 -08:00
David Dias	cbb7290a97	chore: release version v0.5.3	2017-02-10 19:28:41 -08:00
David Dias	63b10c01e3	chore: update contributors	2017-02-10 19:28:41 -08:00
David Dias	11c21b6999	fix: use async.setImmediate	2017-02-10 19:28:34 -08:00
David Dias	109ee51d7b	chore: release version v0.5.2	2017-02-09 10:18:38 -08:00
David Dias	09182b43bf	chore: update contributors	2017-02-09 10:18:38 -08:00
David Dias	a130ab2dc1	chore: ^ to ~	2017-02-09 10:16:51 -08:00
greenkeeperio-bot	13355bf179	chore(package): update aegir to version 10.0.0 https://greenkeeper.io/	2017-02-07 18:45:33 +01:00
David Dias	e24a1e43dc	chore: release version v0.5.1	2017-01-28 21:20:21 +00:00
David Dias	cb7d60ef65	chore: update contributors	2017-01-28 21:20:20 +00:00
David Dias	a01b9479eb	fix: remove unnecessary log	2017-01-28 21:20:16 +00:00
David Dias	d01876a3d1	chore: release version v0.5.0	2017-01-28 21:14:26 +00:00
David Dias	eb5eed8b21	chore: update contributors	2017-01-28 21:14:26 +00:00
David Dias	3c58613b69	chore: release version v0.4.0	2017-01-28 21:14:04 +00:00
David Dias	5dd5d37f6a	feat: new discovery interface	2017-01-28 21:14:04 +00:00
David Dias	6c3dd4b780	chore: update deps	2017-01-28 21:14:04 +00:00
mayerwin	06913271c7	docs(readme): fix typos	2017-01-16 12:01:09 +01:00
David Dias	2cdd7033f0	add options	2016-12-11 12:03:21 -08:00
David Dias	c2cf1da2ce	Merge pull request #50 from libp2p/greenkeeper-aegir-9.2.1	2016-12-10 12:00:26 -08:00
greenkeeperio-bot	8d0124ee5c	chore(package): update aegir to version 9.2.1 https://greenkeeper.io/	2016-12-09 13:25:07 +01:00
David Dias	078956b310	chore: release version v0.3.1	2016-12-01 12:17:33 +00:00
David Dias	4f44158889	chore: update contributors	2016-12-01 12:17:32 +00:00
David Dias	3a8d51c142	Merge pull request #48 from libp2p/feat/add-ping feat: add ping to the mix	2016-12-01 12:17:10 +00:00
David Dias	f8c09db20f	feat: add ping to the mix	2016-12-01 11:53:27 +00:00
David Dias	ee801c9be2	chore: release version v0.3.0	2016-11-28 10:40:29 +00:00
David Dias	03349d7caf	chore: update contributors	2016-11-28 10:40:29 +00:00
David Dias	0c87dbc8f3	feat: export Node class at the top level	2016-11-28 10:38:40 +00:00
David Dias	c4abbaa2f9	chore: release version v0.2.1	2016-11-27 18:56:25 +00:00
David Dias	21759f1204	chore: update contributors	2016-11-27 18:56:25 +00:00
David Dias	0830827c06	docs: add links to readme	2016-11-27 18:54:30 +00:00
David Dias	8f31d1cb17	docs: update package list	2016-11-27 18:48:01 +00:00
David Dias	fc43b99836	chore: release version v0.2.0	2016-11-27 18:41:13 +00:00
David Dias	4027c3cca4	chore: update contributors	2016-11-27 18:41:13 +00:00
David Dias	049c7ce347	docs: readme badges	2016-11-27 18:30:37 +00:00
David Dias	54b65b3cbc	Merge pull request #43 from libp2p/feat/revamp WIP: create the libp2p base class	2016-11-27 19:29:06 +01:00
David Dias	3db3dca98b	docs: update examples folder	2016-11-27 18:23:50 +00:00
David Dias	40fdc4147c	feat: support websockets, even if no listener is added	2016-11-27 18:20:25 +00:00
David Dias	e10ec13c33	feat: add the CI stuffs	2016-11-26 03:12:30 +01:00
David Dias	5d0b25cb00	feat: create base libp2p.Node class	2016-11-26 03:07:52 +01:00
David Dias	57c85fe346	chore: update oldie package.json	2016-11-25 20:08:05 +00:00
David Dias	d7eb5b7abc	docs: overall to the README, lots of more updated information	2016-11-25 20:07:45 +00:00
David Dias	b5608f0ef8	Merge pull request #39 from libp2p/greenkeeper-libp2p-swarm-0.26.0 Update libp2p-swarm to version 0.26.0 🚀	2016-11-07 15:53:16 +00:00
greenkeeperio-bot	b423a1c583	chore(package): update libp2p-swarm to version 0.26.0 https://greenkeeper.io/	2016-11-03 12:42:11 +01:00
Richard Littauer	0f7bde7bc3	Merge pull request #29 from libp2p/feat/remove-below Remove word below	2016-10-14 10:55:39 -04:00
David Dias	fecb41b275	readme	2016-09-14 01:34:15 -04:00
David Dias	14d14ff0b6	Merge pull request #30 from libp2p/readme update the roadmap	2016-09-14 01:33:14 -04:00
David Dias	af493363aa	add images	2016-09-14 01:31:47 -04:00
David Dias	fe2d097bfa	update the roadmap	2016-09-14 01:29:30 -04:00
Richard Littauer	3cf54db8d5	Remove word below It doesnt belong	2016-09-13 17:23:47 -04:00
David Dias	ed9d0e5a42	Merge pull request #27 from libp2p/greenkeeper-multiaddr-2.0.3 Update multiaddr to version 2.0.3 🚀	2016-09-07 20:24:13 -04:00
David Dias	8486f04c55	Merge pull request #28 from libp2p/greenkeeper-peer-info-0.7.1 Update peer-info to version 0.7.1 🚀	2016-09-07 20:24:06 -04:00
greenkeeperio-bot	012433b5d5	chore(package): update peer-info to version 0.7.1 https://greenkeeper.io/	2016-09-08 01:37:08 +02:00
greenkeeperio-bot	48fcf7ee90	chore(package): update multiaddr to version 2.0.3 https://greenkeeper.io/	2016-09-08 01:20:14 +02:00
David Dias	517723a093	Merge pull request #22 from libp2p/feature/standardize-readme Standardized Readme	2016-09-07 14:19:40 -04:00
David Dias	55223d528c	Merge pull request #23 from libp2p/greenkeeper-libp2p-tcp-0.8.0 Update libp2p-tcp to version 0.8.0 🚀	2016-09-07 14:19:15 -04:00
greenkeeperio-bot	f6f96d3b5f	chore(package): update libp2p-tcp to version 0.8.0 https://greenkeeper.io/	2016-09-06 14:56:54 +02:00
Richard Littauer	3c93b7cd4e	Standardized Readme Thoughts?	2016-09-02 15:22:28 -04:00
David Dias	c72ce8a7fb	Merge pull request #14 from libp2p/module-list docs(readme): add package listing	2016-08-29 16:33:45 +01:00
David Dias	a06dc87670	Merge pull request #12 from dignifiedquire/dignified Use dignified.js	2016-08-29 16:33:17 +01:00
Friedel Ziegelmayer	93a0103fb8	docs(readme): add package listing See https://github.com/ipfs/js-ipfs/pull/385 for details	2016-08-01 15:40:47 +02:00
dignifiedquire	a6652f295e	Use dignified.js 1.0.0	2016-04-07 21:20:56 +02:00
dignifiedquire	f08dbbc8a9	Use dignified.js	2016-03-23 15:30:14 +01:00
David Dias	815a85d51f	Merge pull request #3 from diasdavid/example/using-swarm using swarm example	2015-12-15 03:45:22 +00:00
David Dias	c4b6de1db6	notes License: MIT Signed-off-by: David Dias <daviddias.p@gmail.com>	2015-12-11 21:21:07 -08:00
David Dias	2c48724db7	using swarm example License: MIT Signed-off-by: David Dias <daviddias.p@gmail.com>	2015-12-10 15:40:26 -08:00
David Dias	d79abccb85	update readme with roadmap and links to discussion License: MIT Signed-off-by: David Dias <daviddias.p@gmail.com>	2015-11-18 18:58:30 +00:00
David Dias	0293aee549	update the readme with roadmap	2015-11-18 16:28:20 +00:00