move friends, invite, ref inhouse and remove dep warnings

bin.js

···
     .use(require('ssb-master'))
     .use(require('ssb-gossip'))
     .use(require('ssb-replicate'))
-    .use(require('ssb-friends'))
+    .use(require('./plugins/friends'))
     .use(require('ssb-blobs'))
-    .use(require('ssb-invite'))
+    .use(require('./plugins/invite'))
     .use(require('ssb-local'))
     .use(require('ssb-logging'))
     .use(require('ssb-query'))
···
 
 
 
-
-
-

lib/validators.js

···
 var valid = require('muxrpc-validation')
 var zerr  = require('zerr')
-var ref   = require('ssb-ref')
+var ref   = require('../plugins/ref')
 
 // errors
 var MissingAttr = zerr('Usage', 'Param % must have a .% of type "%"')
···
       return AttrType(n, 'hops', 'number')
   }
 })
-
-
-
 
 
 

npm-shrinkwrap.json

···
         "muxrpcli": "3",
         "mv": "^2.1.1",
         "osenv": "^0.1.5",
+        "flumeview-reduce": "^1.3.0",
+        "layered-graph": "^1.1.1",
         "pull-cat": "~1.1.5",
         "pull-file": "^1.0.0",
+        "pull-flatmap": "0.0.1",
         "pull-many": "~1.0.6",
+        "pull-notify": "^0.1.1",
         "pull-pushable": "^2.2.0",
         "pull-stream": "^3.6.2",
         "rimraf": "^2.4.2",
···
         "ssb-config": "^3.2.5",
         "ssb-db": "^20.0.1",
         "ssb-ebt": "^5.6.1",
-        "ssb-friends": "^4.1.0",
         "ssb-gossip": "^1.1.0",
         "ssb-invite": "^2.1.2",
         "ssb-keys": "^7.1.1",

package.json

···
     "ssb-config": "^3.2.5",
     "ssb-db": "^20.0.1",
     "ssb-ebt": "^5.6.1",
-    "ssb-friends": "^4.1.0",
     "ssb-gossip": "^1.1.0",
-    "ssb-invite": "^2.1.2",
     "ssb-keys": "^7.1.1",
     "ssb-links": "^3.0.10",
     "ssb-local": "^1.0.0",

plugins/friends/contacts.js

···
+var Reduce = require('flumeview-reduce')
+var isFeed = require('../ref').isFeed
+//track contact messages, follow, unfollow, block
+
+module.exports = function (sbot, createLayer, config) {
+
+  var layer = createLayer('contacts')
+  var initial = false
+  var hops = {}
+  hops[sbot.id] = 0
+  var index = sbot._flumeUse('contacts2', Reduce(9, function (g, data) {
+    if(!g) g = {}
+
+    var from = data.value.author
+    var to = data.value.content.contact
+    var value =
+      data.value.content.blocking || data.value.content.flagged ? -1 :
+      data.value.content.following === true ? 1
+      : -2
+
+    if(isFeed(from) && isFeed(to)) {
+      if(initial) {
+        layer(from, to, value)
+      }
+      g[from] = g[from] || {}
+      g[from][to] = value
+    }
+    return g
+  }))
+
+  // trigger flume machinery to wait until index is ready,
+  // otherwise there is a race condition when rebuilding the graph.
+  index.get(function (err, g) {
+    initial = true
+    layer(g || {})
+  })
+}
+

plugins/friends/help.js

···
+var SourceDest = {
+  source: {
+    type: 'FeedId',
+    description: 'the feed which posted the contact message'
+  },
+  dest: {
+    type: 'FeedId',
+    description: 'the feed the contact message pointed at'
+  }
+}
+
+var HopsOpts = {
+  start: {
+    type: 'FeedId',
+    description: 'feed at which to start traversing graph from, default to your own feed id'
+  },
+  max: {
+    type: 'number',
+    description: 'include feeds less than or equal to this number of hops',
+  }
+}
+
+var StreamOpts = Object.assign(
+  HopsOpts, {
+    live: {
+      type: 'boolean',
+      description: 'include real time results, defaults to false',
+    },
+    old: {
+      type: 'boolean',
+      description: 'include old results, defaults to true'
+    }
+  }
+)
+
+module.exports = {
+  description: 'track what feeds are following or blocking each other',
+  commands: {
+    isFollowing: {
+      type: 'async',
+      description: 'check if a feed is following another',
+      args: SourceDest
+    },
+    isBlocking: {
+      type: 'async',
+      description: 'check if a feed is blocking another',
+      args: SourceDest
+    },
+    hops: {
+      type: 'async',
+      description: 'dump the map of hops, show all feeds, and how far away they are from start',
+      args: HopsOpts
+    },
+    hopStream: {
+      type: 'source',
+      description: 'stream real time changes to hops. output is series of `{<FeedId>: <hops>,...}` merging these together will give the output of hops',
+      args: StreamOpts
+    },
+
+    get: {
+      type: 'async',
+      description: 'dump internal state of friends plugin, the stored follow graph',
+      args: {}
+    },
+    stream: {
+      type: 'source',
+      description: 'stream real time changes to graph. of hops, output of `get`, followed by {from: <FeedId>, to: <FeedId>: value: true|null|false, where true represents follow, null represents unfollow, and false represents block.',
+      args: StreamOpts
+    },
+    createFriendStream: {
+      type: 'source',
+      description: 'same as `stream`, but output is series of `{id: <FeedId>, hops: <hops>}`',
+      args: StreamOpts
+    },
+  }
+}
+

plugins/friends/index.js

···
+'use strict'
+var LayeredGraph = require('layered-graph')
+var pull         = require('pull-stream')
+var isFeed       = require('../ref').isFeed
+// friends plugin
+// methods to analyze the social graph
+// maintains a 'follow' and 'flag' graph
+
+exports.name = 'friends'
+exports.version = '1.0.0'
+exports.manifest = {
+  hopStream: 'source',
+  onEdge: 'sync',
+  isFollowing: 'async',
+  isBlocking: 'async',
+  hops: 'async',
+  help: 'sync',
+  // createLayer: 'sync',       // not exposed over RPC as returns a function
+  get: 'async',                 // classic (previously marked legacy)
+  createFriendStream: 'source', // classic (previously marked legacy)
+  stream: 'source'              // classic (previously marked legacy)
+}
+
+//mdm.manifest(apidoc)
+
+exports.init = function (sbot, config) {
+  var max = config.friends && config.friends.hops || config.replicate && config.replicate.hops || 3
+  var layered = LayeredGraph({max: max, start: sbot.id})
+
+  function isFollowing (opts, cb) {
+    layered.onReady(function () {
+      var g = layered.getGraph()
+      cb(null, g[opts.source] && g[opts.source][opts.dest] >= 0)
+    })
+  }
+
+  function isBlocking (opts, cb) {
+    layered.onReady(function () {
+      var g = layered.getGraph()
+      cb(null, Math.round(g[opts.source] && g[opts.source][opts.dest]) == -1)
+    })
+  }
+
+  //opinion: do not authorize peers blocked by this node.
+  sbot.auth.hook(function (fn, args) {
+    var self = this
+    isBlocking({source: sbot.id, dest: args[0]}, function (err, blocked) {
+      if(blocked)
+        args[1](new Error('client is blocked'))
+      else fn.apply(self, args)
+    })
+  })
+
+  if(!sbot.replicate)
+    throw new Error('ssb-friends expects a replicate plugin to be available')
+
+  // opinion: replicate with everyone within max hops (max passed to layered above ^)
+  pull(
+    layered.hopStream({live: true, old: true}),
+    pull.drain(function (data) {
+      if(data.sync) return
+      for(var k in data) {
+        sbot.replicate.request(k, data[k] >= 0)
+      }
+    })
+  )
+
+  require('./contacts')(sbot, layered.createLayer, config)
+
+  var classic = require('./legacy')(layered)
+
+  //opinion: pass the blocks to replicate.block
+  setImmediate(function () {
+    var block = (sbot.replicate && sbot.replicate.block) || (sbot.ebt && sbot.ebt.block)
+    if(block) {
+      function handleBlockUnlock(from, to, value) {
+        if (value === false) block(from, to, true)
+        else                 block(from, to, false)
+      }
+      pull(
+        classic.stream({live: true}),
+        pull.drain(function (contacts) {
+          if(!contacts) return
+
+          if (isFeed(contacts.from) && isFeed(contacts.to)) { // live data
+            handleBlockUnlock(contacts.from, contacts.to, contacts.value)
+          } else { // initial data
+            for (var from in contacts) {
+              var relations = contacts[from]
+              for (var to in relations)
+                handleBlockUnlock(from, to, relations[to])
+            }
+          }
+        })
+      )
+    }
+  })
+
+  return {
+    hopStream: layered.hopStream,
+    onEdge: layered.onEdge,
+    isFollowing: isFollowing,
+    isBlocking: isBlocking,
+
+    // expose createLayer, so that other plugins may express relationships
+    createLayer: layered.createLayer,
+
+    // classic, debugging
+    hops: function (opts, cb) {
+      layered.onReady(function () {
+        if(isFunction(opts))
+          cb = opts, opts = {}
+        cb(null, layered.getHops(opts))
+      })
+    },
+    help: function () { return require('./help') },
+    // classic
+    get: classic.get,
+    createFriendStream: classic.createFriendStream,
+    stream: classic.stream,
+  }
+}
+
+// helpers
+
+function isFunction (f) {
+  return 'function' === typeof f
+}

plugins/friends/legacy.js

···
+var FlatMap = require('pull-flatmap')
+var pull    = require('pull-stream')
+var Notify  = require('pull-notify')
+
+module.exports = function (layered) {
+
+  function mapGraph (g, fn) {
+    var _g = {}
+    for(var j in g)
+      for(var k in g[j]) {
+        _g[j] = _g[j] || {}
+        _g[j][k] = fn(g[j][k])
+      }
+    return _g
+  }
+
+  function map(o, fn) {
+    var _o = {}
+    for(var k in o) _o[k] = fn(o[k])
+    return _o
+  }
+
+  function toLegacyValue (v) {
+    //follow and same-as are shown as follow
+    //-2 is unfollow, -1 is block.
+    return v >= 0 ? true : v === -2 ? null : v === -1 ? false : null
+  }
+
+  var streamNotify = Notify()
+  layered.onEdge(function (j,k,v) {
+    streamNotify({from:j, to:k, value:toLegacyValue(v)})
+  })
+
+  return {
+    createFriendStream: function (opts) {
+      var first = true
+      return pull(
+        layered.hopStream(opts),
+        FlatMap(function (change) {
+          var a = []
+          for(var k in change)
+            if(!first || change[k] >= 0)
+              a.push(opts && opts.meta ? {id: k, hops: change[k]} : k)
+          first = false
+          return a
+        })
+      )
+    },
+    get: function (opts, cb) {
+      if(!cb)
+        cb = opts, opts = {}
+      layered.onReady(function () {
+        var value = layered.getGraph()
+        //opts is used like this in ssb-ws
+        if(opts && opts.source) {
+          value = value[opts.source]
+          if(value && opts.dest)
+            cb(null, toLegacyValue(value[opts.dest]))
+          else
+            cb(null, map(value, toLegacyValue))
+        }
+        else if( opts && opts.dest) {
+          var _value = {}
+          for(var k in value)
+            if('undefined' !== typeof value[k][opts.dest])
+              _value[k] = value[k][opts.dest]
+          cb(null, map(_value, toLegacyValue))
+        }
+        else
+          cb(null, mapGraph(value, toLegacyValue))
+      })
+    },
+    stream: function () {
+      var source = streamNotify.listen()
+      layered.onReady(function () {
+        source.push(mapGraph(layered.getGraph(), toLegacyValue))
+      })
+      return source
+    }
+  }
+}
+
+function isEmpty (obj) {
+  return typeof obj === 'object' &&
+    Object.keys(obj).length === 0
+}
+
+
+
+
+

plugins/invite/README.md

···
+# ssb-invite (classic, vendored)
+
+Invite-token system, mainly used for pubs. Creates invite codes as one of ways of onboarding.
+
+Generally this ends being used for pubs:
+
+- Users choose a pub from a [list of pubs](https://github.com/ssbc/ssb-server/wiki/Pub-Servers).
+- The chosen pub gives out an invite code to the user via the pub's website.
+- The user installs a Scuttlebutt client and copy and paste the invite code into the client's "accept invite" prompt.
+- The pub validates the invite code and follows back the new user, making them visible to other Scuttlebutt users.
+
+This project vendors the classic invite system used by secure-scuttlebot, and treats it as the canonical invite mechanism for this codebase.
+
+## api
+
+### create: async
+
+Create a new invite code.
+
+```shell
+create {n} [{note}, {external}]
+```
+
+```javascript
+create(n[, note, external], cb)
+```
+
+This produces an invite-code which encodes the ssb-server instance's public address, and a keypair seed.
+The keypair seed is used to generate a keypair, which is then used to authenticate a connection with the ssb-server instance.
+The ssb-server instance will then grant access to the `use` call.
+
+- `n` (number): How many times the invite can be used before it expires.
+- `note` (string): A note to associate with the invite code. The ssb-server instance will
+    include this note in the follow message that it creates when `use` is
+    called.
+- `external` (string): An external hostname to use
+
+
+### accept: async
+
+Use an invite code.
+
+ - invitecode (string)
+
+```bash
+accept {invitecode}
+```
+
+```js
+accept(invitecode, cb)
+```
+
+This connects to the server address encoded in the invite-code, then calls `use()` on the server.
+It will cause the server to follow the local user.
+
+
+### use: async
+
+Use an invite code created by this ssb-server instance (advanced function).
+
+```bash
+use --feed {feedid}
+```
+
+```javascript
+use({ feed: }, cb)
+```
+
+This commands the receiving server to follow the given feed.
+
+An invite-code encodes the ssb-server instance's address, and a keypair seed.
+The keypair seed must be used to generate a keypair, then authenticate a connection with the ssb-server instance, in order to use this function.
+
+ - `feed` (feedid): The feed the server should follow.
+

plugins/invite/help.js

···
+module.exports = {
+  description: 'accept and create pub/followbot invites',
+  commands: {
+    create: {
+      type: 'async',
+      description: 'create an invite code, must be called on a pub with a static address',
+      args: {
+        uses: {
+          type: 'number',
+          description: 'number of times this invite may be used'
+        },
+        modern: {
+          type: 'boolean',
+          description: 'return an invite which is also a multiserver address. all modern invites have a single use'
+        },
+        external: {
+          type: 'Host',
+          description: "overide the pub's host name in the invite code"
+        },
+        note: {
+          type: 'any',
+          description: 'metadata to attach to invite. this will be included in the contact message when the pub accepts this code'
+        }
+      }
+    },
+    accept: {
+      type: 'async',
+      description: 'accept an invite, connects to the pub, requests invite, then follows pub if successful',
+      args: {
+        invite: {
+          type: 'InviteCode',
+          description: 'the invite code to accept'
+        }
+      }
+    }
+  }
+}
+

plugins/invite/index.js

···
+'use strict'
+var valid = require('muxrpc-validation')({})
+var crypto = require('crypto')
+var ssbKeys = require('ssb-keys')
+var cont = require('cont')
+var explain = require('explain-error')
+var ip = require('ip')
+var fs = require('fs')
+var ref = require('../ref')
+var level = require('level')
+var sublevel = require('level-sublevel/bytewise')
+var path = require('path')
+
+var createClient = require('ssb-client/client')
+
+// invite plugin
+// adds methods for producing invite-codes,
+// which peers can use to command your server to follow them.
+
+function isFunction (f) {
+  return 'function' === typeof f
+}
+
+function isString (s) {
+  return 'string' === typeof s
+}
+
+function isObject(o) {
+  return o && 'object' === typeof o
+}
+
+function isNumber(n) {
+  return 'number' === typeof n && !isNaN(n)
+}
+
+module.exports = {
+  name: 'invite',
+  version: '1.0.0',
+  manifest: require('./manifest.json'),
+  permissions: {
+    master: {allow: ['create']},
+    //temp: {allow: ['use']}
+  },
+  init: function (server, config) {
+    var codes = {}, codesDB
+    if(server.sublevel)
+      codesDB = server.sublevel('codes')
+    else {
+      var db = sublevel(level(path.join(config.path, 'db'), {
+        valueEncoding: 'json'
+      }))
+      codesDB = db.sublevel('codes')
+    }
+    //add an auth hook.
+    server.auth.hook(function (fn, args) {
+      var pubkey = args[0], cb = args[1]
+
+      // run normal authentication
+      fn(pubkey, function (err, auth) {
+        if(err || auth) return cb(err, auth)
+
+        // if no rights were already defined for this pubkey
+        // check if the pubkey is one of our invite codes
+        codesDB.get(pubkey, function (_, code) {
+          //disallow if this invite has already been used.
+          if(code && (code.used >= code.total)) cb()
+          else cb(null, code && code.permissions)
+        })
+      })
+    })
+
+    function getInviteAddress () {
+      return (config.allowPrivate
+        ? server.getAddress('public') || server.getAddress('local') || server.getAddress('private')
+        : server.getAddress('public')
+        )
+    }
+
+    return {
+      create: valid.async(function (opts, cb) {
+        opts = opts || {}
+        if(isNumber(opts))
+          opts = {uses: opts}
+        else if(isObject(opts)) {
+          if(opts.modern)
+            opts.uses = 1
+        }
+        else if(isFunction(opts))
+          cb = opts, opts = {}
+
+        var addr = getInviteAddress()
+        if(!addr) return cb(new Error(
+          'no address available for creating an invite,'+
+          'configuration needed for server.\n'+
+          'see: https://github.com/ssbc/ssb-config/#connections'
+        ))
+        addr = addr.split(';').shift()
+        var host = ref.parseAddress(addr).host
+        if(typeof host !== 'string') {
+          return cb(new Error('Could not parse host portion from server address:' + addr))
+        }
+
+        if (opts.external)
+          host = opts.external
+
+        if(!config.allowPrivate && (ip.isPrivate(host) || 'localhost' === host || host === ''))
+          return cb(new Error('Server has no public ip address, '
+                            + 'cannot create useable invitation'))
+
+        //this stuff is SECURITY CRITICAL
+        //so it should be moved into the main app.
+        //there should be something that restricts what
+        //permissions the plugin can create also:
+        //it should be able to diminish it's own permissions.
+
+        // generate a key-seed and its key
+        var seed = crypto.randomBytes(32)
+        var keyCap = ssbKeys.generate('ed25519', seed)
+
+        // store metadata under the generated pubkey
+        var owner = server.id
+        codesDB.put(keyCap.id,  {
+          id: keyCap.id,
+          total: +opts.uses || 1,
+          note: opts.note,
+          used: 0,
+          permissions: {allow: ['invite.use', 'getAddress'], deny: null}
+        }, function (err) {
+          // emit the invite code: our server address, plus the key-seed
+          if(err) cb(err)
+          else if(opts.modern) {
+            var ws_addr = getInviteAddress().split(';').sort(function (a, b) {
+               return +/^ws/.test(b) - +/^ws/.test(a)
+            }).shift()
+
+
+            if(!/^ws/.test(ws_addr)) throw new Error('not a ws address:'+ws_addr)
+            cb(null, ws_addr+':'+seed.toString('base64'))
+          }
+          else {
+            addr = ref.parseAddress(addr)
+            cb(null, [opts.external ? opts.external : addr.host, addr.port, addr.key].join(':') + '~' + seed.toString('base64'))
+          }
+        })
+      }, 'number|object', 'string?'),
+      use: valid.async(function (req, cb) {
+        var rpc = this
+
+        // fetch the code
+        codesDB.get(rpc.id, function(err, invite) {
+          if(err) return cb(err)
+
+          // check if we're already following them
+          server.friends.get(function (err, follows) {
+//          server.friends.all('follow', function(err, follows) {
+//            if(hops[req.feed] == 1)
+            if (follows && follows[server.id] && follows[server.id][req.feed])
+              return cb(new Error('already following'))
+
+            // although we already know the current feed
+            // it's included so that request cannot be replayed.
+            if(!req.feed)
+              return cb(new Error('feed to follow is missing'))
+
+            if(invite.used >= invite.total)
+              return cb(new Error('invite has expired'))
+
+            invite.used ++
+
+            //never allow this to be used again
+            if(invite.used >= invite.total) {
+              invite.permissions = {allow: [], deny: null}
+            }
+            //TODO
+            //okay so there is a small race condition here
+            //if people use a code massively in parallel
+            //then it may not be counted correctly...
+            //this is not a big enough deal to fix though.
+            //-dominic
+
+            // update code metadata
+            codesDB.put(rpc.id, invite, function (err) {
+              server.emit('log:info', ['invite', rpc.id, 'use', req])
+
+              // follow the user
+              server.publish({
+                type: 'contact',
+                contact: req.feed,
+                following: true,
+                pub: true,
+                note: invite.note || undefined
+              }, cb)
+            })
+          })
+        })
+      }, 'object'),
+      accept: valid.async(function (invite, cb) {
+        // remove surrounding quotes, if found
+        if(isObject(invite))
+          invite = invite.invite
+
+        if (invite.charAt(0) === '"' && invite.charAt(invite.length - 1) === '"')
+          invite = invite.slice(1, -1)
+        var opts
+        // connect to the address in the invite code
+        // using a keypair generated from the key-seed in the invite code
+        var modern = false
+        if(ref.isInvite(invite)) { //legacy ivite
+          if(ref.isLegacyInvite(invite)) {
+            var parts = invite.split('~')
+            opts = ref.parseAddress(parts[0])//.split(':')
+            //convert legacy code to multiserver invite code.
+            var protocol = 'net:'
+            if (opts.host.endsWith(".onion"))
+              protocol = 'onion:'
+            invite = protocol+opts.host+':'+opts.port+'~shs:'+opts.key.slice(1, -8)+':'+parts[1]
+          }
+          else
+            modern = true
+        }
+
+        opts = ref.parseAddress(ref.parseInvite(invite).remote)
+        function connect (cb) {
+          createClient({
+            keys: true, //use seed from invite instead.
+            remote: invite,
+            config: config,
+            manifest: {invite: {use: 'async'}, getAddress: 'async'}
+          }, cb)
+        }
+
+        // retry 3 times, with timeouts.
+        // This is an UGLY hack to get the test/invite.js to pass
+        // it's a race condition, I think because the server isn't ready
+        // when it connects?
+
+        function retry (fn, cb) {
+          var n = 0
+          ;(function next () {
+            var start = Date.now()
+            fn(function (err, value) {
+              n++
+              if(n >= 3) cb(err, value)
+              else if(err) setTimeout(next, 500 + (Date.now()-start)*n)
+              else cb(null, value)
+            })
+          })()
+        }
+
+        retry(connect, function (err, rpc) {
+
+          if(err) return cb(explain(err, 'could not connect to server'))
+
+          // command the peer to follow me
+          rpc.invite.use({ feed: server.id }, function (err, msg) {
+            if(err) return cb(explain(err, 'invite not accepted'))
+
+            // follow and announce the pub
+            cont.para([
+              cont(server.publish)({
+                type: 'contact',
+                following: true,
+                autofollow: true,
+                contact: opts.key
+              }),
+              (
+                opts.host
+                ? cont(server.publish)({
+                    type: 'pub',
+                    address: opts
+                  })
+                : function (cb) { cb() }
+              )
+            ])
+            (function (err, results) {
+              if(err) return cb(err)
+              rpc.close()
+                rpc.close()
+                //ignore err if this is new style invite
+                if(server.gossip) server.gossip.add(ref.parseInvite(invite).remote, 'seed')
+                cb(null, results)
+            })
+          })
+        })
+      }, 'string')
+    }
+  }
+}

plugins/invite/manifest.json

···
+{
+  "create": "async",
+  "use": "async",
+  "accept": "async"
+}
+

plugins/ref/index.js

···
+var isCanonicalBase64 = require('is-canonical-base64')
+var isDomain = require('is-valid-domain')
+var Querystring = require('querystring')
+var ip = require('ip')
+
+var parseLinkRegex = /^((@|%|&)[A-Za-z0-9\/+]{43}=\.[\w\d]+)(\?(.+))?$/
+var linkRegex = exports.linkRegex = /^(@|%|&)[A-Za-z0-9\/+]{43}=\.[\w\d]+$/
+var feedIdRegex = exports.feedIdRegex = isCanonicalBase64('@', '\.(?:sha256|ed25519)', 32)
+var blobIdRegex = exports.blobIdRegex = isCanonicalBase64('&', '\.sha256', 32)
+var msgIdRegex = exports.msgIdRegex = isCanonicalBase64('%', '\.sha256', 32)
+
+var extractRegex = /([@%&][A-Za-z0-9\/+]{43}=\.[\w\d]+)/
+
+var MultiServerAddress = require('multiserver-address')
+
+function isMultiServerAddress (str) {
+  //a http url fits into the multiserver scheme,
+  //but all ssb address must have a transport and a transform
+  //so check there is at least one unescaped ~ in the address
+  return MultiServerAddress.check(str) && /[^!][~]/.test(str)
+}
+
+function isIP (s) {
+  return ip.isV4Format(s) || ip.isV6Format(s)
+}
+
+var isInteger = Number.isInteger
+var DEFAULT_PORT = 8008
+
+function isString (s) {
+  return 'string' === typeof s
+}
+
+var isHost = function (addr) {
+  if (!isString(addr)) return
+  addr = addr.replace(/^wss?:\/\//, '')
+  return (isIP(addr)) || isDomain(addr) || addr === 'localhost'
+}
+
+var isPort = function (p) {
+  return isInteger(p) && p <= 65536
+}
+
+function isObject (o) {
+  return o && 'object' === typeof o && !Array.isArray(o)
+}
+
+var isFeedId = exports.isFeed = exports.isFeedId =
+  function (data) {
+    return isString(data) && feedIdRegex.test(data)
+  }
+
+var isMsgId = exports.isMsg = exports.isMsgId =
+  function (data) {
+    return isString(data) && msgIdRegex.test(data)
+  }
+
+var isBlobId = exports.isBlob = exports.isBlobId =
+  function (data) {
+    return isString(data) && blobIdRegex.test(data)
+  }
+
+var isLink = exports.isLink =
+  function (data) {
+    if (!isString(data)) return false
+    var index = data.indexOf('?')
+    data = ~index ? data.substring(0, index) : data
+    return isString(data) && (isFeedId(data) || isMsgId(data) || isBlobId(data))
+  }
+
+exports.isBlobLink = function (s) {
+  return s[0] === '&' && isLink(s)
+}
+
+exports.isMsgLink = function (s) {
+  return s[0] === '%' && isLink(s)
+}
+
+var normalizeChannel = exports.normalizeChannel =
+  function (data) {
+    if (typeof data === 'string') {
+      data = data.toLowerCase().replace(/\s|,|\.|\?|!|<|>|\(|\)|\[|\]|"|#/g, '')
+      if (data.length > 0 && data.length < 30) {
+        return data
+      }
+    }
+  }
+
+// Classic ssb-ref had deprecation wrappers around some APIs (console.trace).
+// For "classic" usage in this repo, we keep the APIs but drop the warnings.
+function deprecate (name, fn) {
+  return fn
+}
+
+var parseMultiServerAddress = function (data) {
+  if (!isString(data)) return false
+  if (!MultiServerAddress.check(data)) return false
+
+  var addr = MultiServerAddress.decode(data)
+  addr = addr.find(function (address) {
+    if (!address[0]) return false
+    if (!address[1]) return false
+    return /^(net|wss?|onion)$/.test(address[0].name) && /^shs/.test(address[1].name)
+  })
+  if (!Array.isArray(addr)) {
+    return false
+  }
+  var port = +addr[0].data.pop() //last item always port, to handle ipv6
+
+  //preserve protocol type on websocket addresses
+  var host = (/^wss?$/.test(addr[0].name) ? addr[0].name + ':' : '') + addr[0].data.join(':')
+  var key = '@' + addr[1].data[0] + '.ed25519'
+  var seed = addr[1].data[2]
+  // allow multiserver addresses that are not currently understood!
+  if (!(isHost(host) && isPort(+port) && isFeedId(key))) return false
+  var address = {
+    host: host,
+    port: port,
+    key: key
+  }
+
+  if (seed) address.seed = seed
+  return address
+}
+
+var toLegacyAddress = parseMultiServerAddress
+exports.toLegacyAddress = deprecate('ssb-ref.toLegacyAddress', toLegacyAddress)
+
+var isLegacyAddress = exports.isLegacyAddress = function (addr) {
+  return isObject(addr) && isHost(addr.host) && isPort(addr.port) && isFeedId(addr.key)
+}
+
+var toMultiServerAddress = exports.toMultiServerAddress = function (addr) {
+  if (MultiServerAddress.check(addr)) return addr
+  if (!isPort(addr.port)) throw new Error('ssb-ref.toMultiServerAddress - invalid port:' + addr.port)
+  if (!isHost(addr.host)) throw new Error('ssb-ref.toMultiServerAddress - invalid host:' + addr.host)
+  if (!isFeedId(addr.key)) throw new Error('ssb-ref.toMultiServerAddress - invalid key:' + addr.key)
+
+  return (
+    /^wss?:/.test(addr.host) ? addr.host
+      : /\.onion$/.test(addr.host) ? 'onion:' + addr.host
+        : 'net:' + addr.host
+  ) + ':' + addr.port + '~shs:' + addr.key.substring(1, addr.key.indexOf('.'))
+}
+
+var isAddress = exports.isAddress = function (data) {
+  var host, port, id
+  if (isObject(data)) {
+    id = data.key; host = data.host; port = data.port
+  } else if (!isString(data)) return false
+  else if (isMultiServerAddress(data)) return true
+  else {
+    var parts = data.split(':')
+    id = parts.pop(); port = parts.pop(); host = parts.join(':')
+  }
+  return (
+    isFeedId(id) && isPort(+port) &&
+    isHost(host)
+  )
+}
+
+//This is somewhat fragile, because maybe non-shs protocols get added...
+//it would be better to treat all addresses as opaque or have multiserver handle
+//extraction of a signing key from the address.
+var getKeyFromAddress = exports.getKeyFromAddress = function (addr) {
+  if (addr.key) return addr.key
+  var data = MultiServerAddress.decode(addr)
+  if (!data) return
+  for (var k in data) {
+    var address = data[k]
+    for (var j in address) {
+      var protocol = address[j]
+      if (/^shs/.test(protocol.name)) //forwards compatible with future shs versions...
+        return '@' + protocol.data[0] + '.ed25519'
+    }
+  }
+}
+
+var parseAddress = function (e) {
+  if (isString(e)) {
+    if (~e.indexOf('~'))
+      return parseMultiServerAddress(e)
+    var parts = e.split(':')
+    var id = parts.pop(), port = parts.pop(), host = parts.join(':')
+    var e = {
+      host: host,
+      port: +(port || DEFAULT_PORT),
+      key: id
+    }
+    return e
+  }
+  return e
+}
+exports.parseAddress = deprecate('ssb-ref.parseAddress', parseAddress)
+
+var toAddress = exports.toAddress = function (e) {
+  e = parseAddress(e)
+  e.port = e.port || DEFAULT_PORT
+  e.host = e.host || 'localhost'
+  return e
+}
+
+var legacyInviteRegex = /^[A-Za-z0-9\/+]{43}=$/
+var legacyInviteFixerRegex = /#.*$/
+var isLegacyInvite = exports.isLegacyInvite =
+  function (data) {
+    if (!isString(data)) return false
+    data = data.replace(legacyInviteFixerRegex, '')
+    var parts = data.split('~')
+    return parts.length == 2 && isAddress(parts[0]) && legacyInviteRegex.test(parts[1])
+  }
+
+var isMultiServerInvite = exports.isMultiServerInvite =
+  function (data) {
+    if (!isString(data)) return false
+    return !!parseMultiServerInvite(data)
+  }
+
+var isInvite = exports.isInvite =
+  function (data) {
+    if (!isString(data)) return false
+    return isLegacyInvite(data) || isMultiServerInvite(data)
+  }
+
+exports.parseLink = function parseBlob (ref) {
+  var match = parseLinkRegex.exec(ref)
+  if (match && match[1]) {
+    if (match[3]) {
+      var query = Querystring.parse(match[4])
+      // unbox keys have a '+' in them that is parsed into a ' ', this changes it back
+      if (isString(query.unbox)) query.unbox = query.unbox.replace(/ /g, '+')
+      return { link: match[1], query: query }
+    } else {
+      return { link: match[1] }
+    }
+  }
+}
+
+function parseLegacyInvite (invite) {
+  var redirect = invite.split('#')
+  invite = redirect.shift()
+  var parts = invite.split('~')
+  var addr = toAddress(parts[0])
+  //convert legacy code to multiserver invite code.
+  var remote = toMultiServerAddress(addr)
+  invite = remote + ':' + parts[1]
+  return {
+    invite: remote + ':' + parts[1],
+    key: addr.key,
+    redirect: redirect.length ? '#' + redirect.join('#') : null
+  }
+}
+
+function parseMultiServerInvite (invite) {
+  var redirect = invite.split('#')
+  if (!redirect.length) return null
+
+  invite = redirect.shift()
+  var addr = toLegacyAddress(invite)
+  if (!addr) return null
+  delete addr.seed
+  return {
+    invite: invite,
+    remote: toMultiServerAddress(addr),
+    key: addr.key,
+    redirect: redirect.length ? '#' + redirect.join('#') : null
+  }
+}
+
+exports.parseLegacyInvite = deprecate('ssb-ref.parseLegacyInvite', parseLegacyInvite)
+exports.parseMultiServerInvite = deprecate('ssb-ref.parseMultiServerInvite', parseMultiServerInvite)
+
+exports.parseInvite = deprecate('ssb-ref.parseInvite', function (invite) {
+  return (
+    isLegacyInvite(invite)
+      ? parseLegacyInvite(invite)
+      : isMultiServerInvite(invite)
+        ? parseMultiServerInvite(invite)
+        : null
+  )
+})
+
+exports.type =
+  function (id) {
+    if (!isString(id)) return false
+    var c = id.charAt(0)
+    if (c == '@' && isFeedId(id))
+      return 'feed'
+    else if (c == '%' && isMsgId(id))
+      return 'msg'
+    else if (c == '&' && isBlobId(id))
+      return 'blob'
+    else if (isAddress(id)) return 'address'
+    else if (isInvite(id)) return 'invite'
+    else
+      return false
+  }
+
+exports.extract =
+  function (data) {
+    if (!isString(data))
+      return false
+
+    var _data = data
+
+    var res = extractRegex.exec(_data)
+    if (res) {
+      return res && res[0]
+    } else {
+      try { _data = decodeURIComponent(data) }
+      catch (e) {} // this may fail if it's not encoded, so don't worry if it does
+      _data = _data.replace(/&amp;/g, '&')
+
+      var res = extractRegex.exec(_data)
+      return res && res[0]
+    }
+  }
+
+
+
+
+
+
+

test/caps.js

···
   require('secret-stack')(require('./defaults'))
     .use(require('ssb-db'))
     .use(require('ssb-replicate'))
-    .use(require('ssb-friends'))
+    .use(require('../plugins/friends'))
     .use(require('ssb-gossip'))
     .use(require('ssb-logging'))
 

test/util.js

···
-var ref = require('ssb-ref')
+var ref = require('../plugins/ref')
 
 exports.follow = function (id) {
   return {
···
     file: hash
   }
 }
-