chore: release version v0.22.2

update the dependencies

.aegir.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const path = require('path')
+
+module.exports = {
+  webpack: {
+    resolve: {
+      alias: {
+        'node-forge': path.resolve(
+          path.dirname(require.resolve('libp2p-crypto')),
+          '../vendor/forge.bundle.js'
+        )
+      }
+    },
+    externals: {
+      'simple-websocket-server': '{}'
+    }
+  }
+}

.gitignore

@@ -29,5 +29,6 @@ node_modules
 
 
 coverage
-.jshintrc
-.jshintignore
+
+dist
+lib

.npmignore

@@ -0,0 +1,35 @@
+test
+
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+node_modules
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history

.travis.yml

@@ -1,7 +1,8 @@
 sudo: false
 language: node_js
 node_js:
-  - "4.0"
+  - 4
+  - 5
 
 # Make sure we have new NPM.
 before_install:
@@ -10,3 +11,14 @@ before_install:
 script:
   - npm run lint
   - npm test
+  - npm run coverage
+
+addons:
+  firefox: 'latest'
+
+before_script:
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start
+
+after_success:
+  - npm run coverage-publish

README.md

@@ -1,22 +1,43 @@
 libp2p-swarm JavaScript implementation
 ======================================
 
-[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io) 
-[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) 
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
 [![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
-[![Build Status](https://img.shields.io/travis/diasdavid/js-libp2p-swarm/master.svg?style=flat-square)](https://travis-ci.org/diasdavid/js-libp2p-swarm)
+[![Build Status](https://img.shields.io/travis/libp2p/js-libp2p-swarm/master.svg?style=flat-square)](https://travis-ci.org/libp2p/js-libp2p-swarm)
+[![Coverage Status](https://coveralls.io/repos/github/libp2p/js-libp2p-swarm/badge.svg?branch=master)](https://coveralls.io/github/libp2p/js-libp2p-swarm?branch=master)
+[![Dependency Status](https://david-dm.org/libp2p/js-libp2p-swarm.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-swarm)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
 
-> libp2p swarm implementation in JavaScript
+> libp2p swarm implementation in JavaScript.
 
-# Description
+libp2p-swarm is a connection abstraction that is able to leverage several transports and connection upgrades, such as congestion control, channel encryption, the multiplexing of several streams in one connection, and more. It does this by bringing protocol multiplexing to the application level (instead of the traditional Port level) using multicodec and multistream.
 
-libp2p-swarm is a connection abstraction that is able to leverage several transports and connection upgrades, such as congestion control, channel encryption, multiplexing several streams in one connection, and more. It does this by bringing protocol multiplexing to the application level (instead of the traditional Port level) using multicodec and multistream.
+libp2p-swarm is used by [libp2p](https://github.com/libp2p/js-libp2p) but it can be also used as a standalone module.
 
-libp2p-swarm is used by libp2p but it can be also used as a standalone module.
+## Table of Contents
 
-# Usage
+- [Install](#install)
+- [Usage](#usage)
+  - [Create a libp2p Swarm](#create-a-libp2p-swarm)
+- [API](#api)
+  - [Transports](#transports)
+  - [Connection](#connection)
+  - [`swarm.dial(pi, protocol, callback)`](#swarmdialpi-protocol-callback)
+  - [`swarm.hangUp(pi, callback)`](#swarmhanguppi-callback)
+  - [`swarm.listen(callback)`](#swarmlistencallback)
+  - [`swarm.handle(protocol, handler)`](#swarmhandleprotocol-handler)
+  - [`swarm.unhandle(protocol)`](#swarmunhandleprotocol)
+  - [`swarm.close(callback)`](#swarmclosecallback)
+- [Design](#design)
+  - [Multitransport](#multitransport)
+  - [Connection upgrades](#connection-upgrades)
+  - [Identify](#identify)
+  - [Notes](#notes)
+- [Contribute](#contribute)
+- [License](#license)
 
-## Install 
+## Install
 
 libp2p-swarm is available on npm and so, like any other npm module, just:
 
@@ -24,9 +45,9 @@ libp2p-swarm is available on npm and so, like any other npm module, just:
 > npm install libp2p-swarm --save
 ```
 
-## API
+## Usage
 
-#### Create a libp2p Swarm
+### Create a libp2p Swarm
 
 And use it in your Node.js code as:
 
@@ -36,6 +57,8 @@ const Swarm = require('libp2p-swarm')
 const sw = new Swarm(peerInfo)
 ```
 
+## API
+
 peerInfo is a [PeerInfo](https://github.com/diasdavid/js-peer-info) object that represents the peer creating this swarm instance.
 
 ### Transports
@@ -44,10 +67,10 @@ peerInfo is a [PeerInfo](https://github.com/diasdavid/js-peer-info) object that
 
 libp2p-swarm expects transports that implement [interface-transport](https://github.com/diasdavid/abstract-transport). For example [libp2p-tcp](https://github.com/diasdavid/js-libp2p-tcp).
 
-- `key` - the transport identifier
-- `transport` - 
-- `options`
-- `callback`
+- `key` - the transport identifier.
+- `transport` -
+- `options` -
+- `callback` -
 
 ##### `swarm.transport.dial(key, multiaddrs, callback)`
 
@@ -89,38 +112,55 @@ Upgrading a connection to use a stream muxer is still considered an upgrade, but
 
 ##### `swarm.connection.reuse()`
 
-Enable the identify protocol
+Enable the identify protocol.
 
 ### `swarm.dial(pi, protocol, callback)`
 
-dial uses the best transport (whatever works first, in the future we can have some criteria), and jump starts the connection until the point we have to negotiate the protocol. If a muxer is available, then drop the muxer onto that connection. Good to warm up connections or to check for connectivity. If we have already a muxer for that peerInfo, than do nothing.
+dial uses the best transport (whatever works first, in the future we can have some criteria), and jump starts the connection until the point where we have to negotiate the protocol. If a muxer is available, then drop the muxer onto that connection. Good to warm up connections or to check for connectivity. If we have already a muxer for that peerInfo, then do nothing.
 
 - `pi` - peer info project
 - `protocol`
 - `callback`
 
+### `swarm.hangUp(pi, callback)`
+
+Hang up the muxed connection we have with the peer.
+
+- `pi` - peer info project
+- `callback`
+
+### `swarm.listen(callback)`
+
+Start listening on all added transports that are available on the current `peerInfo`.
+
 ### `swarm.handle(protocol, handler)`
 
-handle a new protocol.
+Handle a new protocol.
 
 - `protocol`
 - `handler` - function called when we receive a dial on `protocol. Signature must be `function (conn) {}`
 
+### `swarm.unhandle(protocol)`
+
+Unhandle a protocol.
+
+- `protocol`
+
 ### `swarm.close(callback)`
 
-close all the listeners and muxers.
+Close all the listeners and muxers.
 
 - `callback`
 
-# Design
+## Design
 
-## Multitransport
+### Multitransport
 
 libp2p is designed to support multiple transports at the same time. While peers are identified by their ID (which are generated from their public keys), the addresses of each pair may vary, depending the device where they are being run or the network in which they are accessible through.
 
 In order for a transport to be supported, it has to follow the [interface-transport](https://github.com/diasdavid/interface-transport) spec.
 
-## Connection upgrades
+### Connection upgrades
 
 Each connection in libp2p follows the [interface-connection](https://github.com/diasdavid/interface-connection) spec. This design decision enables libp2p to have upgradable transports.
 
@@ -136,7 +176,7 @@ Types of upgrades to a connection:
 
 We also want to enable flexibility when it comes to upgrading a connection, for example, we might that all dialed transports pass through the encrypted channel upgrade, but not the congestion flow, specially when a transport might have already some underlying properties (UDP vs TCP vs WebRTC vs every other transport protocol)
 
-## Identify
+### Identify
 
 Identify is a protocol that Swarms mounts on top of itself, to identify the connections between any two peers. E.g:
 
@@ -147,9 +187,17 @@ Identify is a protocol that Swarms mounts on top of itself, to identify the conn
 
 In addition to this, we also share the 'observed addresses' by the other peer, which is extremely useful information for different kinds of network topologies.
 
-## Notes
+### Notes
 
 To avoid the confusion between connection, stream, transport, and other names that represent an abstraction of data flow between two points, we use terms as:
 
 - connection - something that implements the transversal expectations of a stream between two peers, including the benefits of using a stream plus having a way to do half duplex, full duplex
 - transport - something that as a dial/listen interface and return objs that implement a connection interface
+
+## Contribute
+
+This module is actively under development. Please check out the issues and submit PRs!
+
+## License
+
+MIT © Protocol Labs

circle.yml

@@ -0,0 +1,12 @@
+machine:
+  node:
+    version: stable
+
+dependencies:
+  pre:
+    - google-chrome --version
+    - wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
+    - sudo sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
+    - sudo apt-get update
+    - sudo apt-get --only-upgrade install google-chrome-stable
+    - google-chrome --version

gulpfile.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const gulp = require('gulp')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const WebSockets = require('libp2p-websockets')
+
+const Swarm = require('./src')
+const spdy = require('libp2p-spdy')
+const multiaddr = require('multiaddr')
+const fs = require('fs')
+const path = require('path')
+
+const sigServer = require('libp2p-webrtc-star/src/signalling-server')
+
+let swarmA
+let swarmB
+let sigS
+
+gulp.task('test:browser:before', (done) => {
+  function createListenerA (cb) {
+    const id = PeerId.createFromJSON(
+        JSON.parse(
+          fs.readFileSync(
+            path.join(__dirname, './test/test-data/id-1.json'))))
+
+    const peerA = new PeerInfo(id)
+    const maA = multiaddr('/ip4/127.0.0.1/tcp/9100/ws')
+
+    peerA.multiaddr.add(maA)
+    swarmA = new Swarm(peerA)
+    swarmA.transport.add('ws', new WebSockets())
+    swarmA.transport.listen('ws', {}, echo, cb)
+  }
+
+  function createListenerB (cb) {
+    const id = PeerId.createFromJSON(
+        JSON.parse(
+          fs.readFileSync(
+            path.join(__dirname, './test/test-data/id-2.json'))))
+
+    const peerB = new PeerInfo(id)
+    const maB = multiaddr('/ip4/127.0.0.1/tcp/9200/ws')
+
+    peerB.multiaddr.add(maB)
+    swarmB = new Swarm(peerB)
+
+    swarmB.transport.add('ws', new WebSockets())
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmB.connection.reuse()
+    swarmB.listen(cb)
+    swarmB.handle('/echo/1.0.0', echo)
+  }
+
+  let count = 0
+  const ready = () => ++count === 3 ? done() : null
+
+  createListenerA(ready)
+  createListenerB(ready)
+  sigS = sigServer.start(15555, ready)
+
+  function echo (conn) {
+    conn.pipe(conn)
+  }
+})
+
+gulp.task('test:browser:after', (done) => {
+  let count = 0
+  const ready = () => ++count === 3 ? done() : null
+
+  swarmA.transport.close('ws', ready)
+  swarmB.close(ready)
+  sigS.stop(ready)
+})
+
+require('aegir/gulp')(gulp)

package.json

@@ -1,16 +1,24 @@
 {
   "name": "libp2p-swarm",
-  "version": "0.8.1",
-  "description": "libp2p swarm implementation in Node.js",
-  "main": "src/index.js",
+  "version": "0.22.2",
+  "description": "libp2p swarm implementation in JavaScript",
+  "main": "lib/index.js",
+  "jsnext:main": "src/index.js",
   "scripts": {
-    "test": "mocha tests/*-test.js",
-    "coverage": "istanbul cover --print both -- _mocha tests/*-test.js",
-    "lint": "standard"
+    "lint": "gulp lint",
+    "build": "gulp build",
+    "test": "gulp test",
+    "test:node": "gulp test:node",
+    "test:browser": "gulp test:browser",
+    "release": "gulp release",
+    "release-minor": "gulp release --type minor",
+    "release-major": "gulp release --type major",
+    "coverage": "gulp coverage",
+    "coverage-publish": "aegir-coverage publish"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/diasdavid/js-libp2p-swarm.git"
+    "url": "https://github.com/libp2p/js-libp2p-swarm.git"
   },
   "keywords": [
     "IPFS"
@@ -18,9 +26,9 @@
   "author": "David Dias <daviddias@ipfs.io>",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/diasdavid/js-libp2p-swarm/issues"
+    "url": "https://github.com/libp2p/js-libp2p-swarm/issues"
   },
-  "homepage": "https://github.com/diasdavid/js-libp2p-swarm",
+  "homepage": "https://github.com/libp2p/js-libp2p-swarm",
   "pre-commit": [
     "lint",
     "test"
@@ -29,24 +37,43 @@
     "node": "^4.3.0"
   },
   "devDependencies": {
-    "bl": "^1.1.2",
+    "aegir": "^4.0.0",
+    "buffer-loader": "0.0.1",
     "chai": "^3.5.0",
-    "istanbul": "^0.4.2",
-    "libp2p-spdy": "^0.2.3",
-    "libp2p-tcp": "^0.4.0",
-    "libp2p-websockets": "^0.2.0",
-    "mocha": "^2.4.5",
-    "multiaddr": "^1.3.0",
-    "peer-id": "^0.6.0",
-    "peer-info": "^0.6.0",
+    "gulp": "^3.9.1",
+    "istanbul": "^0.4.3",
+    "libp2p-multiplex": "^0.2.1",
+    "libp2p-spdy": "^0.8.1",
+    "libp2p-tcp": "^0.7.4",
+    "libp2p-webrtc-star": "^0.3.2",
+    "libp2p-websockets": "^0.7.1",
     "pre-commit": "^1.1.2",
-    "standard": "^6.0.7",
-    "stream-pair": "^1.0.3"
+    "stream-pair": "^1.0.3",
+    "webrtcsupport": "^2.2.0"
   },
   "dependencies": {
-    "duplex-passthrough": "github:diasdavid/duplex-passthrough",
-    "ip-address": "^5.0.2",
-    "multistream-select": "^0.6.1",
-    "protocol-buffers-stream": "^1.2.0"
-  }
-}
+    "babel-runtime": "^6.6.1",
+    "bl": "^1.1.2",
+    "browserify-zlib": "github:ipfs/browserify-zlib",
+    "duplexify": "^3.4.3",
+    "interface-connection": "^0.1.7",
+    "ip-address": "^5.8.0",
+    "length-prefixed-stream": "^1.5.0",
+    "libp2p-identify": "^0.1.3",
+    "lodash.contains": "^2.4.3",
+    "multiaddr": "^2.0.0",
+    "multistream-select": "^0.9.0",
+    "peer-id": "^0.7.0",
+    "peer-info": "^0.7.0",
+    "protocol-buffers": "^3.1.6",
+    "run-parallel": "^1.1.6"
+  },
+  "contributors": [
+    "David Dias <daviddias.p@gmail.com>",
+    "David Dias <mail@daviddias.me>",
+    "Francisco Baio Dias <xicombd@gmail.com>",
+    "Pau Ramon Revilla <masylum@gmail.com>",
+    "Richard Littauer <richard.littauer@gmail.com>",
+    "dignifiedquire <dignifiedquire@gmail.com>"
+  ]
+}

src/connection.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const protocolMuxer = require('./protocol-muxer')
+const identify = require('libp2p-identify')
+const multistream = require('multistream-select')
+
+module.exports = function connection (swarm) {
+  return {
+    addUpgrade () {},
+
+    addStreamMuxer (muxer) {
+      // for dialing
+      swarm.muxers[muxer.multicodec] = muxer
+
+      // for listening
+      swarm.handle(muxer.multicodec, (conn) => {
+        const muxedConn = muxer(conn, true)
+
+        muxedConn.on('stream', (conn) => {
+          protocolMuxer(swarm.protocols, conn)
+        })
+
+        // If identify is enabled
+        //   1. overload getPeerInfo
+        //   2. call getPeerInfo
+        //   3. add this conn to the pool
+        if (swarm.identify) {
+          // overload peerInfo to use Identify instead
+          conn.getPeerInfo = (cb) => {
+            const conn = muxedConn.newStream()
+            const ms = new multistream.Dialer()
+            ms.handle(conn, (err) => {
+              if (err) { return cb(err) }
+
+              ms.select(identify.multicodec, (err, conn) => {
+                if (err) { return cb(err) }
+
+                identify.exec(conn, (err, peerInfo, observedAddrs) => {
+                  if (err) { return cb(err) }
+
+                  observedAddrs.forEach((oa) => {
+                    swarm._peerInfo.multiaddr.addSafe(oa)
+                  })
+
+                  cb(null, peerInfo)
+                })
+              })
+            })
+          }
+
+          conn.getPeerInfo((err, peerInfo) => {
+            if (err) {
+              return console.log('Identify not successful')
+            }
+            swarm.muxedConns[peerInfo.id.toB58String()] = {
+              muxer: muxedConn
+            }
+
+            swarm.emit('peer-mux-established', peerInfo)
+            muxedConn.on('close', () => {
+              delete swarm.muxedConns[peerInfo.id.toB58String()]
+              swarm.emit('peer-mux-closed', peerInfo)
+            })
+          })
+        }
+      })
+    },
+
+    reuse () {
+      swarm.identify = true
+      swarm.handle(identify.multicodec, identify.handler(swarm._peerInfo))
+    }
+  }
+}

src/dial.js

@@ -0,0 +1,185 @@
+'use strict'
+
+const multistream = require('multistream-select')
+const Connection = require('interface-connection').Connection
+
+const protocolMuxer = require('./protocol-muxer')
+
+module.exports = function dial (swarm) {
+  return (pi, protocol, callback) => {
+    if (typeof protocol === 'function') {
+      callback = protocol
+      protocol = null
+    }
+
+    if (!callback) {
+      callback = function noop () {}
+    }
+
+    const proxyConn = new Connection()
+
+    const b58Id = pi.id.toB58String()
+
+    if (!swarm.muxedConns[b58Id]) {
+      if (!swarm.conns[b58Id]) {
+        attemptDial(pi, (err, conn) => {
+          if (err) {
+            return callback(err)
+          }
+          gotWarmedUpConn(conn)
+        })
+      } else {
+        const conn = swarm.conns[b58Id]
+        swarm.conns[b58Id] = undefined
+        gotWarmedUpConn(conn)
+      }
+    } else {
+      if (!protocol) {
+        return callback()
+      }
+      gotMuxer(swarm.muxedConns[b58Id].muxer)
+    }
+
+    return proxyConn
+
+    function gotWarmedUpConn (conn) {
+      conn.setPeerInfo(pi)
+
+      attemptMuxerUpgrade(conn, (err, muxer) => {
+        if (!protocol) {
+          if (err) {
+            swarm.conns[b58Id] = conn
+          }
+          return callback()
+        }
+
+        if (err) {
+          // couldn't upgrade to Muxer, it is ok
+          protocolHandshake(conn, protocol, callback)
+        } else {
+          gotMuxer(muxer)
+        }
+      })
+    }
+
+    function gotMuxer (muxer) {
+      if (swarm.identify) {
+        // TODO: Consider:
+        // 1. overload getPeerInfo
+        // 2. exec identify (through getPeerInfo)
+        // 3. update the peerInfo that is already stored in the conn
+      }
+
+      openConnInMuxedConn(muxer, (conn) => {
+        protocolHandshake(conn, protocol, callback)
+      })
+    }
+
+    function attemptDial (pi, cb) {
+      const tKeys = swarm.availableTransports(pi)
+
+      if (tKeys.length === 0) {
+        return cb(new Error('No available transport to dial to'))
+      }
+
+      nextTransport(tKeys.shift())
+
+      function nextTransport (key) {
+        const multiaddrs = pi.multiaddrs.slice()
+        swarm.transport.dial(key, multiaddrs, (err, conn) => {
+          if (err) {
+            if (tKeys.length === 0) {
+              return cb(new Error('Could not dial in any of the transports'))
+            }
+            return nextTransport(tKeys.shift())
+          }
+
+          cryptoDial()
+
+          function cryptoDial () {
+            // currently, no crypto channel is implemented
+            const ms = new multistream.Dialer()
+            ms.handle(conn, (err) => {
+              if (err) {
+                return cb(err)
+              }
+              ms.select('/plaintext/1.0.0', cb)
+            })
+          }
+        })
+      }
+    }
+
+    function attemptMuxerUpgrade (conn, cb) {
+      const muxers = Object.keys(swarm.muxers)
+      if (muxers.length === 0) {
+        return cb(new Error('no muxers available'))
+      }
+
+      // 1. try to handshake in one of the muxers available
+      // 2. if succeeds
+      //  - add the muxedConn to the list of muxedConns
+      //  - add incomming new streams to connHandler
+
+      nextMuxer(muxers.shift())
+
+      function nextMuxer (key) {
+        const ms = new multistream.Dialer()
+        ms.handle(conn, (err) => {
+          if (err) {
+            return callback(new Error('multistream not supported'))
+          }
+          ms.select(key, (err, conn) => {
+            if (err) {
+              if (muxers.length === 0) {
+                cb(new Error('could not upgrade to stream muxing'))
+              } else {
+                nextMuxer(muxers.shift())
+              }
+              return
+            }
+
+            const muxedConn = swarm.muxers[key](conn, false)
+            swarm.muxedConns[b58Id] = {}
+            swarm.muxedConns[b58Id].muxer = muxedConn
+            // should not be needed anymore - swarm.muxedConns[b58Id].conn = conn
+
+            swarm.emit('peer-mux-established', pi)
+
+            muxedConn.once('close', () => {
+              delete swarm.muxedConns[pi.id.toB58String()]
+              swarm.emit('peer-mux-closed', pi)
+            })
+
+            // For incoming streams, in case identify is on
+            muxedConn.on('stream', (conn) => {
+              protocolMuxer(swarm.protocols, conn)
+            })
+
+            cb(null, muxedConn)
+          })
+        })
+      }
+    }
+
+    function openConnInMuxedConn (muxer, cb) {
+      cb(muxer.newStream())
+    }
+
+    function protocolHandshake (conn, protocol, cb) {
+      const ms = new multistream.Dialer()
+      ms.handle(conn, (err) => {
+        if (err) {
+          return callback(err)
+        }
+        ms.select(protocol, (err, conn) => {
+          if (err) {
+            return callback(err)
+          }
+          proxyConn.setInnerConn(conn)
+          callback(null, proxyConn)
+        })
+      })
+    }
+  }
+}

src/identify.js

@@ -1,93 +0,0 @@
-/*
- * Identify is one of the protocols swarms speaks in order to
- * broadcast and learn about the ip:port pairs a specific peer
- * is available through and to know when a new stream muxer is
- * established, so a conn can be reused
- */
-
-const multistream = require('multistream-select')
-const fs = require('fs')
-const path = require('path')
-const pbStream = require('protocol-buffers-stream')(
-    fs.readFileSync(path.join(__dirname, 'identify.proto')))
-const Info = require('peer-info')
-const Id = require('peer-id')
-const multiaddr = require('multiaddr')
-
-exports = module.exports
-exports.multicodec = '/ipfs/identify/1.0.0'
-
-exports.exec = (rawConn, muxer, peerInfo, callback) => {
-  // 1. open a stream
-  // 2. multistream into identify
-  // 3. send what I see from this other peer (extract fro conn)
-  // 4. receive what the other peer sees from me
-  // 4. callback with (err, peerInfo)
-
-  const conn = muxer.newStream()
-
-  var msI = new multistream.Interactive()
-  msI.handle(conn, () => {
-    msI.select(exports.multicodec, (err, ds) => {
-      if (err) {
-        return callback(err)
-      }
-
-      var pbs = pbStream()
-
-      pbs.on('identify', (msg) => {
-        peerInfo.multiaddr.addSafe(msg.observedAddr)
-
-        const peerId = Id.createFromPubKey(msg.publicKey)
-        const otherPeerInfo = new Info(peerId)
-        msg.listenAddrs.forEach((ma) => {
-          otherPeerInfo.multiaddr.add(multiaddr(ma))
-        })
-
-        callback(null, otherPeerInfo)
-      })
-
-      const obsMultiaddr = rawConn.getObservedAddrs()[0]
-
-      pbs.identify({
-        protocolVersion: 'na',
-        agentVersion: 'na',
-        publicKey: peerInfo.id.pubKey,
-        listenAddrs: peerInfo.multiaddrs.map((mh) => { return mh.buffer }),
-        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : null
-      })
-
-      pbs.pipe(ds).pipe(pbs)
-      pbs.finalize()
-    })
-  })
-}
-
-exports.handler = (peerInfo, swarm) => {
-  return function (conn) {
-    // 1. receive incoming observed info about me
-    // 2. update my own information (on peerInfo)
-    // 3. send back what I see from the other (get from swarm.muxedConns[incPeerID].conn.getObservedAddrs()
-    var pbs = pbStream()
-
-    pbs.on('identify', function (msg) {
-      peerInfo.multiaddr.addSafe(msg.observedAddr)
-
-      const peerId = Id.createFromPubKey(msg.publicKey)
-      const conn = swarm.muxedConns[peerId.toB58String()].conn
-      const obsMultiaddr = conn.getObservedAddrs()[0]
-
-      pbs.identify({
-        protocolVersion: 'na',
-        agentVersion: 'na',
-        publicKey: peerInfo.id.pubKey,
-        listenAddrs: peerInfo.multiaddrs.map(function (ma) {
-          return ma.buffer
-        }),
-        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : null
-      })
-      pbs.finalize()
-    })
-    pbs.pipe(conn).pipe(pbs)
-  }
-}

src/identify.proto

@@ -1,25 +0,0 @@
-message Identify {
-
-  // protocolVersion determines compatibility between peers
-  optional string protocolVersion = 5; // e.g. ipfs/1.0.0
-
-  // agentVersion is like a UserAgent string in browsers, or client version in bittorrent
-  // includes the client name and client.
-  optional string agentVersion = 6; // e.g. go-ipfs/0.1.0
-
-  // publicKey is this node's public key (which also gives its node.ID)
-  // - may not need to be sent, as secure channel implies it has been sent.
-  // - then again, if we change / disable secure channel, may still want it.
-  optional bytes publicKey = 1;
-
-  // listenAddrs are the multiaddrs the sender node listens for open connections on
-  repeated bytes listenAddrs = 2;
-
-  // oservedAddr is the multiaddr of the remote endpoint that the sender node perceives
-  // this is useful information to convey to the other side, as it helps the remote endpoint
-  // determine whether its connection to the local peer goes through NAT.
-  optional bytes observedAddr = 4;
-
-  // (DEPRECATED) protocols are the services this node is running
-  // repeated string protocols = 3;
-}

src/index.js

@@ -1,9 +1,19 @@
-const multistream = require('multistream-select')
-const identify = require('./identify')
-const DuplexPassThrough = require('duplex-passthrough')
+'use strict'
+
+const util = require('util')
+const EE = require('events').EventEmitter
+const parallel = require('run-parallel')
+const contains = require('lodash.contains')
+
+const transport = require('./transport')
+const connection = require('./connection')
+const dial = require('./dial')
+const protocolMuxer = require('./protocol-muxer')
 
 exports = module.exports = Swarm
 
+util.inherits(Swarm, EE)
+
 function Swarm (peerInfo) {
   if (!(this instanceof Swarm)) {
     return new Swarm(peerInfo)
@@ -13,103 +23,13 @@ function Swarm (peerInfo) {
     throw new Error('You must provide a value for `peerInfo`')
   }
 
-  // transports --
+  this._peerInfo = peerInfo
 
+  // transports --
   // { key: transport }; e.g { tcp: <tcp> }
   this.transports = {}
 
-  this.transport = {}
-
-  this.transport.add = (key, transport, options, callback) => {
-    if (typeof options === 'function') {
-      callback = options
-      options = {}
-    }
-    if (!callback) { callback = noop }
-
-    if (this.transports[key]) {
-      throw new Error('There is already a transport with this key')
-    }
-    this.transports[key] = transport
-    callback()
-  }
-
-  this.transport.dial = (key, multiaddrs, callback) => {
-    const t = this.transports[key]
-
-    if (!Array.isArray(multiaddrs)) {
-      multiaddrs = [multiaddrs]
-    }
-
-    // a) filter the multiaddrs that are actually valid for this transport (use a func from the transport itself) (maybe even make the transport do that)
-    multiaddrs = t.filter(multiaddrs)
-
-    // b) if multiaddrs.length = 1, return the conn from the
-    // transport, otherwise, create a passthrough
-    if (multiaddrs.length === 1) {
-      const conn = t.dial(multiaddrs.shift(), {ready: () => {
-        const cb = callback
-        callback = noop // this is done to avoid connection drops as connect errors
-        cb(null, conn)
-      }})
-      conn.once('error', () => {
-        callback(new Error('failed to connect to every multiaddr'))
-      })
-      return conn
-    }
-
-    // c) multiaddrs should already be a filtered list
-    // specific for the transport we are using
-    const pt = new DuplexPassThrough()
-
-    next(multiaddrs.shift())
-    return pt
-    function next (multiaddr) {
-      const conn = t.dial(multiaddr, {ready: () => {
-        pt.wrapStream(conn)
-        const cb = callback
-        callback = noop // this is done to avoid connection drops as connect errors
-        cb(null, pt)
-      }})
-
-      conn.once('error', () => {
-        if (multiaddrs.length === 0) {
-          return callback(new Error('failed to connect to every multiaddr'))
-        }
-        next(multiaddrs.shift())
-      })
-    }
-  }
-
-  this.transport.listen = (key, options, handler, callback) => {
-    // if no callback is passed, we pass conns to connHandler
-    if (!handler) { handler = connHandler }
-
-    const multiaddrs = peerInfo.multiaddrs.filter((m) => {
-      if (m.toString().indexOf('tcp') !== -1) {
-        return m
-      }
-    })
-
-    this.transports[key].createListener(multiaddrs, handler, (err, maUpdate) => {
-      if (err) {
-        return callback(err)
-      }
-      if (maUpdate) {
-        // because we can listen on port 0...
-        peerInfo.multiaddr.replace(multiaddrs, maUpdate)
-      }
-
-      callback()
-    })
-  }
-
-  this.transport.close = (key, callback) => {
-    this.transports[key].close(callback)
-  }
-
   // connections --
-
   // { peerIdB58: { conn: <conn> }}
   this.conns = {}
 
@@ -124,202 +44,92 @@ function Swarm (peerInfo) {
   // { protocol: handler }
   this.protocols = {}
 
-  this.connection = {}
-  this.connection.addUpgrade = () => {}
-
   // { muxerCodec: <muxer> } e.g { '/spdy/0.3.1': spdy }
   this.muxers = {}
-  this.connection.addStreamMuxer = (muxer) => {
-    // for dialing
-    this.muxers[muxer.multicodec] = muxer
 
-    // for listening
-    this.handle(muxer.multicodec, (conn) => {
-      const muxedConn = muxer(conn, true)
-      muxedConn.on('stream', (conn) => {
-        connHandler(conn)
+  // is the Identify protocol enabled?
+  this.identify = false
+
+  this.transport = transport(this)
+  this.connection = connection(this)
+
+  this.availableTransports = (pi) => {
+    const addrs = pi.multiaddrs
+
+    // Only listen on transports we actually have addresses for
+    return Object.keys(this.transports).filter((ts) => {
+      // ipfs multiaddrs are not dialable so we drop them here
+      let dialable = addrs.map((addr) => {
+        // webrtc-star needs the /ipfs/QmHash
+        if (addr.toString().indexOf('webrtc-star') > 0) {
+          return addr
+        }
+
+        if (contains(addr.protoNames(), 'ipfs')) {
+          return addr.decapsulate('ipfs')
+        }
+        return addr
       })
 
-      // if identify is enabled, attempt to do it for muxer reuse
-      if (this.identify) {
-        identify.exec(conn, muxedConn, peerInfo, (err, pi) => {
-          if (err) {
-            return console.log('Identify exec failed', err)
-          }
-          this.muxedConns[pi.id.toB58String()] = {}
-          this.muxedConns[pi.id.toB58String()].muxer = muxedConn
-          this.muxedConns[pi.id.toB58String()].conn = conn // to be able to extract addrs
-        })
-      }
+      return this.transports[ts].filter(dialable).length > 0
     })
   }
 
-  // enable the Identify protocol
-  this.identify = false
-  this.connection.reuse = () => {
-    this.identify = true
-    this.handle(identify.multicodec, identify.handler(peerInfo, this))
-  }
-
-  const self = this // prefered this to bind
-
-  // incomming connection handler
-  function connHandler (conn) {
-    var msS = new multistream.Select()
-    Object.keys(self.protocols).forEach((protocol) => {
-      if (!protocol) { return }
-      msS.addHandler(protocol, self.protocols[protocol])
-    })
-    msS.handle(conn)
-  }
-
   // higher level (public) API
-  this.dial = (pi, protocol, callback) => {
-    var pt = null
-    if (typeof protocol === 'function') {
-      callback = protocol
-      protocol = null
-    } else {
-      pt = new DuplexPassThrough()
-    }
+  this.dial = dial(this)
 
-    const b58Id = pi.id.toB58String()
-    if (!this.muxedConns[b58Id]) {
-      if (!this.conns[b58Id]) {
-        attemptDial(pi, (err, conn) => {
-          if (err) {
-            return callback(err)
-          }
-          gotWarmedUpConn(conn)
-        })
-      } else {
-        const conn = this.conns[b58Id]
-        this.conns[b58Id] = undefined
-        gotWarmedUpConn(conn)
-      }
-    } else {
-      gotMuxer(this.muxedConns[b58Id].muxer)
-    }
-
-    function gotWarmedUpConn (conn) {
-      attemptMuxerUpgrade(conn, (err, muxer) => {
-        if (!protocol) {
-          if (err) {
-            self.conns[b58Id] = conn
-          }
-          return callback()
-        }
-
-        if (err) {
-          // couldn't upgrade to Muxer, it is ok
-          protocolHandshake(conn, protocol, callback)
-        } else {
-          gotMuxer(muxer)
-        }
-      })
-    }
-
-    function gotMuxer (muxer) {
-      openConnInMuxedConn(muxer, (conn) => {
-        protocolHandshake(conn, protocol, callback)
-      })
-    }
-
-    function attemptDial (pi, cb) {
-      const tKeys = Object.keys(self.transports)
-      nextTransport(tKeys.shift())
-
-      function nextTransport (key) {
-        const multiaddrs = pi.multiaddrs.slice()
-        self.transport.dial(key, multiaddrs, (err, conn) => {
-          if (err) {
-            if (tKeys.length === 0) {
-              return cb(new Error('Could not dial in any of the transports'))
-            }
-            return nextTransport(tKeys.shift())
-          }
-          cb(null, conn)
-        })
-      }
-    }
-
-    function attemptMuxerUpgrade (conn, cb) {
-      const muxers = Object.keys(self.muxers)
-      if (muxers.length === 0) {
-        return cb(new Error('no muxers available'))
-      }
-
-      // 1. try to handshake in one of the muxers available
-      // 2. if succeeds
-      //  - add the muxedConn to the list of muxedConns
-      //  - add incomming new streams to connHandler
-
-      nextMuxer(muxers.shift())
-
-      function nextMuxer (key) {
-        var msI = new multistream.Interactive()
-        msI.handle(conn, function () {
-          msI.select(key, (err, conn) => {
-            if (err) {
-              if (muxers.length === 0) {
-                cb(new Error('could not upgrade to stream muxing'))
-              } else {
-                nextMuxer(muxers.shift())
-              }
-              return
-            }
-
-            const muxedConn = self.muxers[key](conn, false)
-            self.muxedConns[b58Id] = {}
-            self.muxedConns[b58Id].muxer = muxedConn
-            self.muxedConns[b58Id].conn = conn
-
-            // in case identify is on
-            muxedConn.on('stream', connHandler)
-
-            cb(null, muxedConn)
-          })
-        })
-      }
-    }
-    function openConnInMuxedConn (muxer, cb) {
-      cb(muxer.newStream())
-    }
-
-    function protocolHandshake (conn, protocol, cb) {
-      var msI = new multistream.Interactive()
-      msI.handle(conn, function () {
-        msI.select(protocol, (err, conn) => {
-          if (err) {
-            return callback(err)
-          }
-
-          pt.wrapStream(conn)
-          callback(null, pt)
-        })
-      })
-    }
+  // Start listening on all available transports
+  this.listen = (callback) => {
+    parallel(this.availableTransports(peerInfo).map((ts) => (cb) => {
+      // Listen on the given transport
+      this.transport.listen(ts, {}, null, cb)
+    }), callback)
   }
 
   this.handle = (protocol, handler) => {
     this.protocols[protocol] = handler
   }
 
-  this.close = (callback) => {
-    var count = 0
+  // our crypto handshake :)
+  this.handle('/plaintext/1.0.0', (conn) => {
+    protocolMuxer(this.protocols, conn)
+  })
 
+  this.unhandle = (protocol, handler) => {
+    if (this.protocols[protocol]) {
+      delete this.protocols[protocol]
+    }
+  }
+
+  this.hangUp = (peerInfo, callback) => {
+    const key = peerInfo.id.toB58String()
+    if (this.muxedConns[key]) {
+      const muxer = this.muxedConns[key].muxer
+      muxer.end()
+      muxer.once('close', () => {
+        delete this.muxedConns[key]
+        callback()
+      })
+    } else {
+      callback()
+    }
+  }
+
+  this.close = (callback) => {
     Object.keys(this.muxedConns).forEach((key) => {
       this.muxedConns[key].muxer.end()
     })
 
-    Object.keys(this.transports).forEach((key) => {
-      this.transports[key].close(() => {
-        if (++count === Object.keys(this.transports).length) {
-          callback()
-        }
-      })
-    })
+    const transports = this.transports
+
+    parallel(Object.keys(transports).map((key) => {
+      return (cb) => {
+        parallel(transports[key].listeners.map((listener) => {
+          return (cb) => {
+            listener.close(cb)
+          }
+        }), cb)
+      }
+    }), callback)
   }
 }
-
-function noop () {}

src/protocol-muxer.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const multistream = require('multistream-select')
+
+module.exports = function protocolMuxer (protocols, conn) {
+  const ms = new multistream.Listener()
+
+  Object.keys(protocols).forEach((protocol) => {
+    if (!protocol) {
+      return
+    }
+
+    ms.addHandler(protocol, protocols[protocol])
+  })
+
+  ms.handle(conn, (err) => {
+    if (err) {
+      return // the multistream handshake failed
+    }
+  })
+}

src/transport.js

@@ -0,0 +1,154 @@
+'use strict'
+
+const Connection = require('interface-connection').Connection
+const parallel = require('run-parallel')
+const debug = require('debug')
+const log = debug('libp2p:swarm')
+
+const protocolMuxer = require('./protocol-muxer')
+
+module.exports = function (swarm) {
+  return {
+    add (key, transport, options, callback) {
+      if (typeof options === 'function') {
+        callback = options
+        options = {}
+      }
+
+      if (!callback) { callback = noop }
+
+      if (swarm.transports[key]) {
+        throw new Error('There is already a transport with this key')
+      }
+      swarm.transports[key] = transport
+      if (!swarm.transports[key].listeners) {
+        swarm.transports[key].listeners = []
+      }
+
+      callback()
+    },
+
+    dial (key, multiaddrs, callback) {
+      const t = swarm.transports[key]
+
+      if (!Array.isArray(multiaddrs)) {
+        multiaddrs = [multiaddrs]
+      }
+
+      // a) filter the multiaddrs that are actually valid for this transport (use a func from the transport itself) (maybe even make the transport do that)
+      multiaddrs = dialables(t, multiaddrs)
+
+      // b) if multiaddrs.length = 1, return the conn from the
+      // transport, otherwise, create a passthrough
+      if (multiaddrs.length === 1) {
+        const conn = t.dial(multiaddrs.shift())
+
+        conn.once('error', connectError)
+
+        conn.once('connect', () => {
+          conn.removeListener('error', connectError)
+          callback(null, conn)
+        })
+
+        return conn
+      }
+      function connectError () {
+        callback(new Error('failed to connect to every multiaddr'))
+      }
+
+      // c) multiaddrs should already be a filtered list
+      // specific for the transport we are using
+      const proxyConn = new Connection()
+
+      next(multiaddrs.shift())
+
+      return proxyConn
+
+      // TODO improve in the future to make all the dials in paralell
+      function next (multiaddr) {
+        const conn = t.dial(multiaddr)
+
+        conn.once('error', connectError)
+
+        function connectError () {
+          if (multiaddrs.length === 0) {
+            return callback(new Error('failed to connect to every multiaddr'))
+          }
+          next(multiaddrs.shift())
+        }
+
+        conn.once('connect', () => {
+          conn.removeListener('error', connectError)
+          proxyConn.setInnerConn(conn)
+          callback(null, proxyConn)
+        })
+      }
+    },
+
+    listen (key, options, handler, callback) {
+      // if no handler is passed, we pass conns to protocolMuxer
+      if (!handler) {
+        handler = protocolMuxer.bind(null, swarm.protocols)
+      }
+
+      const multiaddrs = dialables(swarm.transports[key], swarm._peerInfo.multiaddrs)
+
+      const transport = swarm.transports[key]
+
+      if (!transport.listeners) {
+        transport.listeners = []
+      }
+
+      let freshMultiaddrs = []
+
+      const createListeners = multiaddrs.map((ma) => {
+        return (cb) => {
+          const listener = transport.createListener(handler)
+          listener.listen(ma, () => {
+            log('Listener started on:', ma.toString())
+            listener.getAddrs((err, addrs) => {
+              if (err) {
+                return cb(err)
+              }
+              freshMultiaddrs = freshMultiaddrs.concat(addrs)
+              transport.listeners.push(listener)
+              cb()
+            })
+          })
+        }
+      })
+
+      parallel(createListeners, () => {
+        // cause we can listen on port 0 or 0.0.0.0
+        swarm._peerInfo.multiaddr.replace(multiaddrs, freshMultiaddrs)
+        callback()
+      })
+    },
+
+    close (key, callback) {
+      const transport = swarm.transports[key]
+
+      if (!transport) {
+        return callback(new Error(`Trying to close non existing transport: ${key}`))
+      }
+
+      parallel(transport.listeners.map((listener) => {
+        return (cb) => {
+          listener.close(cb)
+        }
+      }), callback)
+    }
+  }
+}
+
+function dialables (tp, multiaddrs) {
+  return tp.filter(multiaddrs.map((addr) => {
+    // webrtc-star needs the /ipfs/QmHash
+    if (addr.toString().indexOf('webrtc-star') > 0) {
+      return addr
+    }
+
+    return addr
+  }))
+}
+function noop () {}

test/00-instance.node.js

@@ -0,0 +1,12 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const Swarm = require('../src')
+
+describe('create Swarm instance', () => {
+  it('throws on missing peerInfo', () => {
+    expect(() => Swarm()).to.throw(Error)
+  })
+})

test/01-transport-tcp.node.js

@@ -0,0 +1,175 @@
+/* eslint-env mocha */
+
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const bl = require('bl')
+
+describe('transport - tcp', function () {
+  this.timeout(10000)
+
+  var swarmA
+  var swarmB
+  var peerA = new Peer()
+  var peerB = new Peer()
+
+  before((done) => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999'))
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    done()
+  })
+
+  it('add', (done) => {
+    swarmA.transport.add('tcp', new TCP())
+    expect(Object.keys(swarmA.transports).length).to.equal(1)
+    swarmB.transport.add('tcp', new TCP(), () => {
+      expect(Object.keys(swarmB.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('listen', (done) => {
+    var count = 0
+    swarmA.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+    swarmB.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      if (++count === 2) {
+        expect(peerA.multiaddrs.length).to.equal(1)
+        expect(
+          peerA.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9888'))
+        ).to.be.equal(
+          true
+        )
+        expect(peerB.multiaddrs.length).to.equal(1)
+        expect(
+          peerB.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9999'))
+        ).to.be.equal(
+          true
+        )
+        done()
+      }
+    }
+  })
+
+  it('dial to a multiaddr', (done) => {
+    const conn = swarmA.transport.dial('tcp', multiaddr('/ip4/127.0.0.1/tcp/9999'), (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('dial to set of multiaddr, only one is available', (done) => {
+    const conn = swarmA.transport.dial('tcp', [
+      multiaddr('/ip4/127.0.0.1/tcp/9910/ws'), // not valid on purpose
+      multiaddr('/ip4/127.0.0.1/tcp/9910'),
+      multiaddr('/ip4/127.0.0.1/tcp/9999'),
+      multiaddr('/ip4/127.0.0.1/tcp/9309')
+    ], (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('close', (done) => {
+    parallel([
+      (cb) => swarmA.transport.close('tcp', cb),
+      (cb) => swarmB.transport.close('tcp', cb)
+    ], done)
+  })
+
+  it('support port 0', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(1)
+      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/0'))
+      swarm.close(done)
+    }
+  })
+
+  it('support addr /ip4/0.0.0.0/tcp/9050', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/9050'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length >= 1).to.equal(true)
+      expect(
+        peer.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9050'))
+      ).to.be.equal(
+        true
+      )
+      swarm.close(done)
+    }
+  })
+
+  it('support addr /ip4/0.0.0.0/tcp/0', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/0'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length >= 1).to.equal(true)
+      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/0'))
+      swarm.close(done)
+    }
+  })
+
+  it('listen in several addrs', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(3)
+      swarm.close(done)
+    }
+  })
+})

test/02-transport-utp.node.js

@@ -0,0 +1,13 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('transport - utp', function () {
+  this.timeout(10000)
+
+  before((done) => { done() })
+
+  it.skip('add', (done) => {})
+  it.skip('listen', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('close', (done) => {})
+})

test/03-transport-websockets.node.js

@@ -0,0 +1,93 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const WebSockets = require('libp2p-websockets')
+const bl = require('bl')
+
+describe('transport - websockets', function () {
+  this.timeout(10000)
+
+  var swarmA
+  var swarmB
+  var peerA = new Peer()
+  var peerB = new Peer()
+
+  before(() => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888/ws'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC'))
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+  })
+
+  it('add', (done) => {
+    swarmA.transport.add('ws', new WebSockets())
+    expect(Object.keys(swarmA.transports).length).to.equal(1)
+    swarmB.transport.add('ws', new WebSockets(), () => {
+      expect(Object.keys(swarmB.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('listen', (done) => {
+    parallel([
+      (cb) => swarmA.transport.listen('ws', {}, (conn) => {
+        conn.pipe(conn)
+      }, cb),
+      (cb) => swarmB.transport.listen('ws', {}, (conn) => {
+        conn.pipe(conn)
+      }, cb)
+    ], () => {
+      expect(peerA.multiaddrs.length).to.equal(1)
+      expect(
+        peerA.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9888/ws'))
+      ).to.be.equal(
+        true
+      )
+      expect(peerB.multiaddrs.length).to.equal(1)
+      expect(
+        peerB.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9999/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC'))
+      ).to.equal(
+        true
+      )
+      done()
+    })
+  })
+
+  it('dial', (done) => {
+    const conn = swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/ws'), (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('dial (conn from callback)', (done) => {
+    swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/ws'), (err, conn) => {
+      expect(err).to.not.exist
+
+      conn.pipe(bl((err, data) => {
+        expect(err).to.not.exist
+        done()
+      }))
+      conn.write('hey')
+      conn.end()
+    })
+  })
+
+  it('close', (done) => {
+    parallel([
+      (cb) => swarmA.transport.close('ws', cb),
+      (cb) => swarmB.transport.close('ws', cb)
+    ], done)
+  })
+})

test/04-muxing-multiplex.node.js

@@ -0,0 +1,120 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const multiplex = require('libp2p-spdy')
+
+// TODO multiplex needs to be upgraded, like spdy, to work again
+describe.skip('stream muxing with multiplex (on TCP)', function () {
+  this.timeout(60 * 1000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+  var swarmC
+  var peerC
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmB.transport.add('tcp', new TCP())
+    swarmC.transport.add('tcp', new TCP())
+
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmC.transport.listen('tcp', {}, null, cb)
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb),
+      (cb) => swarmC.close(cb)
+    ], done)
+  })
+
+  it('add', (done) => {
+    swarmA.connection.addStreamMuxer(multiplex)
+    swarmB.connection.addStreamMuxer(multiplex)
+    swarmC.connection.addStreamMuxer(multiplex)
+    done()
+  })
+
+  it('handle + dial on protocol', (done) => {
+    swarmB.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial to warm conn', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.handle('/papaia/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('enable identify to reuse incomming muxed conn', (done) => {
+    swarmA.connection.reuse()
+    swarmC.connection.reuse()
+
+    swarmC.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      setTimeout(() => {
+        expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+        done()
+      }, 500)
+    })
+  })
+})

test/05-muxing-spdy.node.js

@@ -0,0 +1,244 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+
+const spdy = require('libp2p-spdy')
+
+describe('stream muxing with spdy (on TCP)', function () {
+  this.timeout(60 * 1000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+  var swarmC
+  var peerC
+  var swarmD
+  var peerD
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+    peerD = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+    peerD.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9004'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+    swarmD = new Swarm(peerD)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmB.transport.add('tcp', new TCP())
+    swarmC.transport.add('tcp', new TCP())
+    swarmD.transport.add('tcp', new TCP())
+
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmC.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmD.transport.listen('tcp', {}, null, cb)
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb),
+      // (cb) => swarmC.close(cb)
+      (cb) => swarmD.close(cb)
+    ], done)
+  })
+
+  it('add', () => {
+    swarmA.connection.addStreamMuxer(spdy)
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmC.connection.addStreamMuxer(spdy)
+    swarmD.connection.addStreamMuxer(spdy)
+  })
+
+  it('handle + dial on protocol', (done) => {
+    swarmB.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial to warm conn', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.handle('/papaia/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('enable identify to reuse incomming muxed conn', (done) => {
+    swarmA.connection.reuse()
+    swarmC.connection.reuse()
+
+    swarmC.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      setTimeout(() => {
+        expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+        done()
+      }, 500)
+    })
+  })
+
+  it('with Identify, do getPeerInfo', (done) => {
+    swarmA.handle('/banana/1.0.0', (conn) => {
+      conn.getPeerInfo((err, peerInfoC) => {
+        expect(err).to.not.exist
+        expect(peerInfoC.id.toB58String()).to.equal(peerC.id.toB58String())
+      })
+
+      conn.pipe(conn)
+    })
+
+    swarmC.dial(peerA, '/banana/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      setTimeout(() => {
+        expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+        conn.getPeerInfo((err, peerInfoA) => {
+          expect(err).to.not.exist
+          expect(peerInfoA.id.toB58String()).to.equal(peerA.id.toB58String())
+          conn.on('end', done)
+          conn.resume()
+          conn.end()
+        })
+      }, 500)
+    })
+  })
+
+  // This test is not possible as the raw conn is not exposed anymore
+  // TODO: create a similar version, but that spawns a swarm in a
+  // different proc
+  it.skip('make sure it does not blow up when the socket is closed', (done) => {
+    swarmD.connection.reuse()
+
+    let count = 0
+    const destroyed = () => ++count === 2 ? done() : null
+
+    swarmD.handle('/banana/1.0.0', (conn) => {
+      conn.on('error', () => {})
+      conn.on('close', destroyed)
+    })
+
+    swarmA.dial(peerD, '/banana/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+
+      conn.on('error', () => {})
+      conn.on('close', destroyed)
+
+      swarmD.muxedConns[peerA.id.toB58String()].conn.destroy()
+    })
+  })
+
+  // This test is not possible as the raw conn is not exposed anymore
+  // TODO: create a similar version, but that spawns a swarm in a
+  // different proc
+  it.skip('blow up a socket, with WebSockets', (done) => {
+    var swarmE
+    var peerE
+    var swarmF
+    var peerF
+
+    peerE = new Peer()
+    peerF = new Peer()
+
+    peerE.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9110/ws'))
+    peerF.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9120/ws'))
+
+    swarmE = new Swarm(peerE)
+    swarmF = new Swarm(peerF)
+
+    swarmE.transport.add('ws', new WebSockets())
+    swarmF.transport.add('ws', new WebSockets())
+
+    swarmE.connection.addStreamMuxer(spdy)
+    swarmF.connection.addStreamMuxer(spdy)
+    swarmE.connection.reuse()
+    swarmF.connection.reuse()
+
+    parallel([
+      (cb) => swarmE.transport.listen('ws', {}, null, cb),
+      (cb) => swarmF.transport.listen('ws', {}, null, cb)
+    ], next)
+
+    function next () {
+      let count = 0
+      const destroyed = () => ++count === 2 ? close() : null
+
+      swarmE.handle('/avocado/1.0.0', (conn) => {
+        conn.on('error', () => {})
+        conn.on('close', destroyed)
+      })
+
+      swarmF.dial(peerE, '/avocado/1.0.0', (err, conn) => {
+        expect(err).to.not.exist
+        conn.on('error', () => {})
+        conn.on('close', destroyed)
+
+        swarmF.muxedConns[peerE.id.toB58String()].conn.destroy()
+      })
+    }
+
+    function close () {
+      parallel([
+        (cb) => swarmE.close(cb),
+        (cb) => swarmF.close(cb)
+      ], done)
+    }
+  })
+
+  it('close one end, make sure the other does not blow', (done) => {
+    swarmC.close((err) => {
+      if (err) throw err
+      // to make sure it has time to propagate
+      setTimeout(done, 1000)
+    })
+  })
+})

test/06-conn-upgrade-secio.node.js

@@ -0,0 +1,10 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('secio conn upgrade (on TCP)', function () {
+  this.timeout(20000)
+
+  it.skip('add', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('tls on a muxed stream (not the full conn)', (done) => {})
+})

test/07-conn-upgrade-tls.node.js

@@ -0,0 +1,8 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('tls conn upgrade (on TCP)', function () {
+  it.skip('add', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('tls on a muxed stream (not the full conn)', (done) => {})
+})

test/08-swarm-without-muxing.node.js

@@ -0,0 +1,102 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+
+describe('high level API - 1st without stream multiplexing (on TCP)', function () {
+  this.timeout(20000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmB.transport.add('tcp', new TCP())
+
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb)
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb)
+    ], done)
+  })
+
+  it('handle a protocol', (done) => {
+    swarmB.handle('/bananas/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+    expect(Object.keys(swarmB.protocols).length).to.equal(2)
+    done()
+  })
+
+  it('dial on protocol', (done) => {
+    swarmB.handle('/pineapple/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/pineapple/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial on protocol (returned conn)', (done) => {
+    swarmB.handle('/apples/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    const conn = swarmA.dial(peerB, '/apples/1.0.0', (err) => {
+      expect(err).to.not.exist
+    })
+    conn.end()
+    conn.on('data', () => {}) // let it flow.. let it flooooow
+    conn.on('end', done)
+  })
+
+  it('dial to warm a conn', (done) => {
+    swarmA.dial(peerB, (err) => {
+      expect(err).to.not.exist
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.dial(peerB, '/bananas/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('unhandle', (done) => {
+    const proto = '/bananas/1.0.0'
+    swarmA.unhandle(proto)
+    expect(swarmA.protocols[proto]).to.not.exist
+    done()
+  })
+})

test/09-swarm-with-muxing.node.js

@@ -0,0 +1,248 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const parallel = require('run-parallel')
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const spdy = require('libp2p-spdy')
+
+describe('high level API - with everything mixed all together!', function () {
+  this.timeout(100000)
+
+  var swarmA // tcp
+  var peerA
+  var swarmB // tcp+ws
+  var peerB
+  var swarmC // tcp+ws
+  var peerC
+  var swarmD // ws
+  var peerD
+  var swarmE // ws
+  var peerE
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+    peerD = new Peer()
+    peerE = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+    swarmD = new Swarm(peerD)
+    swarmE = new Swarm(peerE)
+
+    done()
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb),
+      // (cb) => swarmC.close(cb),
+      (cb) => swarmD.close(cb),
+      (cb) => swarmE.close(cb)
+    ], done)
+  })
+
+  it('add tcp', (done) => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmB.transport.add('tcp', new TCP())
+    swarmC.transport.add('tcp', new TCP())
+
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb)
+      // (cb) => swarmC.transport.listen('tcp', {}, null, cb)
+    ], done)
+  })
+
+  it.skip('add utp', (done) => {})
+
+  it('add websockets', (done) => {
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9012/ws'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9022/ws'))
+    peerD.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9032/ws'))
+    peerE.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9042/ws'))
+
+    swarmB.transport.add('ws', new WebSockets())
+    swarmC.transport.add('ws', new WebSockets())
+    swarmD.transport.add('ws', new WebSockets())
+    swarmE.transport.add('ws', new WebSockets())
+
+    parallel([
+      (cb) => swarmB.transport.listen('ws', {}, null, cb),
+      // (cb) => swarmC.transport.listen('ws', {}, null, cb),
+      (cb) => swarmD.transport.listen('ws', {}, null, cb),
+      (cb) => swarmE.transport.listen('ws', {}, null, cb)
+    ], done)
+  })
+
+  it('listen automatically', (done) => {
+    swarmC.listen(done)
+  })
+
+  it('add spdy', () => {
+    swarmA.connection.addStreamMuxer(spdy)
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmC.connection.addStreamMuxer(spdy)
+    swarmD.connection.addStreamMuxer(spdy)
+    swarmE.connection.addStreamMuxer(spdy)
+
+    swarmA.connection.reuse()
+    swarmB.connection.reuse()
+    swarmC.connection.reuse()
+    swarmD.connection.reuse()
+    swarmE.connection.reuse()
+  })
+
+  it.skip('add multiplex', () => {})
+
+  it('warm up from A to B on tcp to tcp+ws', (done) => {
+    parallel([
+      (cb) => swarmB.once('peer-mux-established', (peerInfo) => {
+        expect(peerInfo.id.toB58String()).to.equal(peerA.id.toB58String())
+        cb()
+      }),
+      (cb) => swarmA.once('peer-mux-established', (peerInfo) => {
+        expect(peerInfo.id.toB58String()).to.equal(peerB.id.toB58String())
+        cb()
+      }),
+      (cb) => swarmA.dial(peerB, (err) => {
+        expect(err).to.not.exist
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+        cb()
+      })
+    ], done)
+  })
+
+  it('warm up a warmed up, from B to A', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial from tcp to tcp+ws, on protocol', (done) => {
+    swarmB.handle('/anona/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/anona/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial from ws to ws no proto', (done) => {
+    swarmD.dial(peerE, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmD.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial from ws to ws', (done) => {
+    swarmE.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmD.dial(peerE, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmD.muxedConns).length).to.equal(1)
+
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', () => {
+        setTimeout(() => {
+          expect(Object.keys(swarmE.muxedConns).length).to.equal(1)
+          done()
+        }, 1000)
+      })
+    })
+  })
+
+  it('dial from tcp to tcp+ws (returned conn)', (done) => {
+    swarmB.handle('/grapes/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    const conn = swarmA.dial(peerB, '/grapes/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+    })
+    conn.end()
+
+    conn.on('data', () => {}) // let it flow.. let it flooooow
+    conn.on('end', done)
+  })
+
+  it('dial from tcp+ws to tcp+ws', (done) => {
+    swarmC.handle('/mamao/1.0.0', (conn) => {
+      conn.getPeerInfo((err, peerInfo) => {
+        expect(err).to.not.exist
+        expect(peerInfo).to.exist
+      })
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerC, '/mamao/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.getPeerInfo((err, peerInfo) => {
+        expect(err).to.not.exist
+        expect(peerInfo).to.exist
+      })
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('hangUp', (done) => {
+    let count = 0
+    const ready = () => ++count === 3 ? done() : null
+
+    swarmB.once('peer-mux-closed', (peerInfo) => {
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(0)
+      ready()
+    })
+
+    swarmA.once('peer-mux-closed', (peerInfo) => {
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      ready()
+    })
+
+    swarmA.hangUp(peerB, (err) => {
+      expect(err).to.not.exist
+      ready()
+    })
+  })
+
+  it('close a muxer emits event', (done) => {
+    parallel([
+      (cb) => swarmC.close(cb),
+      (cb) => swarmA.once('peer-mux-closed', (peerInfo) => cb())
+    ], done)
+  })
+})

test/browser-00-transport-websockets.js

@@ -0,0 +1,48 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const multiaddr = require('multiaddr')
+const Id = require('peer-id')
+const Peer = require('peer-info')
+const WebSockets = require('libp2p-websockets')
+const bl = require('bl')
+
+const Swarm = require('../src')
+
+describe('transport - websockets', function () {
+  this.timeout(10000)
+
+  var swarm
+
+  before(() => {
+    const b58IdSrc = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
+    // use a pre generated Id to save time
+    const idSrc = Id.createFromB58String(b58IdSrc)
+    const peerSrc = new Peer(idSrc)
+    swarm = new Swarm(peerSrc)
+  })
+
+  it('add', (done) => {
+    swarm.transport.add('ws', new WebSockets(), () => {
+      expect(Object.keys(swarm.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial', (done) => {
+    const ma = multiaddr('/ip4/127.0.0.1/tcp/9100/ws')
+
+    const conn = swarm.transport.dial('ws', ma, (err, conn) => {
+      expect(err).to.not.exist
+    })
+
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      expect(data.toString()).to.equal('hey')
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+})

test/browser-01-transport-webrtc-star.js

@@ -0,0 +1,90 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const multiaddr = require('multiaddr')
+const peerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const WebRTCStar = require('libp2p-webrtc-star')
+const bl = require('bl')
+const parallel = require('run-parallel')
+
+const Swarm = require('../src')
+
+describe('transport - webrtc-star', function () {
+  this.timeout(10000)
+
+  let swarm1
+  let peer1
+
+  let swarm2
+  let peer2
+
+  before(() => {
+    const id1 = peerId.createFromB58String('QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA')
+    peer1 = new PeerInfo(id1)
+    const mh1 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA')
+    peer1.multiaddr.add(mh1)
+
+    const id2 = peerId.createFromB58String('QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooB')
+    peer2 = new PeerInfo(id2)
+    const mh2 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooB')
+    peer2.multiaddr.add(mh2)
+
+    swarm1 = new Swarm(peer1)
+    swarm2 = new Swarm(peer2)
+  })
+
+  it('add WebRTCStar transport to swarm 1', (done) => {
+    swarm1.transport.add('wstar', new WebRTCStar(), () => {
+      expect(Object.keys(swarm1.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('add WebRTCStar transport to swarm 2', (done) => {
+    swarm2.transport.add('wstar', new WebRTCStar(), () => {
+      expect(Object.keys(swarm2.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('listen on swarm 1', (done) => {
+    swarm1.transport.listen('wstar', {}, (conn) => {
+      conn.pipe(conn)
+    }, done)
+  })
+
+  it('listen on swarm 2', (done) => {
+    swarm2.transport.listen('wstar', {}, (conn) => {
+      conn.pipe(conn)
+    }, done)
+  })
+
+  it('dial', (done) => {
+    swarm1.transport.dial('wstar', peer2.multiaddrs[0], (err, conn) => {
+      expect(err).to.not.exist
+
+      const text = 'Hello World'
+      conn.pipe(bl((err, data) => {
+        expect(err).to.not.exist
+        expect(data.toString()).to.equal(text)
+        done()
+      }))
+
+      conn.write(text)
+      conn.end()
+    })
+  })
+
+  it('close', (done) => {
+    parallel([
+      (cb) => {
+        swarm1.transport.close('wstar', cb)
+      },
+      (cb) => {
+        swarm2.transport.close('wstar', cb)
+      }
+    ], done)
+  })
+})

test/browser-02-swarm-with-muxing-plus-websockets.js

@@ -0,0 +1,74 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const multiaddr = require('multiaddr')
+const PeerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const WebSockets = require('libp2p-websockets')
+const spdy = require('libp2p-spdy')
+const fs = require('fs')
+const path = require('path')
+
+const Swarm = require('../src')
+
+describe('high level API (swarm with spdy + websockets)', function () {
+  this.timeout(60 * 1000)
+
+  var swarm
+  var peerDst
+
+  before(() => {
+    const peerSrc = new PeerInfo()
+    swarm = new Swarm(peerSrc)
+  })
+
+  it('add spdy', () => {
+    swarm.connection.addStreamMuxer(spdy)
+    swarm.connection.reuse()
+  })
+
+  it('add ws', () => {
+    swarm.transport.add('ws', new WebSockets())
+    expect(Object.keys(swarm.transports).length).to.equal(1)
+  })
+
+  it('create Dst peer info', () => {
+    const id = PeerId.createFromJSON(
+        JSON.parse(
+          fs.readFileSync(
+            path.join(__dirname, './test-data/id-2.json'))))
+
+    peerDst = new PeerInfo(id)
+
+    const ma = multiaddr('/ip4/127.0.0.1/tcp/9200/ws')
+    peerDst.multiaddr.add(ma)
+  })
+
+  it('dial to warm a conn', (done) => {
+    swarm.dial(peerDst, (err) => {
+      expect(err).to.not.exist
+      done()
+    })
+  })
+
+  it('dial on protocol, use warmed conn', (done) => {
+    swarm.dial(peerDst, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('close', (done) => {
+    // cause CI is slow
+    setTimeout(() => {
+      swarm.close(done)
+    }, 1000)
+  })
+
+  // TODO - test that the listener (node.js peer) can dial back
+  // do that by dialing on a protocol to activate that behaviour
+  // like libp2p-spdy tests
+})

test/browser-03-swarm-with-muxing-plus-webrtc-star.js

@@ -0,0 +1,129 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const multiaddr = require('multiaddr')
+const peerId = require('peer-id')
+const PeerInfo = require('peer-info')
+const WebRTCStar = require('libp2p-webrtc-star')
+const spdy = require('libp2p-spdy')
+const bl = require('bl')
+const parallel = require('run-parallel')
+
+const Swarm = require('../src')
+
+describe('high level API (swarm with spdy + webrtc-star)', function () {
+  this.timeout(60 * 1000)
+
+  let swarm1
+  let peer1
+  let wstar1
+
+  let swarm2
+  let peer2
+  let wstar2
+
+  before(() => {
+    const id1 = peerId.create()
+    peer1 = new PeerInfo(id1)
+    const mh1 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + id1.toB58String())
+    peer1.multiaddr.add(mh1)
+
+    const id2 = peerId.create()
+    peer2 = new PeerInfo(id2)
+    const mh2 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + id2.toB58String())
+    peer2.multiaddr.add(mh2)
+
+    swarm1 = new Swarm(peer1)
+    swarm2 = new Swarm(peer2)
+  })
+
+  it('add WebRTCStar transport to swarm 1', () => {
+    wstar1 = new WebRTCStar()
+    swarm1.transport.add('wstar', wstar1)
+    expect(Object.keys(swarm1.transports).length).to.equal(1)
+  })
+
+  it('add WebRTCStar transport to swarm 2', () => {
+    wstar2 = new WebRTCStar()
+    swarm2.transport.add('wstar', wstar2)
+    expect(Object.keys(swarm2.transports).length).to.equal(1)
+  })
+
+  it('listen on swarm 1', (done) => {
+    swarm1.listen(done)
+  })
+
+  it('listen on swarm 2', (done) => {
+    swarm2.listen(done)
+  })
+
+  it('add spdy', () => {
+    swarm1.connection.addStreamMuxer(spdy)
+    swarm1.connection.reuse()
+    swarm2.connection.addStreamMuxer(spdy)
+    swarm2.connection.reuse()
+  })
+
+  it('handle proto', () => {
+    swarm2.handle('/echo/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+  })
+
+  it('dial on proto', (done) => {
+    swarm1.dial(peer2, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarm1.muxedConns).length).to.equal(1)
+
+      const text = 'Hello World'
+      conn.pipe(bl((err, data) => {
+        expect(err).to.not.exist
+        expect(data.toString()).to.equal(text)
+        expect(Object.keys(swarm2.muxedConns).length).to.equal(1)
+        done()
+      }))
+
+      conn.write(text)
+      conn.end()
+    })
+  })
+
+  it('create a third node and check that discovery works', (done) => {
+    wstar1.discovery.on('peer', (peerInfo) => {
+      expect(Object.keys(swarm1.muxedConns).length).to.equal(1)
+      swarm1.dial(peerInfo, () => {
+        expect(Object.keys(swarm1.muxedConns).length).to.equal(2)
+      })
+    })
+    wstar2.discovery.on('peer', (peerInfo) => {
+      swarm2.dial(peerInfo)
+    })
+
+    const id3 = peerId.create()
+    const peer3 = new PeerInfo(id3)
+    const mh3 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/' + id3.toB58String())
+    peer3.multiaddr.add(mh3)
+
+    const swarm3 = new Swarm(peer3)
+    const wstar3 = new WebRTCStar()
+    swarm3.transport.add('wstar', wstar3)
+    swarm3.connection.addStreamMuxer(spdy)
+    swarm3.connection.reuse()
+    swarm3.listen(() => {
+      setTimeout(() => {
+        expect(Object.keys(swarm1.muxedConns).length).to.equal(2)
+        expect(Object.keys(swarm2.muxedConns).length).to.equal(2)
+        expect(Object.keys(swarm3.muxedConns).length).to.equal(2)
+        swarm3.close(done)
+      }, 8000)
+    })
+  })
+
+  it('close', (done) => {
+    parallel([
+      swarm1.close,
+      swarm2.close
+    ], done)
+  })
+})

test/browser.js

@@ -0,0 +1,27 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const w = require('webrtcsupport')
+
+const Swarm = require('../src')
+
+describe('basics', () => {
+  it('throws on missing peerInfo', (done) => {
+    expect(Swarm).to.throw(Error)
+    done()
+  })
+})
+
+require('./browser-00-transport-websockets.js')
+
+if (w.support) {
+  require('./browser-01-transport-webrtc-star.js')
+}
+
+require('./browser-02-swarm-with-muxing-plus-websockets.js')
+
+if (w.support) {
+  require('./browser-03-swarm-with-muxing-plus-webrtc-star.js')
+  require('./browser-04-swarm-with-muxing-plus-websockets-and-webrtc-star.js')
+}

test/node.js

@@ -0,0 +1,12 @@
+/* eslint-env mocha */
+'use strict'
+
+const fs = require('fs')
+
+describe('libp2p-swarm', () => {
+  fs.readdirSync(__dirname)
+    .filter((file) => file.match(/\.node\.js$/))
+    .forEach((file) => {
+      require(`./${file}`)
+    })
+})

test/test-data/id-1.json

@@ -0,0 +1,5 @@
+{
+  "id": "QmYmfUS4A3E64BzU8DsCmCWpPhcXWU2KTKNRGtdtN4oCgU",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQCYtGLh+ow9WEJMn50voPGa6MsqSgJx8pNXGtk5kMSktWxfYHrejLZJjN0+br2CwpFMtf9JW6dAIpxb3qViBCFXjzEK8JuYaXM2sHC6sapyCxeZUbZJtGAXNWQW3qV7m8s8cJTOu2s1euT/G6uf/mIVFIzCkQDx+Ejh5Aie+BTAEf1WbLmcoDDxVESe22gpTxtMG8WTocMV34BxKn8d8vhcZZsi8LLkjg172QwQr3Q68jKgdja3K1YYm6fnso6H3+H06IHgPFAvVhycBbmlyR3bL/hFBl6+ElwBxeIrlM/oAY93KCs622SLYWFHb+J2q7WofSbUSscp3gWj7c8KJqHvAgMBAAECggEBAJZi4BcpBj/L0c9gSg8D86zZomvNY0cQ3GYmPNPibKbBPS9Y9uiBr2wT3DeGHADQ2QOxIO7/4mDZNR+Mz1cONj/i9yuM9c9N2nd7oClcmz2hCualgF5p01BH9oBHWLW5IpgtT3+hN939X9SVTZpNjg6wpEdhQosKN8yvJIZaTyUvh/ZMRIJvbnbLg13gIF7Lpyn1rtFovQg0dET0C8zhTCDPacJIOLp8BIBMknPfOl0SrvOMZjufzVZLvbt0YraXhLK8EWe87ffTMoBlIktWpEKdPBOCuFf4E4WRXJ78tcbvNtx3f5zGi+ZVbKcLA1axu+OqbjHCG6yrlywcVBoTuxECgYEA56yDBaM0VFD1CqsqwYIWmAyYBjV7dkM+ogMb+mfQn+ja6QSt+U/APXB3dP+EDvysh5AZR0wpUrmz14xC1yB1/XAKIfMLQZB8DdUkuj5UcsKjkzLJkIFYGOXIutU7IHTma7s/0fLxwp8SvkEL+6nHuZskf77yjDAvWLZeSD/CYWsCgYEAqL0mKeyyhBBFvNJyE3CyyhDfzgf+NrvrNJcx73nAzLDE44BPc/3lHYn2AJJhasNnjJfRiFzW90PNgCjZLLXqeHkX4xixoibvRtb31WHR2UyxXe/KQZwBy11mPzStnI4Y83C2A8OXsx4xAPq69nX9foSFD6cuLkWUGeb8f7Jxbo0CgYB25mfcJdW+jEom7pAj/kLgSF5hmWNC3+IuPhBG5K8C0vw+6ULsmEyee7EjX9wD4RQfAwqmN+VhaqNtNbQ8OpGzv6PDprwZKzEv3DtcRo8K0vAmpMMkIe334T6y/Kq6zqRPmCt58gi4DPIOqM2gnJM/o+sIkRRkdHpoOjiLNgXp/wKBgQCNrGpLjwl/am4zEHppKhljIPHX+cwORo8/06ZAi/g9pDlbThLnr4fb2kaqyjxyuGfLmnh5xoFSkCINdb6KFJ8t0XYl3UjffVMvJjRle0EG8qaE2Vz24zZ6egvsC52ssX3vf3XDCUjoQfQg/2NUpVJWFIvnzZUvkom7ib38tWUZzQKBgDe0+OqdJEIdajkwCMEYbmZDYqkbw4pgmwSqCwK7HeCi8dvACW5OCCutnN0L57eEltyWy0XP2XmRlfsD0atkKBq3KgNfSawx6/t/K3OtZa8VAtg2M0PbCZljW/8Bz6xlxiyPXFTRgr9zr4yM1homMmPA39hURmXNNedXUh3IMkH7",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYtGLh+ow9WEJMn50voPGa6MsqSgJx8pNXGtk5kMSktWxfYHrejLZJjN0+br2CwpFMtf9JW6dAIpxb3qViBCFXjzEK8JuYaXM2sHC6sapyCxeZUbZJtGAXNWQW3qV7m8s8cJTOu2s1euT/G6uf/mIVFIzCkQDx+Ejh5Aie+BTAEf1WbLmcoDDxVESe22gpTxtMG8WTocMV34BxKn8d8vhcZZsi8LLkjg172QwQr3Q68jKgdja3K1YYm6fnso6H3+H06IHgPFAvVhycBbmlyR3bL/hFBl6+ElwBxeIrlM/oAY93KCs622SLYWFHb+J2q7WofSbUSscp3gWj7c8KJqHvAgMBAAE="
+}

test/test-data/id-2.json

@@ -0,0 +1,5 @@
+{
+  "id": "QmQAbW9j3wQ8JDFmg8JRid82EpZabuCngVDmhqzCmJwqt6",
+  "privKey": "CAASpgkwggSiAgEAAoIBAQCAQjiCzMF+PQaDUuNa7avUsj2xnNTQcUrs4yHz/L+JI/AY2ij0iXsBSE0chK1KtBu24gZzWs3/BDyNl28E0Sd41QpK6oTVMHjUfLovO+h7G78bqpI83vk5CEOKt29VihQs282fivbQb5ALYwzBIW2lsIoWwrQq1btsNA5NXJ43OAcPZ9SybBUg49f5gWf/kmh/J6e1rvwyVjQc7cmmpzcQUc+XNL7db6T3ArokXZMyBK6oQCOaJc1bqwgHwYSI3parjds9k8Z6fXA2ub3Va//1EgjQ50lRZH03PGYS42HR1QSSz1eLjMmdrbJrZZj7IbXgqAO6gT6wlGLr5xMQudabAgMBAAECggEAQ9NBESJ4fGqHJDFUG8St5pevelqGTAhtZ+IhFWamXz6K/Il5uP9u9dmnNZqQDX47XbYfVSdC4kX6Q6I+SlzUs9htTfrA7gBpFW00BEB5C4k7wcSs+tWrE9bj6NpiXOjdDG/cSC9zn/wvP2ZM22DzG/jEvY6POku2hlzs50pAPNB7bBaKysA/e52J0Tu/Wf/+sZyp2MiYQJmIkfbYeDF2rqm5y04S6Z31O3SMQIETNcBK8T+L2jwx+Q0msB8toam7hRf1KjxD0yZe+Vff9tPfwjgEoWF+O27g3+rjDq/QqUfzOPMgvAFgELBMpv6CCM8/3l9gUu+7itBxDq65sDCoCQKBgQC6FTLTQA3ux3WV0/7MKXJIHgYZ4b8lIbiiWuO/6t2ZnwvLfTbiU5br/8bcRPL5ygFuIdzkx8VHcbkOmld/VE7qaRZoJb94JVvC6N+5MQxr+pzbWQSNcE+cKJgy1RADea8nad698ifls/39kZGCc6Srt2TqxTBuoZ3c9jEMs3N2pwKBgQCwcxNSw7Wkq302lKc/7QdtfegrwlLjRClLYaW9ESQeErayRY8pxLgl/XKap1HPyc0aQ+78W6w+DAxvcToGBsLak0ujJjzP7b8G6fo+cexuIr8NiGL4LVzpZfQjkfQU4DDwsOdedeKzGelIdstMMtAZDFG9eNPe99XeJBnYfIDS7QKBgH8xFjiHQ/6+n4T2DueGPPNGcm0mfPzoe8ed0KbR5v6mU+2XfPheon5VqpvNFTff9/JLey11z0byWMe+f6gs/HQFuKcfhiydfIdRnfp7qD32Y1kbE52J8yCOLtowAG4fsrWCDBpRdyvvR+EWqxs76IbnKDfA6UX1em4aaZSA5J9pAoGAE8aB5ue6Rt9VZDWa3QZCq9nNmIHp6kCsZB9ohN0T8C7mvOog1myOuutB2eVgvOoAC66LbUsU7ctJ5X+KIjzFv9t8Qae6bw9VNoAopLD974YDZY/gj7H91Maxav8jnOdXdNJOy/5oTuxbgdyWgk67leMUkiiljjq2hHQFVYb2pS0CgYBam0ZJ5Trds1LijE2eoYPyiJdhWEsHYFDzoV17cyjhbSrmlWJBNKQfw6q6UtnxSNFMvsPOZv53d3B8iIDnZ/UHFvw1et+yQk/QrxTfXurqn8lJcMCfKzm3ORKibgJPMmtcPbLoxuEKXMXx18iwoCsMnapijJ0Qj5HofluiupSfxg==",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCAQjiCzMF+PQaDUuNa7avUsj2xnNTQcUrs4yHz/L+JI/AY2ij0iXsBSE0chK1KtBu24gZzWs3/BDyNl28E0Sd41QpK6oTVMHjUfLovO+h7G78bqpI83vk5CEOKt29VihQs282fivbQb5ALYwzBIW2lsIoWwrQq1btsNA5NXJ43OAcPZ9SybBUg49f5gWf/kmh/J6e1rvwyVjQc7cmmpzcQUc+XNL7db6T3ArokXZMyBK6oQCOaJc1bqwgHwYSI3parjds9k8Z6fXA2ub3Va//1EgjQ50lRZH03PGYS42HR1QSSz1eLjMmdrbJrZZj7IbXgqAO6gT6wlGLr5xMQudabAgMBAAE="
+}

tests/swarm-test.js

@@ -1,507 +0,0 @@
-/* eslint-env mocha */
-
-const expect = require('chai').expect
-// const async = require('async')
-
-const multiaddr = require('multiaddr')
-// const Id = require('peer-id')
-const Peer = require('peer-info')
-const Swarm = require('../src')
-const TCP = require('libp2p-tcp')
-const WebSockets = require('libp2p-websockets')
-const bl = require('bl')
-const spdy = require('libp2p-spdy')
-
-describe('basics', () => {
-  it('throws on missing peerInfo', (done) => {
-    expect(Swarm).to.throw(Error)
-    done()
-  })
-})
-
-describe('transport - tcp', function () {
-  this.timeout(10000)
-
-  var swarmA
-  var swarmB
-  var peerA = new Peer()
-  var peerB = new Peer()
-
-  before((done) => {
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999'))
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-    done()
-  })
-
-  it('add', (done) => {
-    swarmA.transport.add('tcp', new TCP())
-    expect(Object.keys(swarmA.transports).length).to.equal(1)
-    swarmB.transport.add('tcp', new TCP(), () => {
-      expect(Object.keys(swarmB.transports).length).to.equal(1)
-      done()
-    })
-  })
-
-  it('listen', (done) => {
-    var count = 0
-    swarmA.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-    swarmB.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      if (++count === 2) {
-        expect(peerA.multiaddrs.length).to.equal(1)
-        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888'))
-        expect(peerB.multiaddrs.length).to.equal(1)
-        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999'))
-        done()
-      }
-    }
-  })
-
-  it('dial to a multiaddr', (done) => {
-    const conn = swarmA.transport.dial('tcp', multiaddr('/ip4/127.0.0.1/tcp/9999'), (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('dial to set of multiaddr, only one is available', (done) => {
-    const conn = swarmA.transport.dial('tcp', [
-      multiaddr('/ip4/127.0.0.1/tcp/9910/websockets'), // not valid on purpose
-      multiaddr('/ip4/127.0.0.1/tcp/9910'),
-      multiaddr('/ip4/127.0.0.1/tcp/9999'),
-      multiaddr('/ip4/127.0.0.1/tcp/9309')
-    ], (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('tcp', closed)
-    swarmB.transport.close('tcp', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
-  })
-
-  it('support port 0', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/0'))
-      swarm.close(done)
-    }
-  })
-
-  it('support addr /ip4/0.0.0.0/tcp/9050', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/9050'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/9050'))
-      swarm.close(done)
-    }
-  })
-
-  it('support addr /ip4/0.0.0.0/tcp/0', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/0'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/0'))
-      swarm.close(done)
-    }
-  })
-
-  it('listen in several addrs', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(3)
-      swarm.close(done)
-    }
-  })
-})
-
-describe('transport - websockets', function () {
-  this.timeout(10000)
-
-  var swarmA
-  var swarmB
-  var peerA = new Peer()
-  var peerB = new Peer()
-
-  before((done) => {
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-    done()
-  })
-
-  it('add', (done) => {
-    swarmA.transport.add('ws', new WebSockets())
-    expect(Object.keys(swarmA.transports).length).to.equal(1)
-    swarmB.transport.add('ws', new WebSockets(), () => {
-      expect(Object.keys(swarmB.transports).length).to.equal(1)
-      done()
-    })
-  })
-
-  it('listen', (done) => {
-    var count = 0
-    swarmA.transport.listen('ws', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-    swarmB.transport.listen('ws', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      if (++count === 2) {
-        expect(peerA.multiaddrs.length).to.equal(1)
-        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
-        expect(peerB.multiaddrs.length).to.equal(1)
-        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
-        done()
-      }
-    }
-  })
-
-  it('dial', (done) => {
-    const conn = swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('ws', closed)
-    swarmB.transport.close('ws', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
-  })
-})
-
-describe('transport - utp', function () {
-  this.timeout(10000)
-
-  before((done) => { done() })
-
-  it.skip('add', (done) => {})
-  it.skip('listen', (done) => {})
-  it.skip('dial', (done) => {})
-  it.skip('close', (done) => {})
-})
-
-describe('high level API - 1st without stream multiplexing (on TCP)', function () {
-  this.timeout(20000)
-
-  var swarmA
-  var peerA
-  var swarmB
-  var peerB
-
-  before((done) => {
-    peerA = new Peer()
-    peerB = new Peer()
-
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-
-    swarmA.transport.add('tcp', new TCP())
-    swarmA.transport.listen('tcp', {}, null, ready)
-
-    swarmB.transport.add('tcp', new TCP())
-    swarmB.transport.listen('tcp', {}, null, ready)
-
-    var counter = 0
-
-    function ready () {
-      if (++counter === 2) {
-        done()
-      }
-    }
-  })
-
-  after((done) => {
-    var counter = 0
-
-    swarmA.close(closed)
-    swarmB.close(closed)
-
-    function closed () {
-      if (++counter === 2) {
-        done()
-      }
-    }
-  })
-
-  it('handle a protocol', (done) => {
-    swarmB.handle('/bananas/1.0.0', (conn) => {
-      conn.pipe(conn)
-    })
-    expect(Object.keys(swarmB.protocols).length).to.equal(1)
-    done()
-  })
-
-  it('dial on protocol', (done) => {
-    swarmB.handle('/pineapple/1.0.0', (conn) => {
-      conn.pipe(conn)
-    })
-
-    swarmA.dial(peerB, '/pineapple/1.0.0', (err, conn) => {
-      expect(err).to.not.exist
-      conn.end()
-      conn.on('data', () => {}) // let it flow.. let it flooooow
-      conn.on('end', done)
-    })
-  })
-
-  it('dial to warm a conn', (done) => {
-    swarmA.dial(peerB, (err) => {
-      expect(err).to.not.exist
-      done()
-    })
-  })
-
-  it('dial on protocol, reuse warmed conn', (done) => {
-    swarmA.dial(peerB, '/bananas/1.0.0', (err, conn) => {
-      expect(err).to.not.exist
-      conn.end()
-      conn.on('data', () => {}) // let it flow.. let it flooooow
-      conn.on('end', done)
-    })
-  })
-})
-
-describe('stream muxing (on TCP)', function () {
-  this.timeout(20000)
-
-  describe('multiplex', () => {
-    before((done) => { done() })
-    after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('handle + dial on protocol', (done) => {})
-    it.skip('dial to warm conn', (done) => {})
-    it.skip('dial on protocol, reuse warmed conn', (done) => {})
-    it.skip('enable identify to reuse incomming muxed conn', (done) => {})
-  })
-  describe('spdy', () => {
-    var swarmA
-    var peerA
-    var swarmB
-    var peerB
-    var swarmC
-    var peerC
-
-    before((done) => {
-      peerA = new Peer()
-      peerB = new Peer()
-      peerC = new Peer()
-
-      // console.log('peer A', peerA.id.toB58String())
-      // console.log('peer B', peerB.id.toB58String())
-      // console.log('peer C', peerC.id.toB58String())
-
-      peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-      peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-      peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
-
-      swarmA = new Swarm(peerA)
-      swarmB = new Swarm(peerB)
-      swarmC = new Swarm(peerC)
-
-      swarmA.transport.add('tcp', new TCP())
-      swarmA.transport.listen('tcp', {}, null, ready)
-
-      swarmB.transport.add('tcp', new TCP())
-      swarmB.transport.listen('tcp', {}, null, ready)
-
-      swarmC.transport.add('tcp', new TCP())
-      swarmC.transport.listen('tcp', {}, null, ready)
-
-      var counter = 0
-
-      function ready () {
-        if (++counter === 3) {
-          done()
-        }
-      }
-    })
-
-    after((done) => {
-      var counter = 0
-
-      swarmA.close(closed)
-      swarmB.close(closed)
-      swarmC.close(closed)
-
-      function closed () {
-        if (++counter === 3) {
-          done()
-        }
-      }
-    })
-
-    it('add', (done) => {
-      swarmA.connection.addStreamMuxer(spdy)
-      swarmB.connection.addStreamMuxer(spdy)
-      swarmC.connection.addStreamMuxer(spdy)
-      done()
-    })
-
-    it('handle + dial on protocol', (done) => {
-      swarmB.handle('/abacaxi/1.0.0', (conn) => {
-        conn.pipe(conn)
-      })
-
-      swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
-        conn.end()
-
-        conn.on('data', () => {}) // let it flow.. let it flooooow
-        conn.on('end', done)
-      })
-    })
-
-    it('dial to warm conn', (done) => {
-      swarmB.dial(peerA, (err) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmB.conns).length).to.equal(0)
-        expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
-        done()
-      })
-    })
-
-    it('dial on protocol, reuse warmed conn', (done) => {
-      swarmA.handle('/papaia/1.0.0', (conn) => {
-        conn.pipe(conn)
-      })
-
-      swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmB.conns).length).to.equal(0)
-        expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
-        conn.end()
-
-        conn.on('data', () => {}) // let it flow.. let it flooooow
-        conn.on('end', done)
-      })
-    })
-
-    it('enable identify to reuse incomming muxed conn', (done) => {
-      swarmA.connection.reuse()
-      swarmC.connection.reuse()
-
-      swarmC.dial(peerA, (err) => {
-        expect(err).to.not.exist
-        setTimeout(() => {
-          expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
-          expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
-          done()
-        }, 500)
-      })
-    })
-  })
-})
-
-describe('conn upgrades', function () {
-  this.timeout(20000)
-
-  describe('secio on tcp', () => {
-    // before((done) => { done() })
-    // after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('dial', (done) => {})
-    it.skip('tls on a muxed stream (not the full conn)', (done) => {})
-  })
-  describe('tls on tcp', () => {
-    // before((done) => { done() })
-    // after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('dial', (done) => {})
-    it.skip('tls on a muxed stream (not the full conn)', (done) => {})
-  })
-})
-
-describe('high level API - with everything mixed all together!', function () {
-  this.timeout(20000)
-
-  // before((done) => { done() })
-  // after((done) => { done() })
-
-  it.skip('add tcp', (done) => {})
-  it.skip('add utp', (done) => {})
-  it.skip('add websockets', (done) => {})
-  it.skip('dial', (done) => {})
-})