chore: release version v0.18.2

Make identify not freak out on missing pubkey, it is ok.. this enables webrtc-star discovery to work fine

README.md

@@ -9,7 +9,7 @@ libp2p-swarm JavaScript implementation
 [![Dependency Status](https://david-dm.org/diasdavid/js-libp2p-swarm.svg?style=flat-square)](https://david-dm.org/ipfs/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
 
@@ -47,10 +47,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
+- `key` - the transport identifier.
 - `transport` -
-- `options`
-- `callback`
+- `options` -
+- `callback` -
 
 ##### `swarm.transport.dial(key, multiaddrs, callback)`
 

gulpfile.js

@@ -1,21 +1,31 @@
 'use strict'
 
 const gulp = require('gulp')
-const Peer = require('peer-info')
-const Id = require('peer-id')
+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 b58IdA = 'QmWg2L4Fucx1x4KXJTfKHGixBJvveubzcd7DdhB2Mqwfh1'
-    const peerA = new Peer(Id.createFromB58String(b58IdA))
-    const maA = multiaddr('/ip4/127.0.0.1/tcp/9100/websockets')
+    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)
@@ -24,23 +34,30 @@ gulp.task('test:browser:before', (done) => {
   }
 
   function createListenerB (cb) {
-    const b58IdB = 'QmRy1iU6BHmG5Hd8rnPhPL98cy1W1przUSTAMcGDq9yAAV'
-    const maB = multiaddr('/ip4/127.0.0.1/tcp/9200/websockets')
-    const peerB = new Peer(Id.createFromB58String(b58IdB))
+    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.transport.listen('ws', {}, null, cb)
-
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmB.connection.reuse()
+    swarmB.listen(cb)
     swarmB.handle('/echo/1.0.0', echo)
   }
 
   let count = 0
-  const ready = () => ++count === 2 ? done() : null
+  const ready = () => ++count === 3 ? done() : null
 
   createListenerA(ready)
   createListenerB(ready)
+  sigS = sigServer.start(15555, ready)
 
   function echo (conn) {
     conn.pipe(conn)
@@ -49,10 +66,11 @@ gulp.task('test:browser:before', (done) => {
 
 gulp.task('test:browser:after', (done) => {
   let count = 0
-  const ready = () => ++count === 2 ? done() : null
+  const ready = () => ++count === 3 ? done() : null
 
   swarmA.transport.close('ws', ready)
-  swarmB.transport.close('ws', ready)
+  swarmB.close(ready)
+  sigS.stop(ready)
 })
 
 require('aegir/gulp')(gulp)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-swarm",
-  "version": "0.12.10",
+  "version": "0.18.2",
   "description": "libp2p swarm implementation in JavaScript",
   "main": "lib/index.js",
   "jsnext:main": "src/index.js",
@@ -37,27 +37,30 @@
     "node": "^4.3.0"
   },
   "devDependencies": {
+    "aegir": "^3.0.4",
     "bl": "^1.1.2",
     "buffer-loader": "0.0.1",
     "chai": "^3.5.0",
-    "aegir": "^3.0.1",
     "gulp": "^3.9.1",
     "istanbul": "^0.4.3",
     "libp2p-multiplex": "^0.2.1",
-    "libp2p-spdy": "^0.3.1",
-    "libp2p-tcp": "^0.5.1",
-    "libp2p-websockets": "^0.4.4",
+    "libp2p-spdy": "^0.6.1",
+    "libp2p-tcp": "^0.6.0",
+    "libp2p-webrtc-star": "^0.1.4",
+    "libp2p-websockets": "^0.6.0",
     "pre-commit": "^1.1.2",
-    "stream-pair": "^1.0.3"
+    "stream-pair": "^1.0.3",
+    "webrtcsupport": "^2.2.0"
   },
   "dependencies": {
     "babel-runtime": "^6.6.1",
+    "browserify-zlib": "github:ipfs/browserify-zlib",
     "duplex-passthrough": "github:diasdavid/duplex-passthrough",
     "ip-address": "^5.8.0",
     "lodash.contains": "^2.4.3",
-    "multiaddr": "^1.4.1",
-    "multistream-select": "^0.6.5",
-    "peer-id": "^0.6.6",
+    "multiaddr": "^2.0.0",
+    "multistream-select": "^0.9.0",
+    "peer-id": "^0.6.7",
     "peer-info": "^0.6.2",
     "protocol-buffers-stream": "^1.3.1",
     "run-parallel": "^1.1.6"

src/connection.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const connHandler = require('./default-handler')
+const identify = require('./identify')
+
+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)
+
+        var peerIdForConn
+
+        muxedConn.on('stream', (conn) => {
+          function gotId () {
+            if (peerIdForConn) {
+              conn.peerId = peerIdForConn
+              connHandler(swarm.protocols, conn)
+            } else {
+              setTimeout(gotId, 100)
+            }
+          }
+
+          if (swarm.identify) {
+            return gotId()
+          }
+
+          connHandler(swarm.protocols, conn)
+        })
+
+        // if identify is enabled, attempt to do it for muxer reuse
+        if (swarm.identify) {
+          identify.exec(conn, muxedConn, swarm._peerInfo, (err, pi) => {
+            if (err) {
+              return console.log('Identify exec failed', err)
+            }
+
+            peerIdForConn = pi.id
+            swarm.muxedConns[pi.id.toB58String()] = {}
+            swarm.muxedConns[pi.id.toB58String()].muxer = muxedConn
+            swarm.muxedConns[pi.id.toB58String()].conn = conn // to be able to extract addrs
+
+            swarm.emit('peer-mux-established', pi)
+
+            muxedConn.on('close', () => {
+              delete swarm.muxedConns[pi.id.toB58String()]
+              swarm.emit('peer-mux-closed', pi)
+            })
+          })
+        }
+      })
+    },
+
+    reuse () {
+      swarm.identify = true
+      swarm.handle(identify.multicodec, identify.handler(swarm._peerInfo, swarm))
+    }
+  }
+}

src/default-handler.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const multistream = require('multistream-select')
+
+// incomming connection handler
+module.exports = function connHandler (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/dial.js

@@ -0,0 +1,179 @@
+'use strict'
+
+const multistream = require('multistream-select')
+const DuplexPassThrough = require('duplex-passthrough')
+
+const connHandler = require('./default-handler')
+
+module.exports = function dial (swarm) {
+  return (pi, protocol, callback) => {
+    if (typeof protocol === 'function') {
+      callback = protocol
+      protocol = null
+    }
+
+    if (!callback) {
+      callback = function noop () {}
+    }
+
+    const pt = new DuplexPassThrough()
+
+    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 pt
+
+    function gotWarmedUpConn (conn) {
+      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) {
+      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, js-libp2p-swarm doesn't implement any crypto
+            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
+            swarm.muxedConns[b58Id].conn = conn
+
+            swarm.emit('peer-mux-established', pi)
+
+            muxedConn.on('close', () => {
+              delete swarm.muxedConns[pi.id.toB58String()]
+              swarm.emit('peer-mux-closed', pi)
+            })
+
+            // in case identify is on
+            muxedConn.on('stream', (conn) => {
+              conn.peerId = pi.id
+              connHandler(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)
+          }
+
+          pt.wrapStream(conn)
+          pt.peerId = pi.id
+          callback(null, pt)
+        })
+      })
+    }
+  }
+}

src/identify.js

@@ -19,7 +19,7 @@ const identity = fs.readFileSync(path.join(__dirname, 'identify.proto'))
 const pbStream = require('protocol-buffers-stream')(identity)
 
 exports = module.exports
-exports.multicodec = '/ipfs/identify/1.0.0'
+exports.multicodec = '/ipfs/id/1.0.0'
 
 exports.exec = (rawConn, muxer, peerInfo, callback) => {
   // 1. open a stream
@@ -30,9 +30,13 @@ exports.exec = (rawConn, muxer, peerInfo, callback) => {
 
   const conn = muxer.newStream()
 
-  var msI = new multistream.Interactive()
-  msI.handle(conn, () => {
-    msI.select(exports.multicodec, (err, ds) => {
+  const ms = new multistream.Dialer()
+  ms.handle(conn, (err) => {
+    if (err) {
+      return callback(err)
+    }
+
+    ms.select(exports.multicodec, (err, ds) => {
       if (err) {
         return callback(err)
       }
@@ -58,7 +62,7 @@ exports.exec = (rawConn, muxer, peerInfo, callback) => {
       pbs.identify({
         protocolVersion: 'na',
         agentVersion: 'na',
-        publicKey: peerInfo.id.pubKey,
+        publicKey: peerInfo.id.pubKey || new Buffer(0),
         listenAddrs: peerInfo.multiaddrs.map((mh) => mh.buffer),
         observedAddr: obsMultiaddr ? obsMultiaddr.buffer : new Buffer('')
       })
@@ -75,7 +79,6 @@ exports.handler = (peerInfo, swarm) => {
     // 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', (msg) => {
       if (msg.observedAddr.length > 0) {
         peerInfo.multiaddr.addSafe(multiaddr(msg.observedAddr))
@@ -88,12 +91,13 @@ exports.handler = (peerInfo, swarm) => {
       pbs.identify({
         protocolVersion: 'na',
         agentVersion: 'na',
-        publicKey: peerInfo.id.pubKey,
+        publicKey: peerInfo.id.pubKey || new Buffer(0),
         listenAddrs: peerInfo.multiaddrs.map((ma) => ma.buffer),
         observedAddr: obsMultiaddr ? obsMultiaddr.buffer : new Buffer('')
       })
       pbs.finalize()
     })
+
     pbs.pipe(conn).pipe(pbs)
   }
 }

src/index.js

@@ -1,12 +1,14 @@
 'use strict'
 
-const multistream = require('multistream-select')
-const identify = require('./identify')
-const DuplexPassThrough = require('duplex-passthrough')
-const contains = require('lodash.contains')
 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 connHandler = require('./default-handler')
 
 exports = module.exports = Swarm
 
@@ -21,112 +23,13 @@ function Swarm (peerInfo) {
     throw new Error('You must provide a value for `peerInfo`')
   }
 
+  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 = this.transports[key].filter(
-      peerInfo.multiaddrs.map((addr) => {
-        // ipfs multiaddrs are not dialable so we drop them here
-        if (contains(addr.protoNames(), 'ipfs')) {
-          return addr.decapsulate('ipfs')
-        }
-
-        return addr
-      })
-    )
-
-    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) => {
-    const transport = this.transports[key]
-
-    if (!transport) {
-      return callback(new Error(`Trying to close non existing transport: ${key}`))
-    }
-
-    transport.close(callback)
-  }
-
   // connections --
 
   // { peerIdB58: { conn: <conn> }}
@@ -143,240 +46,43 @@ 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)
+  // is the Identify protocol enabled?
+  this.identify = false
 
-      var peerIdForConn
+  this.transport = transport(this)
+  this.connection = connection(this)
 
-      muxedConn.on('stream', (conn) => {
-        function gotId () {
-          if (peerIdForConn) {
-            conn.peerId = peerIdForConn
-            connHandler(conn)
-          } else {
-            setTimeout(gotId, 100)
-          }
+  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 (this.identify) {
-          return gotId()
+        if (contains(addr.protoNames(), 'ipfs')) {
+          return addr.decapsulate('ipfs')
         }
-
-        connHandler(conn)
+        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)
-          }
-
-          peerIdForConn = pi.id
-          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
-
-          self.emit('peer-mux-established', pi)
-
-          muxedConn.on('close', () => {
-            delete self.muxedConns[pi.id.toB58String()]
-            self.emit('peer-mux-closed', pi)
-          })
-        })
-      }
-    })
-  }
-
-  // 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)
-  }
-
-  function availableTransports (pi) {
-    const addrs = pi.multiaddrs
-    return Object.keys(self.transports).filter((ts) => {
-      // Only listen on transports we actually have addresses for
-      return self.transports[ts].filter(addrs).length > 0
+      return this.transports[ts].filter(dialable).length > 0
     })
   }
 
   // higher level (public) API
-  this.dial = (pi, protocol, callback) => {
-    if (typeof protocol === 'function') {
-      callback = protocol
-      protocol = null
-    }
-
-    if (!callback) {
-      callback = function noop () {}
-    }
-
-    const pt = new DuplexPassThrough()
-
-    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 {
-      if (!protocol) {
-        return callback()
-      }
-      gotMuxer(this.muxedConns[b58Id].muxer)
-    }
-
-    return pt
-
-    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 = availableTransports(pi)
-      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
-
-            self.emit('peer-mux-established', pi)
-
-            muxedConn.on('close', () => {
-              delete self.muxedConns[pi.id.toB58String()]
-              self.emit('peer-mux-closed', pi)
-            })
-
-            // in case identify is on
-            muxedConn.on('stream', (conn) => {
-              conn.peerId = pi.id
-              connHandler(conn)
-            })
-
-            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)
-          pt.peerId = pi.id
-          callback(null, pt)
-        })
-      })
-    }
-  }
+  this.dial = dial(this)
 
   // Start listening on all available transports
   this.listen = (callback) => {
-    parallel(availableTransports(peerInfo).map((ts) => (cb) => {
+    parallel(this.availableTransports(peerInfo).map((ts) => (cb) => {
       // Listen on the given transport
       this.transport.listen(ts, {}, null, cb)
     }), callback)
@@ -386,6 +92,11 @@ function Swarm (peerInfo) {
     this.protocols[protocol] = handler
   }
 
+  // our crypto handshake :)
+  this.handle('/plaintext/1.0.0', (conn) => {
+    connHandler(this.protocols, conn)
+  })
+
   this.unhandle = (protocol, handler) => {
     if (this.protocols[protocol]) {
       delete this.protocols[protocol]
@@ -402,5 +113,3 @@ function Swarm (peerInfo) {
     }), callback)
   }
 }
-
-function noop () {}

src/transport.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const contains = require('lodash.contains')
+const DuplexPassThrough = require('duplex-passthrough')
+
+const connHandler = require('./default-handler')
+
+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
+      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(), {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())
+        })
+      }
+    },
+
+    listen (key, options, handler, callback) {
+      // if no callback is passed, we pass conns to connHandler
+      if (!handler) {
+        handler = connHandler.bind(null, swarm.protocols)
+      }
+
+      const multiaddrs = dialables(swarm.transports[key], swarm._peerInfo.multiaddrs)
+
+      swarm.transports[key].createListener(multiaddrs, handler, (err, maUpdate) => {
+        if (err) {
+          return callback(err)
+        }
+        if (maUpdate) {
+          // because we can listen on port 0...
+          swarm._peerInfo.multiaddr.replace(multiaddrs, maUpdate)
+        }
+
+        callback()
+      })
+    },
+
+    close (key, callback) {
+      const transport = swarm.transports[key]
+
+      if (!transport) {
+        return callback(new Error(`Trying to close non existing transport: ${key}`))
+      }
+
+      transport.close(callback)
+    }
+  }
+}
+
+// transform given multiaddrs to a list of dialable addresses
+// for the given transport `tp`.
+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
+    }
+
+    // ipfs multiaddrs are not dialable so we drop them here
+    if (contains(addr.protoNames(), 'ipfs')) {
+      return addr.decapsulate('ipfs')
+    }
+
+    return addr
+  }))
+}
+
+function noop () {}

test/01-transport-tcp.node.js

@@ -77,7 +77,7 @@ describe('transport - tcp', function () {
 
   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/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')

test/03-transport-websockets.node.js

@@ -19,8 +19,8 @@ describe('transport - websockets', function () {
   var peerB = new Peer()
 
   before(() => {
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
+    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)
   })
@@ -45,13 +45,13 @@ describe('transport - websockets', function () {
     ], () => {
       expect(peerA.multiaddrs.length).to.equal(1)
       expect(
-        peerA.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
+        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/websockets'))
+        peerB.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9999/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC'))
       ).to.equal(
         true
       )
@@ -60,7 +60,7 @@ describe('transport - websockets', function () {
   })
 
   it('dial', (done) => {
-    const conn = swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, conn) => {
+    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) => {
@@ -72,7 +72,7 @@ describe('transport - websockets', function () {
   })
 
   it('dial (conn from callback)', (done) => {
-    swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, 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) => {

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

@@ -47,7 +47,7 @@ describe('high level API - 1st without stream multiplexing (on TCP)', function (
     swarmB.handle('/bananas/1.0.0', (conn) => {
       conn.pipe(conn)
     })
-    expect(Object.keys(swarmB.protocols).length).to.equal(1)
+    expect(Object.keys(swarmB.protocols).length).to.equal(2)
     done()
   })
 

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

@@ -74,10 +74,10 @@ describe('high level API - with everything mixed all together!', function () {
   it.skip('add utp', (done) => {})
 
   it('add websockets', (done) => {
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9012/websockets'))
-    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9022/websockets'))
-    peerD.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9032/websockets'))
-    peerE.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9042/websockets'))
+    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())

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

@@ -2,11 +2,7 @@
 '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 w = require('webrtcsupport')
 
 const Swarm = require('../src')
 
@@ -17,102 +13,15 @@ describe('basics', () => {
   })
 })
 
-describe('transport - websockets', function () {
-  this.timeout(10000)
+require('./browser-00-transport-websockets.js')
 
-  var swarm
+if (w.support) {
+  require('./browser-01-transport-webrtc-star.js')
+}
 
-  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)
-  })
+require('./browser-02-swarm-with-muxing-plus-websockets.js')
 
-  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/websockets')
-
-    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()
-  })
-})
-
-describe('high level API - 1st without stream multiplexing (on websockets)', function () {
-  this.timeout(10000)
-
-  var swarm
-  var peerDst
-
-  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)
-  })
-
-  after((done) => {
-    swarm.close(done)
-  })
-
-  it('add ws', () => {
-    swarm.transport.add('ws', new WebSockets())
-    expect(Object.keys(swarm.transports).length).to.equal(1)
-  })
-
-  it('create Dst peer info', () => {
-    const b58IdDst = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
-    // use a pre generated Id to save time
-    const idDst = Id.createFromB58String(b58IdDst)
-    peerDst = new Peer(idDst)
-
-    const ma = multiaddr('/ip4/127.0.0.1/tcp/9200/websockets')
-    peerDst.multiaddr.add(ma)
-  })
-
-  it('dial on protocol', (done) => {
-    swarm.dial(peerDst, '/echo/1.0.0', (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()
-    })
-  })
-
-  it('dial to warm a conn', (done) => {
-    swarm.dial(peerDst, (err) => {
-      expect(err).to.not.exist
-      done()
-    })
-  })
-
-  it('dial on protocol, reuse 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)
-    })
-  })
-})
+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/test-data/id-1.json

@@ -0,0 +1,5 @@
+{
+  "id": "1220dddcb7b540358368df92bf537a60f20663130ca09ef9eec40b9a4ed15b3572a7",
+  "privKey": "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",
+  "pubKey": "080012a60230820122300d06092a864886f70d01010105000382010f003082010a02820101008b6959ff2e965869d2d450ced6135e641c92ceaa216877c566de2cab9a9d6e62f8a859efa8f71c8e67d1722cddb5afc4d382001d423e9839f382e543723500566e3e71fe08c004765f848aacda8df2478dcfdafc0fa377cc6beda9e5c5a9b456ccb0fccde94ade50fd58a057d79e805344fa57ee75e28cce37bda4f68fd890f21a99598e68bb02ebb36864a8503403a5d01eba9873def7cf19c10a6cb9d0eaff55e714a0855fe0323feec9ce1a1d5787a9908ac4171becb75450c06e7d5f747954ac8b9ee58d259bf931ceb7366b454c7bc82c18490c8407866969858a6c13e11b721780806f2116ad771caf6a3674c77ba0176a4c4c5fefdaa93fcae5dc03d50203010001"
+}

test/test-data/id-2.json

@@ -0,0 +1,5 @@
+{
+  "id": "12209cc55e7a4dd253eb4867307a21dde36c49ff044c7ffac7adbecc339dc949e32b",
+  "privKey": "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",
+  "pubKey": "080012a60230820122300d06092a864886f70d01010105000382010f003082010a028201010081365503703172a249b6d98d833c8ff875d8d7e8bec3f76fdca94f24ca0f73c84b5b2748381071deeabbb64309c9edd3c084f0fce0351d3fa131151fa9bb0d4bfd03b856f21f483a8162e657e0487a7b4c3045c0e86291007ae175bf46872c9794043271d0a5940ba76126e1b448cfcaf84150b7a56da997cad75e996176d2750526be99907edf35f4bae8490df2f96b4b337f11c18f7ec3d428209682fdf420e5cb11d59ba3aace98ead99bfa39e403bbc343aed643f04c1b0af9d9fbf6a815dc1ddaf58de655d49eaea58020634e6e3bdd21684e157b07b54162c509bed7ae74e04da7a188f59adc982da4e3ed1d525a3c2d23f6c7535d154bdb9b2e97426f0203010001"
+}