chore: release version v0.10.1

docs(examples): libp2p in the browser 1

CHANGELOG.md

@@ -0,0 +1,93 @@
+<a name="0.10.1"></a>
+## [0.10.1](https://github.com/libp2p/js-libp2p/compare/v0.10.0...v0.10.1) (2017-07-10)
+
+
+
+<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)
+
+
+

CODE_OF_CONDUCT.md

@@ -0,0 +1,151 @@
+# IPFS Community Code of Conduct
+
+We believe that our mission is best served in an environment that is friendly,
+safe, and accepting; free from intimidation or harassment.
+
+Towards this end, certain behaviors and practices will not be tolerated.
+
+## tl;dr
+
+- Be respectful.
+- We're here to help: abuse@ipfs.io
+- Abusive behavior is never tolerated.
+- Violations of this code may result in swift and permanent expulsion from the IPFS community.
+- "Too long, didn't read" is not a valid excuse for not knowing what is in this document.
+
+## Table of Contents
+
+- [Scope](#scope)
+- [Friendly Harassment-Free Space](#friendly-harassment-free-space)
+- [Reporting Violations of this Code of Conduct](#reporting-violations-of-this-code-of-conduct)
+- [Copyright Violations](#copyright-violations)
+- [Consequences](#consequences)
+- [Addressing Grievances](#addressing-grievances)
+- [Contact Info](#contact-info)
+- [Changes](#changes)
+- [Credit and License](#credit-and-license)
+
+## Scope
+
+We expect all members of the IPFS community to abide by this Code of Conduct
+at all times in all IPFS community venues, online and in person, and in one-on-one
+communications pertaining to IPFS affairs.
+
+This policy covers the usage of IPFS public infrastructure, including the
+IPFS.io HTTP gateways, as well as other IPFS websites, IPFS related events,
+and any other services offered by or on behalf of the IPFS community. It also
+applies to behavior in the context of the IPFS Open Source project
+communities, including but not limited to public GitHub repositories, IRC
+channels, social media, mailing lists, and public events.
+
+This Code of Conduct is in addition to, and does not in any way nullify or
+invalidate, any other terms or conditions related to use of IPFS services.
+
+The definitions of various subjective terms such as "discriminatory",
+"hateful", or "confusing" will be decided at the sole discretion of the IPFS
+abuse team.
+
+## Friendly Harassment-Free Space
+
+We are committed to providing a friendly, safe and welcoming environment for
+all, regardless of gender identity, sexual orientation, disability, ethnicity,
+religion, age, physical appearance, body size, race, or similar personal
+characteristics.
+
+We ask that you please respect that people have differences of opinion
+regarding technical choices, and that every design or implementation choice
+carries a trade-off and numerous costs. There is seldom a single right answer.
+A difference of technology preferences is not a license to be rude.
+
+Any spamming, trolling, flaming, baiting, or other attention-stealing
+behavior is not welcome, and will not be tolerated.
+
+Harassing other users is never tolerated, whether via public or private media.
+
+Avoid using offensive or harassing nicknames, or other identifiers that might
+detract from a friendly, safe, and welcoming environment for all.
+
+Harassment includes, but is not limited to: harmful or prejudicial verbal or
+written comments related to gender identity, sexual orientation, disability,
+ethnicity, religion, age, physical appearance, body size, race, or similar
+personal characteristics; inappropriate use of nudity, sexual images, and/or
+sexually explicit language in public spaces; threats of physical or non-
+physical harm; deliberate intimidation, stalking or following; harassing
+photography or recording; sustained disruption of talks or other events;
+inappropriate physical contact; and unwelcome sexual attention.
+
+Media shared through public infrastructure run by the IPFS team must not
+contain illegal or infringing content. You should only publish content via
+IPFS public infrastructure if you have the right to do so. This includes
+complying with all software license agreements or other intellectual property
+restrictions. You will be solely responsible for any violation of laws or
+others’ intellectual property rights.
+
+## Reporting Violations of this Code of Conduct
+
+If you believe someone is harassing you or has otherwise violated this Code of
+Conduct, please contact us at abuse@ipfs.io to send us an abuse report. If
+this is the initial report of a problem, please include as much detail as
+possible. It is easiest for us to address issues when we have more context.
+
+## Copyright Violations
+
+We respect the intellectual property of others and ask that you do too. If you
+believe any content or other materials available through public IPFS
+infrastructure violates a copyright held by you and you would like to submit a
+notice pursuant to the Digital Millennium Copyright Act or other similar
+international law, you can submit a notice to our agent for service of notice
+to: abuse@ipfs.io
+
+(We will add a physical mailing address here when we acquire one).
+
+Please make sure your notice meets the Digital Millennium Copyright Act
+requirements.
+
+## Consequences
+
+All content published to public IPFS infrastructure is hosted at the sole
+discretion of the IPFS team.
+
+Unacceptable behavior from any community member will not be tolerated.
+
+Anyone asked to stop unacceptable behavior is expected to comply immediately.
+
+If a community member engages in unacceptable behavior, the ipfs team
+may take any action they deem appropriate, up to and including a temporary ban
+or permanent expulsion from the community without warning (and without refund
+in the case of a paid event or service).
+
+## Addressing Grievances
+
+If you feel you have been falsely or unfairly accused of violating this Code
+of Conduct, you should notify the IPFS team. We will do our best to ensure
+that your grievance is handled appropriately.
+
+In general, we will choose the course of action that we judge as being most in
+the interest of fostering a safe and friendly community.
+
+On IRC, let one of the ops know if you think that someone has transgressed
+against the Code of Conduct. If you would like to be an op and promise to
+help maintain and abide by the code, please let us know.
+
+## Contact Info
+
+Please contact abuse@ipfs.io if you need to report a problem or address a
+grievance related to an abuse report.
+
+You are also encouraged to contact us if you are curious about something that
+might be "on the line" between appropriate and inappropriate content. We are
+happy to provide guidance to help you be a successful part of our community.
+
+## Changes
+
+This is a living document and may be updated from time to time. Please refer
+to the git history for this document to view the changes.
+
+## Credit and License
+This Code of Conduct is based on the
+[npm Code of Conduct](https://www.npmjs.com/policies/conduct).
+
+This document may be reused under a [Creative Commons Attribution-ShareAlike
+License](http://creativecommons.org/licenses/by-sa/4.0/).

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing guidelines
+
+libp2p as a project, including js-libp2p and all of its modules, follows the [standard IPFS Community contributing guidelines](https://github.com/ipfs/community/blob/master/js-project-guidelines.md).
+
+We also adhere to the [IPFS JavaScript Community contributing guidelines](https://github.com/ipfs/community/blob/master/js-project-guidelines.md) which provide additional information of how to collaborate and contribute in the JavaScript implementation of libp2p.
+
+We appreciate your time and attention for going over these. Please open an issue on [ipfs/community](https://github.com/ipfs/community) if you have any question.
+
+Thank you.

README.md

@@ -1,13 +1,28 @@
-![](https://github.com/libp2p/js-libp2p/blob/fe2d097bfa072ef6733f2defb568bdc526052ee4/img/js-libp2p.png?raw=true)
+<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/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
-[![Build Status](https://travis-ci.org/libp2p/js-libp2p.svg?style=flat-square)](https://travis-ci.org/libp2p/js-libp2p)
-![coverage](https://img.shields.io/badge/coverage-%3F-yellow.svg?style=flat-square)
-[![Dependency Status](https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square)](https://david-dm.org/libp2p/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>
 
-> libp2p is the networking stack of IPFS, a modular networking library to solve P2P application needs.
+<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>
+
+<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>
 
 ## Table of Contents
 
@@ -15,6 +30,7 @@
 - [Bundles](#bundles)
 - [Usage](#usage)
   - [Install](#install)
+  - [Usage](#usage)
   - [API](#api)
 - [Development](#development)
   - [Tests](#tests)
@@ -28,10 +44,10 @@ libp2p is the product of a long and arduous quest to understand the evolution of
 
 We are in the process of writting better documentation, blog posts, tutorials and a formal specification. Today you can find:
 
-- [libp2p.io - The libp2p Website (WIP)](https://github.com/libp2p/website)
+- [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)
+  - [`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)
 
@@ -41,8 +57,8 @@ To sum up, libp2p is a "network stack" -- a protocol suite -- that cleanly separ
 
 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-libp2p-ipfs-nodejs) - The libp2p build used by js-ipfs when run in Node.js
-- [libp2p-ipfs-browser](https://github.com/ipfs/js-libp2p-ipfs-browser) - The libp2p build used by js-ipfs when run in a Browser (that supports WebRTC)
+- [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.
 
@@ -56,33 +72,208 @@ npm install --save libp2p
 
 ## Usage
 
-> **Disclaimer - We haven't solidified [libp2p interface](https://github.com/libp2p/interface-libp2p) yet, it might change at anytime.**
+### [Tutorials and Examples](/examples)
+
+You can find multiple examples on the [examples folder](/examples) that will guide you through using libp2p for several scenarions.
 
 ### Extending libp2p skeleton
 
 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).
 
-### libp2p API
+**Example:**
 
-Defined by [interface-libp2p](https://github.com/libp2p/interface-libp2p)
+```JavaScript
+// Creating a bundle that adds:
+//   transport: websockets + tcp
+//   stream-muxing: SPDY
+//   crypto-channel: secio
+//   discovery: multicast-dns
 
-## Development
+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')
 
-## Linting
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
 
-```sh
-> npm run lint
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: [
+          spdy
+        ],
+        crypto: [
+          secio
+        ]
+      },
+      discovery: [
+        new MulticastDNS(peerInfo)
+      ],
+      // 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.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.isStarted()`
+
+> 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
+
+---------------------
+
+`DHT methods exposed`
+
+#### `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
+
+---------------------
+
+`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
 
 List of packages currently in existence for libp2p
 
 | Package | Version | Dependencies | DevDependencies |
 |---------|---------|--------------|-----------------|
-| **Bundles**                                        |
-| [`libp2p-ipfs-nodejs`](//github.com/ipfs/js-libp2p-ipfs-nodejs) | [![npm](https://img.shields.io/npm/v/libp2p-ipfs-nodejs.svg?maxAge=86400&style=flat-square)](//github.com/ipfs/js-libp2p-ipfs-nodejs/releases) | [![Dependency Status](https://david-dm.org/ipfs/js-libp2p-ipfs-nodejs.svg?style=flat-square)](https://david-dm.org/ipfs/js-libp2p-ipfs-nodejs) | [![devDependency Status](https://david-dm.org/ipfs/js-libp2p-ipfs-nodejs/dev-status.svg?style=flat-square)](https://david-dm.org/ipfs/js-libp2p-ipfs-nodejs?type=dev) |
-| [`libp2p-ipfs-browser`](//github.com/ipfs/js-libp2p-ipfs-browser) | [![npm](https://img.shields.io/npm/v/libp2p-ipfs-browser.svg?maxAge=86400&style=flat-square)](//github.com/ipfs/js-libp2p-ipfs-browser/releases) | [![Dependency Status](https://david-dm.org/ipfs/js-libp2p-ipfs-browser.svg?style=flat-square)](https://david-dm.org/ipfs/js-libp2p-ipfs-browser) | [![devDependency Status](https://david-dm.org/ipfs/js-libp2p-ipfs-browser/dev-status.svg?style=flat-square)](https://david-dm.org/ipfs/js-libp2p-ipfs-browser?type=dev) |
 | **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) |

examples/README.md

@@ -1,6 +1,26 @@
-### Examples list
+# `js-libp2p` Examples and Tutorials
 
-Here are some examples built with libp2p bundles.
+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.
 
-- https://github.com/ipfs/js-libp2p-ipfs/tree/master/examples/echo
-- https://github.com/ipfs/js-libp2p-ipfs/tree/master/examples/chat
+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!
+
+## Understanding how libp2p works
+
+- [Transports](./transports)
+- [Protocol and Stream Muxing](./protocol-and-stream-muxing)
+- [Encrypted Communications](./encrypted-communications)
+- [Discovery Mechanisms](./discovery-mechanisms)
+- [Peer Routing](./peer-routing)
+- [Content Routing](./content-routing)
+- [PubSub](./pubsub)
+- [NAT Traversal](./nat-traversal)
+- Circuit Relay (future)
+- Naming (future)
+
+## Other examples
+
+- [Running libp2p in the Browser](./libp2p-in-the-browser)
+- Running libp2p in the Electron (future)
+- [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)

examples/archived/README.md

@@ -1,4 +0,0 @@
-Using libp2p-swarm
-==================
-
-

examples/archived/node-1.js

@@ -1,39 +0,0 @@
-'use strict'
-
-var Swarm = require('libp2p-swarm')
-var tcp = require('libp2p-tcp')
-var multiaddr = require('multiaddr')
-var Id = require('peer-id')
-var Spdy = require('libp2p-spdy')
-var Libp2p = require('../../src')
-var Peer = require('peer-info')
-
-// set up
-
-var mh = multiaddr('/ip4/127.0.0.1/tcp/8010')
-var p = new Peer(Id.create(), [])
-var sw = new Swarm(p)
-
-// create a libp2p node
-
-var node = new Libp2p(sw)
-
-node.swarm.addTransport('tcp', tcp, {multiaddr: mh}, {}, {port: 8010}, function () {
-  // Ready to receive incoming connections
-
-  sw.addStreamMuxer('spdy', Spdy, {})
-
-  // dial to another node
-
-  var mh2 = multiaddr('/ip4/127.0.0.1/tcp/8020')
-  var p2 = new Peer(Id.create(), [mh2])
-
-  node.swarm.dial(p2, {}, '/sparkles/1.0.0', function (err, conn) {
-    if (err) {
-      return console.error(err)
-    }
-
-    console.log('-> connection is ready')
-    process.stdin.pipe(conn).pipe(process.stdout)
-  })
-})

examples/archived/node-2.js

@@ -1,31 +0,0 @@
-'use strict'
-
-var Swarm = require('libp2p-swarm')
-var tcp = require('libp2p-tcp')
-var multiaddr = require('multiaddr')
-var Id = require('peer-id')
-var Spdy = require('libp2p-spdy')
-var Libp2p = require('../../src')
-var Peer = require('peer-info')
-
-// set up
-
-var mh = multiaddr('/ip4/127.0.0.1/tcp/8020')
-var p = new Peer(Id.create(), [])
-var sw = new Swarm(p)
-
-sw.addTransport('tcp', tcp, {multiaddr: mh}, {}, {port: 8020}, function () {
-  // Ready to receive incoming connections
-
-  sw.addStreamMuxer('spdy', Spdy, {})
-
-  // create a libp2p node
-
-  var node = new Libp2p(sw)
-
-  // handle/mount a protocol
-
-  node.swarm.handleProtocol('/sparkles/1.0.0', function (conn) {
-    process.stdin.pipe(conn).pipe(process.stdout)
-  })
-})

examples/chat/README.md

@@ -0,0 +1 @@
+# Chat example with libp2p

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

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

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

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="
+}

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="
+}

examples/discovery-mechanisms/1.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const Multiplex = require('libp2p-multiplex')
+const SECIO = require('libp2p-secio')
+const PeerInfo = require('peer-info')
+const Railing = require('libp2p-railing')
+const waterfall = require('async/waterfall')
+
+// Find this list at: https://github.com/ipfs/js-ipfs/blob/master/src/core/runtime/config-nodejs.json
+const bootstrapers = [
+  '/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+  '/ip4/104.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z',
+  '/ip4/104.236.179.241/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM',
+  '/ip4/162.243.248.213/tcp/4001/ipfs/QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm',
+  '/ip4/128.199.219.111/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu',
+  '/ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64',
+  '/ip4/178.62.158.247/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd',
+  '/ip4/178.62.61.185/tcp/4001/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3',
+  '/ip4/104.236.151.122/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx'
+]
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [Multiplex],
+        crypto: [SECIO]
+      },
+      discovery: [new Railing(bootstrapers)]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+let node
+
+waterfall([
+  (cb) => PeerInfo.create(cb),
+  (peerInfo, cb) => {
+    peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+    node = new MyBundle(peerInfo)
+    node.start(cb)
+  }
+], (err) => {
+  if (err) { throw err }
+
+  node.on('peer:discovery', (peer) => {
+    console.log('Discovered:', peer.id.toB58String())
+    node.dial(peer, () => {})
+  })
+
+  node.on('peer:connect', (peer) => {
+    console.log('Connection established to:', peer.id.toB58String())
+  })
+})

examples/discovery-mechanisms/2.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const Multiplex = require('libp2p-multiplex')
+const SECIO = require('libp2p-secio')
+const PeerInfo = require('peer-info')
+const MulticastDNS = require('libp2p-mdns')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [Multiplex],
+        crypto: [SECIO]
+      },
+      discovery: [new MulticastDNS(peerInfo, { interval: 1000 })]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+  node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+})

examples/discovery-mechanisms/README.md

@@ -0,0 +1,161 @@
+# Peer Discovery Mechanisms
+
+A Peer Discovery module enables libp2p to find peers to connect to. Think of these mechanisms as ways to join the rest of the network, as railing points.
+
+With these system, a libp2p node can both have a set of nodes to always connect on boot (bootstraper nodes), discover nodes through locality (e.g connected in the same LAN) or through serendipity (random walks on a DHT).
+
+These mechanisms save configuration and enable a node to operate without any explicit dials, it will just work.
+
+## 1. Bootstrap list of Peers when booting a node
+
+For this demo, we will connect to IPFS default bootstrapper nodes and so, we will need to support the same set of features those nodes have, that are: TCP, multiplex and SECIO. You can see the complete example at [1.js](./1.js).
+
+First, we create our libp2p bundle.
+
+```JavaScript
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [Multiplex],
+        crypto: [SECIO]
+      },
+      discovery: [new Railing(bootstrapers)]
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+In this bundle, we use a `bootstrappers` array listing peers to connect _on boot_. Here is the list used by js-ipfs and go-ipfs.
+
+```JavaScript
+const bootstrapers = [
+  '/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
+  '/ip4/104.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z',
+  '/ip4/104.236.179.241/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM',
+  '/ip4/162.243.248.213/tcp/4001/ipfs/QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm',
+  '/ip4/128.199.219.111/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu',
+  '/ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64',
+  '/ip4/178.62.158.247/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd',
+  '/ip4/178.62.61.185/tcp/4001/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3',
+  '/ip4/104.236.151.122/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx'
+]
+```
+
+Now, once we create and start the node, we can listen for events such as `peer:discovery` and `peer:connect`, these events tell us when we found a peer, independently of the discovery mechanism used and when we actually dialed to that peer.
+
+```
+let node
+
+waterfall([
+  (cb) => PeerInfo.create(cb),
+  (peerInfo, cb) => {
+    peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+    node = new MyBundle(peerInfo)
+    node.start(cb)
+  }
+], (err) => {
+  if (err) { throw err }
+
+  // Emitted when a peer has been found
+  node.on('peer:discovery', (peer) => {
+    console.log('Discovered:', peer.id.toB58String())
+    // Note how we need to dial, even if just to warm up the Connection (by not
+    // picking any protocol) in order to get a full Connection. The Peer Discovery
+    // doesn't make any decisions for you.
+    node.dial(peer, () => {})
+  })
+
+  // Once the dial is complete, this event is emitted.
+  node.on('peer:connect', (peer) => {
+    console.log('Connection established to:', peer.id.toB58String())
+  })
+})
+```
+
+From running [1.js](./1.js), you should see the following:
+
+```bash
+> node 1.js
+Discovered: QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ
+Discovered: QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z
+Discovered: QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM
+Discovered: QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm
+Discovered: QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu
+Discovered: QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64
+Discovered: QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd
+Discovered: QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3
+Discovered: QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+Connection established to: QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3
+Connection established to: QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd
+Connection established to: QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64
+Connection established to: QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm
+Connection established to: QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM
+Connection established to: QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx
+Connection established to: QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ
+Connection established to: QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z
+Connection established to: QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu
+```
+
+## 2. MulticastDNS to find other peers in the network
+
+For this example, we need `libp2p-mdns`, go ahead and `npm install` it. You can find the complete solution at [2.js](./2.js).
+
+Update your libp2p bundle to include MulticastDNS.
+
+```JavaScript
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [Multiplex],
+        crypto: [SECIO]
+      },
+      // We set the interval here to 1 second so that is faster to observe. The
+      // default is 10 seconds.
+      discovery: [new MulticastDNS(peerInfo, { interval: 1000 })]
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+To observe it working, spawn two nodes.
+
+```JavaScript
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+  node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+})
+```
+
+If you run this example, you will see a continuous stream of each peer discovering each other.
+
+```bash
+> node 2.js
+Discovered: QmSSbQpuKrxkoXHm1v4Pi35hPN5hUHMZoBoawEs2Nhvi8m
+Discovered: QmRcXXhtG8vTqwVBRonKWtV4ovDoC1Fe56WYtcrw694eiJ
+Discovered: QmSSbQpuKrxkoXHm1v4Pi35hPN5hUHMZoBoawEs2Nhvi8m
+Discovered: QmRcXXhtG8vTqwVBRonKWtV4ovDoC1Fe56WYtcrw694eiJ
+Discovered: QmSSbQpuKrxkoXHm1v4Pi35hPN5hUHMZoBoawEs2Nhvi8m
+Discovered: QmRcXXhtG8vTqwVBRonKWtV4ovDoC1Fe56WYtcrw694eiJ
+```
+
+## 3. Where to find other Peer Discovery Mechanisms
+
+There are plenty more Peer Discovery Mechanisms out there, you can:
+
+- Find one in [libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star). Yes, a transport with discovery capabilities! This happens because WebRTC requires a rendezvous point for peers to exchange [SDP](https://tools.ietf.org/html/rfc4317) offer, which means we have one or more points that can introduce peers to each other. Think of it as MulticastDNS for the Web, as in MulticastDNS only works in LAN.
+- Any DHT will offer you a discovery capability. You can simple _random-walk_ the routing tables to find other peers to connect to.
+- You can create your own Discovery service, a registry, a list, a radio beacon, you name it!

examples/echo/README.md

@@ -0,0 +1 @@
+# Echo example with libp2p

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

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="
+}

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="
+}

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

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

examples/encrypted-communications/1.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const SPDY = require('libp2p-spdy')
+const SECIO = require('libp2p-secio')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [SPDY],
+        crypto: [SECIO]
+      }
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  node2.handle('/a-protocol', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  node1.dial(node2.peerInfo, '/a-protocol', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['This information is sent out encrypted to the other peer']), conn)
+  })
+})

examples/encrypted-communications/README.md

@@ -0,0 +1,39 @@
+# Encrypted Communications
+
+libp2p can leverage the encrypted communications from the transports it uses (i.e WebRTC). To ensure that every connection is encrypted, independently of how it was set up, libp2p also supports a set of modules that encrypt every communication established.
+
+We call this usage a _connection upgrade_ where given a connection between peer A to peer B, a protocol handshake can be performed that gives that connection new properties.
+
+A byproduct of having these encrypted communications modules is that we can authenticate the peers we are dialing to. You might have noticed that every time we dial to a peer in libp2p space, we always use its PeerId at the end (e.g /ip4/127.0.0.1/tcp/89765/ipfs/QmWCbVw1XZ8hiYBwwshPce2yaTDYTqTaP7GCHGpry3ykWb), this PeerId is generated by hashing the Public Key of the peer. With this, we can create a crypto challenge when dialing to another peer and prove that peer is the owner of a PrivateKey that matches the Public Key we know.
+
+# 1. Set up encrypted communications with SECIO
+
+We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the module `libp2p-secio` to complete it, go ahead and `npm install libp2p-secio`.
+
+SECIO is the crypto channel developed for IPFS, it is a TLS 1.3 like crypto channel that established an encrypted communication channel between two peers.
+
+To add it to your libp2p bundle, all you have to do is:
+
+```JavaScript
+const SECIO = require('libp2p-secio')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [SPDY],
+        // Attach secio as the crypto channel to use
+        crypto: [SECIO]
+      }
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+And that's it, from now on, all your libp2p communications are encrypted. Try running the exampme [1.js](./1.js) to see it working.
+
+If you want to want to learn more about how SECIO works, you can read the [great write up done by Dominic Tarr](https://github.com/auditdrivencrypto/secure-channel/blob/master/prior-art.md#ipfss-secure-channel).
+
+Importante note: SECIO hasn't been audited and so, we do not recommend to trust its security. We intent to move to TLS 1.3 once the specification is finalized and an implementation exists that we can use.

examples/libp2p-in-the-browser/1/.gitignore

@@ -0,0 +1 @@
+bundle.js

examples/libp2p-in-the-browser/1/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "libp2p-in-the-browser",
+  "version": "0.1.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\"}'",
+    "start": "npm run bundle && npm run serve"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "browserify": "^14.0.0",
+    "concat-stream": "^1.6.0",
+    "detect-dom-ready": "^1.0.2",
+    "node-static": "^0.7.9"
+  },
+  "dependencies": {
+    "detect-dom-ready": "^1.0.2",
+    "libp2p": "^0.10.0",
+    "libp2p-multiplex": "^0.4.4",
+    "libp2p-railing": "^0.5.2",
+    "libp2p-secio": "^0.6.8",
+    "libp2p-spdy": "^0.10.6",
+    "libp2p-webrtc-star": "^0.11.0",
+    "libp2p-websockets": "^0.10.0",
+    "peer-info": "^0.9.3"
+  }
+}

examples/libp2p-in-the-browser/1/public/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8"/>
+    <title>libp2p in the browser</title>
+  </head>
+  <body>
+    <h1>libp2p node running \o/</h1>
+    <div id="my-peer"></div>
+    <div id="swarm"></div>
+
+    <script src="bundle.js"></script>
+  </body>
+</html>

examples/libp2p-in-the-browser/1/src/browser-bundle.js

@@ -0,0 +1,53 @@
+'use strict'
+
+const WebRTCStar = require('libp2p-webrtc-star')
+const WebSockets = require('libp2p-websockets')
+
+const Multiplex = require('libp2p-multiplex')
+const SPDY = require('libp2p-spdy')
+const SECIO = require('libp2p-secio')
+
+const Railing = require('libp2p-railing')
+const libp2p = require('libp2p')
+
+// Find this list at: https://github.com/ipfs/js-ipfs/blob/master/src/core/runtime/config-browser.json
+const bootstrapers = [
+  '/dns4/ams-1.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd',
+  '/dns4/sfo-1.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx',
+  '/dns4/lon-1.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3',
+  '/dns4/sfo-2.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z',
+  '/dns4/sfo-3.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM',
+  '/dns4/sgp-1.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu',
+  '/dns4/nyc-1.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm',
+  '/dns4/nyc-2.bootstrap.libp2p.io/tcp/443/wss/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64'
+]
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const wstar = new WebRTCStar()
+
+    const modules = {
+      transport: [
+        wstar,
+        new WebSockets()
+      ],
+      connection: {
+        muxer: [
+          Multiplex,
+          SPDY
+        ],
+        crypto: [SECIO]
+      },
+      discovery: [
+        wstar.discovery,
+        new Railing(bootstrapers)
+      ]
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node

examples/libp2p-in-the-browser/1/src/create-node.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const PeerInfo = require('peer-info')
+const Node = require('./browser-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)
+
+    node.idStr = peerIdStr
+    callback(null, node)
+  })
+}
+
+module.exports = createNode

examples/libp2p-in-the-browser/1/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) => {})
+    })
+  })
+})

examples/libp2p-in-the-browser/README.md

@@ -0,0 +1,14 @@
+# libp2p running in the Browser
+
+One of the primary goals with libp2p P2P was to get it fully working in the browser and interopable with the versions running in Go and in Node.js.
+
+# 1. Setting up a simple app that lists connections to other nodes
+
+Simple go into the folder [1](./1) and execute the following
+
+```bash
+> cd 1
+> npm install
+> npm start
+# open your browser in port :9090
+```

examples/nat-traversal/README.md

@@ -0,0 +1,2 @@
+# WIP - This example is still in the works
+![](http://1.bp.blogspot.com/-tNvSnCW0KlQ/U-KOKGVoJkI/AAAAAAAAA3Q/aiSLMeSJFtw/s1600/WIP-sign.jpg)

examples/peer-routing/README.md

@@ -0,0 +1,2 @@
+# WIP - This example is still in the works
+![](http://1.bp.blogspot.com/-tNvSnCW0KlQ/U-KOKGVoJkI/AAAAAAAAA3Q/aiSLMeSJFtw/s1600/WIP-sign.jpg)

examples/protocol-and-stream-muxing/1.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  // exact matching
+  node2.handle('/your-protocol', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  // semver matching
+  /*
+  node2.handle('/another-protocol/1.0.1', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+  */
+
+  // custom func matching
+  /*
+  node2.handle('/custom-match-func', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  }, (myProtocol, requestedProtocol, callback) => {
+    if (myProtocol.indexOf(requestedProtocol)) {
+      callback(null, true)
+    } else {
+      callback(null, false)
+    }
+  })
+  */
+
+  node1.dial(node2.peerInfo, '/your-protocol', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['my own protocol, wow!']), conn)
+  })
+
+  /*
+  node1.dial(node2.peerInfo, '/another-protocol/1.0.0', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['semver me please']), conn)
+  })
+  */
+
+  /*
+  node1.dial(node2.peerInfo, '/custom-match-func/some-query', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['do I fall into your criteria?']), conn)
+  })
+  */
+})

examples/protocol-and-stream-muxing/2.js

@@ -0,0 +1,79 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const SPDY = require('libp2p-spdy')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [SPDY]
+      }
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  node2.handle('/a', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  node2.handle('/b', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  series([
+    (cb) => node1.dial(node2.peerInfo, '/a', (err, conn) => {
+      if (err) { throw err }
+      pull(pull.values(['protocol (a)']), conn)
+      cb()
+    }),
+    (cb) => node1.dial(node2.peerInfo, '/b', (err, conn) => {
+      if (err) { throw err }
+      pull(pull.values(['protocol (b)']), conn)
+      cb()
+    }),
+    (cb) => node1.dial(node2.peerInfo, '/b', (err, conn) => {
+      if (err) { throw err }
+      pull(pull.values(['another conn on protocol (b)']), conn)
+      cb()
+    })
+  ])
+})

examples/protocol-and-stream-muxing/3.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const SPDY = require('libp2p-spdy')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      connection: {
+        muxer: [SPDY]
+      }
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  node1.handle('/node-1', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  node2.handle('/node-2', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  series([
+    (cb) => node1.dial(node2.peerInfo, '/node-2', (err, conn) => {
+      if (err) { throw err }
+      pull(pull.values(['from 1 to 2']), conn)
+      cb()
+    }),
+    (cb) => node2.dial(node1.peerInfo, '/node-1', (err, conn) => {
+      if (err) { throw err }
+      pull(pull.values(['from 2 to 1']), conn)
+      cb()
+    })
+  ], (err) => {
+    if (err) { throw err }
+    console.log('Addresses by which both peers are connected')
+    node1.peerBook
+         .getAllArray()
+         .forEach((peer) => console.log('node 1 to node 2:', peer.isConnected().toString()))
+    node2.peerBook
+         .getAllArray()
+         .forEach((peer) => console.log('node 2 to node 1:', peer.isConnected().toString()))
+  })
+})

examples/protocol-and-stream-muxing/README.md

@@ -0,0 +1,174 @@
+# Protocol and Stream Multiplexing (aka muxing)
+
+One of the specialties of libp2p is solving the bane of protocol discovery and handshake between machines. Before libp2p, you would have to assign a listener to a port and then through some process of formal specification you would assign ports to special protocols so that other hosts would know before hand which port to dial (e.g ssh (22), http (80), https (443), ftp (21), etc). With libp2p you don't need to do that anymore, not only you don't have to assign ports before hand, you don't even need to think about ports at all since all the protocol handshaking happens in the wire!
+
+The feature of agreeing on a protocol over an established connection is what we call _protocol multiplexing_ and it is possible through [multistream-select](https://github.com/multiformats/multistream), another protocol that lets you agree per connection (or stream) which protocol is going to be talked over that connection (select), it also enables you to request the other end to tell you which protocols it supports (ls). You can learn more about multistream-select at its [specification repo](https://github.com/multiformats/multistream).
+
+# 1. Handle multiple protocols
+
+Let's see _protocol multiplexing_ in action! You will need the following modules for this example: `libp2p`, `libp2p-tcp`, `peer-info`, `async` and `pull-stream`. This example reuses the base left by the [Transports](../transports) example. You can see the complete solution at [1.js](./1.js).
+
+After creating the nodes, we need to tell libp2p which protocols to handle. 
+
+```JavaScript
+// ...
+const node1 = nodes[0]
+const node2 = nodes[1]
+
+// Here we are telling libp2p that is someone dials this node to talk with the `/your-protocol`
+// multicodec, the protocol identifier, please call this callback and give it the connection
+// so that incomming data can be handled
+node2.handle('/your-protocol', (protocol, conn) => {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+})
+```
+
+After the protocol is _handled_, now we can dial to it.
+
+```JavaScript
+node1.dial(node2.peerInfo, '/your-protocol', (err, conn) => {
+  if (err) { throw err }
+  pull(pull.values(['my own protocol, wow!']), conn)
+})
+```
+
+You might have seen this in the [Transports](../transports) examples. However, what it was not explained is that you can do more than exact string matching, for example, you can use semver.
+
+```JavaScript
+node2.handle('/another-protocol/1.0.1', (protocol, conn) => {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+})
+// ...
+node1.dial(node2.peerInfo, '/another-protocol/1.0.0', (err, conn) => {
+  if (err) { throw err }
+  pull(pull.values(['semver me please']), conn)
+})
+```
+
+This feature is super power for network protocols. It works in the same way as versioning your RPC/REST API, but for anything that goes in the wire. We had to use this feature to upgrade protocols within the IPFS Stack (i.e Bitswap) and we successfully managed to do so without any network splits.
+
+There is still one last feature, you can create your custom match functions. 
+
+```JavaScript
+node2.handle('/custom-match-func', (protocol, conn) => {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+}, (myProtocol, requestedProtocol, callback) => {
+  // This is all custom. I'm checking the base path matches, think of this
+  // as a HTTP routing table.
+  if (myProtocol.indexOf(requestedProtocol)) {
+    callback(null, true)
+  } else {
+    callback(null, false)
+  }
+})
+// ...
+node1.dial(node2.peerInfo, '/custom-match-func/some-query', (err, conn) => {
+  if (err) { throw err }
+  pull(pull.values(['do I fall into your criteria?']), conn)
+})
+```
+
+Try all of this out by executing [1.js](./1.js).
+
+# 2. Reuse existing connection
+
+The example above would require a node to create a whole new connection for every time it dials in one of the protocols, this is a waste of resources and also it might be simply not possible (e.g lack of file descriptors, not enough ports being open, etc). What we really want is to dial a connection once and then multiplex several virtual connections (stream) over a single connection, this is where _stream multiplexing_ comes into play.
+
+Stream multiplexing is a old concept, in fact it happens in many of the layers of the [OSI System](https://en.wikipedia.org/wiki/OSI_model), in libp2p we make this feature to our avail by letting the user pick which module for stream multiplexing to use.
+
+Currently, we have two available [libp2p-spdy](https://github.com/libp2p/js-libp2p-spdy) and [libp2p-multiplex](https://github.com/libp2p/js-libp2p-multiplex) and pluging them in is as easy as adding another transport. Let's revisit our libp2p bundle.
+
+```JavaScript
+const SPDY = require('libp2p-spdy')
+//...
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()],
+      // Here we are adding the SPDY muxer to our libp2p bundle.
+      // Thanks to protocol muxing, a libp2p bundle can support multiple Stream Muxers at the same
+      // time and pick the right one when dialing to a node
+      connection: {
+        muxer: [SPDY]
+      }
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+With this, we can dial as many times as we want to a peer and always reuse the same established underlying connection.
+
+```JavaScript
+node2.handle('/a', (protocol, conn) => {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+})
+
+node2.handle('/b', (protocol, conn) => {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+})
+
+series([
+  (cb) => node1.dial(node2.peerInfo, '/a', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['protocol (a)']), conn)
+    cb()
+  }),
+  (cb) => node1.dial(node2.peerInfo, '/b', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['protocol (b)']), conn)
+    cb()
+  }),
+  (cb) => node1.dial(node2.peerInfo, '/b', (err, conn) => {
+    if (err) { throw err }
+    pull(pull.values(['another conn on protocol (b)']), conn)
+    cb()
+  })
+])
+```
+
+By running [2.js](./2.js) you should see the following result:
+
+```
+> node 2.js
+protocol (a)
+protocol (b)
+another protocol (b)
+```
+
+# 3. Bidirectional connections
+
+There is one last trick on _protocol and stream multiplexing_ that libp2p uses to make everyone's life easier and that is _biderectional connection_.
+
+With the aid of both mechanisms, we can reuse an incomming connection to dial streams out too, this is specially useful when you are behind tricky NAT, firewalls or if you are running in a browser, where you can have listening addrs, but you can dial out. By dialing out, you enable other peers to talk with you in Protocols that they want, simply by opening a new multiplexed stream.
+
+You can see this working on example [3.js](./3.js). The result should look like the following:
+
+```Bash
+> node 3.js
+from 1 to 2
+Addresses by which both peers are connected
+node 1 to node 2: /ip4/127.0.0.1/tcp/50629/ipfs/QmZwMKTo6wG4Te9A6M2eJnWDpR8uhsGed4YRegnV5DcKiv
+node 2 to node 1: /ip4/127.0.0.1/tcp/50630/ipfs/QmRgormJQeDyXhDKma11eUtksoh8vWmeBoxghVt4meauW9
+from 2 to 1
+```

examples/pubsub/README.md

@@ -0,0 +1,2 @@
+# WIP - This example is still in the works
+![](http://1.bp.blogspot.com/-tNvSnCW0KlQ/U-KOKGVoJkI/AAAAAAAAA3Q/aiSLMeSJFtw/s1600/WIP-sign.jpg)

examples/transports/1.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+let node
+
+waterfall([
+  (cb) => PeerInfo.create(cb),
+  (peerInfo, cb) => {
+    peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+    node = new MyBundle(peerInfo)
+    node.start(cb)
+  }
+], (err) => {
+  if (err) { throw err }
+
+  console.log('node has started (true/false):', node.isOn())
+  console.log('listening on:')
+  node.peerInfo.multiaddrs.forEach((ma) => console.log(ma.toString()))
+})

examples/transports/2.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+function printAddrs (node, number) {
+  console.log('node %s is listening on:', number)
+  node.peerInfo.multiaddrs.forEach((ma) => console.log(ma.toString()))
+}
+
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  printAddrs(node1, '1')
+  printAddrs(node2, '2')
+
+  node2.handle('/print', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  node1.dial(node2.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['Hello', ' ', 'p2p', ' ', 'world', '!']), conn)
+  })
+})

examples/transports/3.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP(), new WebSockets()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+function createNode (addrs, callback) {
+  if (!Array.isArray(addrs)) {
+    addrs = [addrs]
+  }
+
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      addrs.forEach((addr) => peerInfo.multiaddrs.add(addr))
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+function printAddrs (node, number) {
+  console.log('node %s is listening on:', number)
+  node.peerInfo.multiaddrs.forEach((ma) => console.log(ma.toString()))
+}
+
+function print (protocol, conn) {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+}
+
+parallel([
+  (cb) => createNode('/ip4/0.0.0.0/tcp/0', cb),
+  (cb) => createNode(['/ip4/0.0.0.0/tcp/0', '/ip4/127.0.0.1/tcp/10000/ws'], cb),
+  (cb) => createNode('/ip4/127.0.0.1/tcp/20000/ws', cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+  const node3 = nodes[2]
+
+  printAddrs(node1, '1')
+  printAddrs(node2, '2')
+  printAddrs(node3, '3')
+
+  node1.handle('/print', print)
+  node2.handle('/print', print)
+  node3.handle('/print', print)
+
+  node1.dial(node2.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['node 1 dialed to node 2 successfully']), conn)
+  })
+
+  node2.dial(node3.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['node 2 dialed to node 3 successfully']), conn)
+  })
+
+  node3.dial(node1.peerInfo, '/print', (err, conn) => {
+    if (err) {
+      console.log('node 3 failed to dial to node 1 with:', err.message)
+    }
+  })
+})

examples/transports/README.md

@@ -0,0 +1,305 @@
+# [Transports](http://libp2p.io/implementations/#transports)
+
+libp2p doesn't make assumptions for you, instead, it enables you as the developer of the application to pick the modules you need to run your application, which can vary depending on the runtime you are executing. A libp2p node can use one or more Transports to dial and listen for Connections. These transports are modules that offer a clean interface for dialing and listening, defined by the [interface-transport](https://github.com/libp2p/interface-transport) specification. Some examples of possible transports are: TCP, UTP, WebRTC, QUIC, HTTP, Pigeon and so on.
+
+A more complete definition of what is a transport can be found on the [interface-transport](https://github.com/libp2p/interface-transport) specification. A way to recognize a candidate transport is through the badge:
+
+[![](https://raw.githubusercontent.com/diasdavid/interface-transport/master/img/badge.png)](https://raw.githubusercontent.com/diasdavid/interface-transport/master/img/badge.png)
+
+## 1. Creating a libp2p Bundle with TCP
+
+When using libp2p, you always want to create your own libp2p Bundle, that is, pick your set of modules and create your network stack with the properties you need. In this example, we will create a bundle with TCP. You can find the complete solution on the file [1.js](/1.js).
+
+You will need 4 deps total, so go ahead and install all of them with: 
+
+```
+> npm install libp2p libp2p-tcp peer-info async
+```
+
+Then, on your favorite text editor create a file with the `.js` extension. I've called mine `1.js`.
+
+First thing is to create our own bundle! Insert:
+
+```JavaScript
+'use strict'
+
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+
+// This MyBundle class is your libp2p bundle packed with TCP
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    // modules is a JS object that will describe the components
+    // we want for our libp2p bundle
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+Now that we have our own MyBundle class that extends libp2p, let's create a node with it. We will use `async/waterfall` just for code structure, but you don't need to. Append to the same file:
+
+```JavaScript
+let node
+
+waterfall([
+  // First we create a PeerInfo object, which will pack the
+  // info about our peer. Creating a PeerInfo is an async
+  // operation because we use the WebCrypto API
+  // (yeei Universal JS)
+  (cb) => PeerInfo.create(cb),
+  (peerInfo, cb) => {
+    // To signall the addresses we want to be available, we use
+    // the multiaddr format, a self describable address
+    peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+    // Now we can create a node with that PeerInfo object
+    node = new MyBundle(peerInfo)
+    // Last, we start the node!
+    node.start(cb)
+  }
+], (err) => {
+  if (err) { throw err }
+
+  // At this point the node has started
+  console.log('node has started (true/false):', node.isOn())
+  // And we can print the now listening addresses.
+  // If you are familiar with TCP, you might have noticed
+  // that we specified the node to listen in 0.0.0.0 and port
+  // 0, which means "listen in any network interface and pick
+  // a port for me
+  console.log('listening on:')
+  node.peerInfo.multiaddrs.forEach((ma) => console.log(ma.toString()))
+})
+```
+
+Running this should result in somehting like:
+
+```bash
+> node 1.js
+node has started (true/false): true
+listening on:
+/ip4/127.0.0.1/tcp/61329/ipfs/QmW2cKTakTYqbQkUzBTEGXgWYFj1YEPeUndE1YWs6CBzDQ
+/ip4/192.168.2.156/tcp/61329/ipfs/QmW2cKTakTYqbQkUzBTEGXgWYFj1YEPeUndE1YWs6CBzDQ
+```
+
+That `QmW2cKTakTYqbQkUzBTEGXgWYFj1YEPeUndE1YWs6CBzDQ` is the PeerId that was created during the PeerInfo generation.
+
+## 2. Dialing from one node to another node
+
+Now that we have our bundle, let's create two nodes and make them dial to each other! You can find the complete solution at [2.js](/2.js).
+
+For this step, we will need one more dependency.
+
+```bash
+> npm install pull-stream
+```
+
+We are going to reuse the MyBundle class from step 1, but this time to make things simpler, we will create two functions, one to create nodes and another to print the addrs to avoid duplicating code.
+
+```JavaScript
+function createNode (callback) {
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/0')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+
+function printAddrs (node, number) {
+  console.log('node %s is listening on:', number)
+  node.peerInfo.multiaddrs.forEach((ma) => console.log(ma.toString()))
+}
+```
+
+Now we are going to use `async/parallel` to create two nodes, print their addresses and dial from one node to the other.
+
+```
+parallel([
+  (cb) => createNode(cb),
+  (cb) => createNode(cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+
+  printAddrs(node1, '1')
+  printAddrs(node2, '2')
+
+  node2.handle('/print', (protocol, conn) => {
+    pull(
+      conn,
+      pull.map((v) => v.toString()),
+      pull.log()
+    )
+  })
+
+  node1.dial(node2.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['Hello', ' ', 'p2p', ' ', 'world', '!']), conn)
+  })
+})
+```
+
+The result should be look like:
+
+```bash
+> node 2.js
+node 1 is listening on:
+/ip4/127.0.0.1/tcp/62279/ipfs/QmeM4wNWv1uci7UJjUXZYfvcy9uqAbw7G9icuxdqy88Mj9
+/ip4/192.168.2.156/tcp/62279/ipfs/QmeM4wNWv1uci7UJjUXZYfvcy9uqAbw7G9icuxdqy88Mj9
+node 2 is listening on:
+/ip4/127.0.0.1/tcp/62278/ipfs/QmWp58xJgzbouNJcyiNNTpZuqQCJU8jf6ixc7TZT9xEZhV
+/ip4/192.168.2.156/tcp/62278/ipfs/QmWp58xJgzbouNJcyiNNTpZuqQCJU8jf6ixc7TZT9xEZhV
+Hello p2p world!
+```
+
+## 3. Using multiple transports
+
+Next, we want to be available in multiple transports to increase our chances of having common transports in the network. A simple scenario, a node running in the browser only has access to HTTP, WebSockets and WebRTC since the browser doesn't let you open any other kind of transport, for this node to dial to some other node, that other node needs to share a common transport.
+
+What we are going to do in this step is to create 3 nodes, one with TCP, another with TCP+WebSockets and another one with just WebSockets. The full solution can be found on [3.js](3.js).
+
+In this example, we will need to also install `libp2p-websockets`, go ahead and install:
+
+```sh
+> npm install libp2p-websockets
+```
+
+We want to create 3 nodes, one with TCP, one with TCP+WebSockets and one with just WebSockets. We need to update our `MyBundle` class to contemplate WebSockets as well:
+
+```JavaScript
+const WebSockets = require('libp2p-websockets')
+// ...
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP(), new WebSockets()]
+    }
+    super(modules, peerInfo)
+  }
+}
+```
+
+Now that we have our bundle ready, let's upgrade our createNode function to enable us to pick the addrs in which a node will start a listener.
+
+```JavaScript
+function createNode (addrs, callback) {
+  if (!Array.isArray(addrs)) {
+    addrs = [addrs]
+  }
+
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(cb),
+    (peerInfo, cb) => {
+      addrs.forEach((addr) => peerInfo.multiaddrs.add(addr))
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => callback(err, node))
+}
+```
+
+As a rule, a libp2p node will only be capable of using a transport if: a) it has the module for it and b) it was given a multiaddr to listen on. The only exception to this rule is WebSockets in the browser, where a node can dial out, but unfortunately cannot open a socket.
+
+Let's update our flow to create nodes and see how they behave when dialing to each other:
+
+```JavaScript
+parallel([
+  (cb) => createNode('/ip4/0.0.0.0/tcp/0', cb),
+  // Here we add an extra multiaddr that has a /ws at the end, this means that we want
+  // to create a TCP socket, but mount it as WebSockets instead.
+  (cb) => createNode(['/ip4/0.0.0.0/tcp/0', '/ip4/127.0.0.1/tcp/10000/ws'], cb),
+  (cb) => createNode('/ip4/127.0.0.1/tcp/20000/ws', cb)
+], (err, nodes) => {
+  if (err) { throw err }
+
+  const node1 = nodes[0]
+  const node2 = nodes[1]
+  const node3 = nodes[2]
+
+  printAddrs(node1, '1')
+  printAddrs(node2, '2')
+  printAddrs(node3, '3')
+
+  node1.handle('/print', print)
+  node2.handle('/print', print)
+  node3.handle('/print', print)
+
+  // node 1 (TCP) dials to node 2 (TCP+WebSockets)
+  node1.dial(node2.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['node 1 dialed to node 2 successfully']), conn)
+  })
+
+  // node 2 (TCP+WebSockets) dials to node 2 (WebSockets)
+  node2.dial(node3.peerInfo, '/print', (err, conn) => {
+    if (err) { throw err }
+
+    pull(pull.values(['node 2 dialed to node 3 successfully']), conn)
+  })
+
+  // node 3 (WebSockets) attempts to dial to node 1 (TCP)
+  node3.dial(node1.peerInfo, '/print', (err, conn) => {
+    if (err) {
+      console.log('node 3 failed to dial to node 1 with:', err.message)
+    }
+  })
+})
+```
+
+`print` is a function created using the code from 2.js, but factored into its own function to save lines, here it is:
+
+```JavaScript
+function print (protocol, conn) {
+  pull(
+    conn,
+    pull.map((v) => v.toString()),
+    pull.log()
+  )
+}
+```
+
+If everything was set correctly, you now should see the following after you run the script:
+
+```Bash
+> node 3.js
+node 1 is listening on:
+/ip4/127.0.0.1/tcp/62620/ipfs/QmWpWmcVJkF6EpmAaVDauku8g1uFGuxPsGP35XZp9GYEqs
+/ip4/192.168.2.156/tcp/62620/ipfs/QmWpWmcVJkF6EpmAaVDauku8g1uFGuxPsGP35XZp9GYEqs
+node 2 is listening on:
+/ip4/127.0.0.1/tcp/10000/ws/ipfs/QmWAQtWdzWXibgfyc7WRHhhv6MdqVKzXvyfSTnN2aAvixX
+/ip4/127.0.0.1/tcp/62619/ipfs/QmWAQtWdzWXibgfyc7WRHhhv6MdqVKzXvyfSTnN2aAvixX
+/ip4/192.168.2.156/tcp/62619/ipfs/QmWAQtWdzWXibgfyc7WRHhhv6MdqVKzXvyfSTnN2aAvixX
+node 3 is listening on:
+/ip4/127.0.0.1/tcp/20000/ws/ipfs/QmVq1PWh3VSDYdFqYMtqp4YQyXcrH27N7968tGdM1VQPj1
+node 3 failed to dial to node 1 with: No available transport to dial to
+node 1 dialed to node 2 successfully
+node 2 dialed to node 3 successfully
+```
+
+As expected, we created 3 nodes, node 1 with TCP, node 2 with TCP+WebSockets and node 3 with just WebSockets. node 1 -> node 2 and node 2 -> node 3 managed to dial correctly because they shared a common transport, however, node 3 -> node 1 failed because they didn't share any.
+
+## 4. How to create a new libp2p transport
+
+Today there are already 3 transports available, one in the works and plenty to come, you can find these at [interface-transport implementations](https://github.com/libp2p/interface-transport#modules-that-implement-the-interface) list.
+
+Adding more transports is done through the same way as you added TCP and WebSockets. Some transports might offer extra functionalities but for what is libp2p concern, as long as it follows the interface defined at the [spec](https://github.com/libp2p/interface-transport#api), it will be able to use it.
+
+If you decide to implement a transport yourself, please consider adding to the list so that others can use it as well.
+
+Hope this tutorial was useful. We are always looking to improve it, contributions are welcome!

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)

package.json

@@ -1,14 +1,17 @@
 {
   "name": "libp2p",
-  "version": "0.5.1",
-  "description": "JavaScript Skeleton for libp2p bundles",
+  "version": "0.10.1",
+  "description": "JavaScript base class for libp2p bundles",
   "main": "src/index.js",
   "scripts": {
-    "test": "aegir-test node",
+    "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",
-    "release": "aegir-release node",
-    "release-minor": "aegir-release --type minor",
-    "release-major": "aegir-release --type major",
     "coverage": "aegir-coverage",
     "coverage-publish": "aegir-coverage publish"
   },
@@ -32,24 +35,46 @@
   "bugs": {
     "url": "https://github.com/libp2p/js-libp2p/issues"
   },
-  "homepage": "https://github.com/diasdavid/js-libp2p",
+  "homepage": "https://github.com/libp2p/js-libp2p",
   "devDependencies": {
-    "chai": "^3.5.0",
-    "aegir": "^9.4.0",
-    "pre-commit": "^1.2.2"
+    "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.4",
+    "libp2p-railing": "^0.5.2",
+    "libp2p-secio": "^0.6.8",
+    "libp2p-spdy": "^0.10.6",
+    "libp2p-swarm": "^0.29.2",
+    "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": {
-    "libp2p-ping": "^0.3.0",
-    "libp2p-swarm": "^0.26.13",
-    "mafmt": "^2.1.6",
-    "multiaddr": "^2.2.0",
-    "peer-book": "^0.3.0",
-    "peer-id": "^0.8.1",
-    "peer-info": "^0.8.2"
+    "async": "^2.5.0",
+    "libp2p-ping": "~0.4.0",
+    "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>"

src/index.js

@@ -1,58 +1,60 @@
 'use strict'
 
+const EventEmitter = require('events').EventEmitter
+const assert = require('assert')
+
+const setImmediate = require('async/setImmediate')
+const each = require('async/each')
+const series = require('async/series')
+
+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 multiaddr = require('multiaddr')
 const mafmt = require('mafmt')
-const EE = require('events').EventEmitter
-const assert = require('assert')
-const Ping = require('libp2p-ping')
+const multiaddr = require('multiaddr')
 
 exports = module.exports
 
-const OFFLINE_ERROR_MESSAGE = 'The libp2p node is not started yet'
-const IPFS_CODE = 421
+const NOT_STARTED_ERROR_MESSAGE = 'The libp2p node is not started yet'
 
-class Node {
+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.isOnline = false
+    this._isStarted = false
 
-    this.discovery = new EE()
-
-    this.swarm = new Swarm(this.peerInfo)
+    this.swarm = new Swarm(this.peerInfo, this.peerBook)
 
     // Attach stream multiplexers
-    if (this.modules.connection.muxer) {
+    if (this.modules.connection && this.modules.connection.muxer) {
       let muxers = this.modules.connection.muxer
       muxers = Array.isArray(muxers) ? muxers : [muxers]
-      muxers.forEach((muxer) => {
-        this.swarm.connection.addStreamMuxer(muxer)
-      })
+      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
+      // 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.peerBook.removeByB58String(peerInfo.id.toB58String())
+        this.emit('peer:disconnect', peerInfo)
       })
     }
 
     // Attach crypto channels
-    if (this.modules.connection.crypto) {
+    if (this.modules.connection && this.modules.connection.crypto) {
       let cryptos = this.modules.connection.crypto
       cryptos = Array.isArray(cryptos) ? cryptos : [cryptos]
       cryptos.forEach((crypto) => {
@@ -64,19 +66,70 @@ class Node {
     if (this.modules.discovery) {
       let discoveries = this.modules.discovery
       discoveries = Array.isArray(discoveries) ? discoveries : [discoveries]
+
       discoveries.forEach((discovery) => {
-        discovery.on('peer', (peerInfo) => {
-          this.discovery.emit('peer', peerInfo)
-        })
+        discovery.on('peer', (peerInfo) => this.emit('peer:discovery', peerInfo))
       })
     }
 
     // Mount default protocols
     Ping.mount(this.swarm)
 
-    // Not fully implemented in js-libp2p yet
-    this.routing = undefined
-    this.records = undefined
+    // 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)
+      }
+    }
   }
 
   /*
@@ -92,7 +145,18 @@ class Node {
     let transports = this.modules.transport
 
     transports = Array.isArray(transports) ? transports : [transports]
-    const multiaddrs = this.peerInfo.multiaddrs
+
+    // 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) {
@@ -106,31 +170,41 @@ class Node {
       }
     })
 
-    this.swarm.listen((err) => {
-      if (err) {
-        return callback(err)
-      }
-      if (ws) {
-        this.swarm.transport.add(ws.tag || ws.constructor.name, ws)
-      }
+    series([
+      (cb) => this.swarm.listen(cb),
+      (cb) => {
+        if (ws) {
+          // always add dialing on websockets
+          this.swarm.transport.add(ws.tag || ws.constructor.name, ws)
+        }
 
-      this.isOnline = true
-
-      if (this.modules.discovery) {
-        this.modules.discovery.forEach((discovery) => {
-          setImmediate(() => discovery.start(() => {}))
-        })
+        // 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()
-    })
+    ], callback)
   }
 
   /*
    * Stop the libp2p node by closing its listeners and open connections
    */
   stop (callback) {
-    this.isOnline = false
+    this._isStarted = false
 
     if (this.modules.discovery) {
       this.modules.discovery.forEach((discovery) => {
@@ -138,145 +212,71 @@ class Node {
       })
     }
 
-    this.swarm.close(callback)
-  }
-
-  //
-  // Ping
-  //
-
-  // TODO
-  pingById (id, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-    callback(new Error('not implemented yet'))
-  }
-
-  // TODO
-  pingByMultiaddr (maddr, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-    callback(new Error('not implemented yet'))
-  }
-
-  pingByPeerInfo (peerInfo, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-    callback(null, new Ping(this.swarm, peerInfo))
-  }
-
-  //
-  // Dialing methods
-  //
-
-  // TODO
-  dialById (id, protocol, callback) {
-    // NOTE: dialById only works if a previous dial was made. This will
-    // change once we have PeerRouting
-
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-
-    if (typeof protocol === 'function') {
-      callback = protocol
-      protocol = undefined
-    }
-
-    callback(new Error('not implemented yet'))
-  }
-
-  dialByMultiaddr (maddr, protocol, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-
-    if (typeof protocol === 'function') {
-      callback = protocol
-      protocol = undefined
-    }
-
-    if (typeof maddr === 'string') {
-      maddr = multiaddr(maddr)
-    }
-
-    if (!mafmt.IPFS.matches(maddr.toString())) {
-      return callback(new Error('multiaddr not valid'))
-    }
-
-    const ipfsIdB58String = maddr.stringTuples().filter((tuple) => {
-      if (tuple[0] === IPFS_CODE) {
-        return true
+    series([
+      (cb) => {
+        if (this._dht) {
+          return this._dht.stop(cb)
+        }
+        cb()
+      },
+      (cb) => this.swarm.close(cb),
+      (cb) => {
+        this.emit('stop')
+        cb()
       }
-    })[0][1]
-
-    let peer
-    try {
-      peer = this.peerBook.getByB58String(ipfsIdB58String)
-    } catch (err) {
-      peer = new PeerInfo(PeerId.createFromB58String(ipfsIdB58String))
-    }
-
-    peer.multiaddr.add(maddr)
-    this.dialByPeerInfo(peer, protocol, callback)
+    ], callback)
   }
 
-  dialByPeerInfo (peer, protocol, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
+  isStarted () {
+    return this._isStarted
+  }
 
-    if (typeof protocol === 'function') {
-      callback = protocol
-      protocol = undefined
-    }
-
-    this.swarm.dial(peer, protocol, (err, conn) => {
+  ping (peer, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
+    this._getPeerInfo(peer, (err, peerInfo) => {
       if (err) {
         return callback(err)
       }
-      this.peerBook.put(peer)
-      callback(null, conn)
+
+      callback(null, new Ping(this.swarm, peerInfo))
     })
   }
 
-  //
-  // Disconnecting (hangUp) methods
-  //
+  dial (peer, protocol, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
 
-  hangUpById (id, callback) {
-    // TODO
-    callback(new Error('not implemented yet'))
-  }
-
-  hangUpByMultiaddr (maddr, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
-
-    if (typeof maddr === 'string') {
-      maddr = multiaddr(maddr)
+    if (typeof protocol === 'function') {
+      callback = protocol
+      protocol = undefined
     }
 
-    if (!mafmt.IPFS.matches(maddr.toString())) {
-      return callback(new Error('multiaddr not valid'))
-    }
-
-    const ipfsIdB58String = maddr.stringTuples().filter((tuple) => {
-      if (tuple[0] === IPFS_CODE) {
-        return true
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
       }
-    })[0][1]
 
-    try {
-      const pi = this.peerBook.getByB58String(ipfsIdB58String)
-      this.hangUpByPeerInfo(pi, callback)
-    } catch (err) {
-      // already disconnected
-      callback()
-    }
+      this.swarm.dial(peerInfo, protocol, (err, conn) => {
+        if (err) {
+          return callback(err)
+        }
+        this.peerBook.put(peerInfo)
+        callback(null, conn)
+      })
+    })
   }
 
-  hangUpByPeerInfo (peer, callback) {
-    assert(this.isOnline, OFFLINE_ERROR_MESSAGE)
+  hangUp (peer, callback) {
+    assert(this.isStarted(), NOT_STARTED_ERROR_MESSAGE)
 
-    this.peerBook.removeByB58String(peer.id.toB58String())
-    this.swarm.hangUp(peer, callback)
+    this._getPeerInfo(peer, (err, peerInfo) => {
+      if (err) {
+        return callback(err)
+      }
+
+      this.swarm.hangUp(peerInfo, callback)
+    })
   }
 
-  //
-  // Protocol multiplexing handling
-  //
-
   handle (protocol, handlerFunc, matchFunc) {
     this.swarm.handle(protocol, handlerFunc, matchFunc)
   }
@@ -284,6 +284,38 @@ class Node {
   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

test/base.js

@@ -1,12 +1,14 @@
 /* eslint-env mocha */
 'use strict'
 
-const expect = require('chai').expect
+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
+    expect(libp2p).to.exist()
   })
 })

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

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="
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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="
+}

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

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