hypercore 10.0.0-alpha.19 → 10.0.0-alpha.22

package/index.js

@@ -108,6 +108,7 @@ module.exports = class Hypercore extends EventEmitter {
 
     if (!noiseStream.userData) {
       const protocol = Replicator.createProtocol(noiseStream)
+      if (opts.keepAlive !== false) protocol.setKeepAlive(true)
       noiseStream.userData = protocol
       noiseStream.on('error', noop) // All noise errors already propagate through outerStream
     }
@@ -230,6 +231,8 @@ module.exports = class Hypercore extends EventEmitter {
     this.storage = Hypercore.defaultStorage(opts.storage || storage)
 
     this.core = await Core.open(this.storage, {
+      createIfMissing: opts.createIfMissing,
+      overwrite: opts.overwrite,
       keyPair,
       crypto: this.crypto,
       onupdate: this._oncoreupdate.bind(this)

package/lib/protocol.js

@@ -2,9 +2,19 @@ const { uint, from: fromEncoding } = require('compact-encoding')
 const b4a = require('b4a')
 const safetyCatch = require('safety-catch')
 const codecs = require('codecs')
+const sodium = require('sodium-universal')
 
 const messages = require('./messages')
 
+const slab = b4a.alloc(96)
+const NS = slab.subarray(0, 32)
+const NS_HYPERCORE_INITIATOR = slab.subarray(32, 64)
+const NS_HYPERCORE_RESPONDER = slab.subarray(64, 96)
+
+sodium.crypto_generichash(NS, b4a.from('hypercore'))
+sodium.crypto_generichash(NS_HYPERCORE_INITIATOR, b4a.from([0]), NS)
+sodium.crypto_generichash(NS_HYPERCORE_RESPONDER, b4a.from([1]), NS)
+
 class Extension {
   constructor (protocol, type, name, handlers) {
     this.protocol = protocol
@@ -256,11 +266,17 @@ module.exports = class Protocol {
     this._localExtensions = 128
     this._remoteExtensions = []
     this._extensions = new Map()
+    this._keepAliveInterval = null
+    this._pendingCaps = []
 
     this._destroyer = this._safeDestroy.bind(this)
     this.noiseStream.on('data', this.onmessage.bind(this))
     this.noiseStream.on('end', this.noiseStream.end) // no half open
+    this.noiseStream.on('finish', () => {
+      this.setKeepAlive(false)
+    })
     this.noiseStream.on('close', () => {
+      this.setKeepAlive(false)
       // TODO: If the stream was destroyed with an error, we probably want to forward it here
       for (const peer of this._peers.values()) {
         peer.destroy(null)
@@ -270,6 +286,18 @@ module.exports = class Protocol {
     this._sendHandshake()
   }
 
+  setKeepAlive (enable) {
+    if (enable) {
+      if (this._keepAliveInterval) return
+      this._keepAliveInterval = setInterval(this.ping.bind(this), 5000)
+      if (this._keepAliveInterval.unref) this._keepAliveInterval.unref()
+    } else {
+      if (!this._keepAliveInterval) return
+      clearInterval(this._keepAliveInterval)
+      this._keepAliveInterval = null
+    }
+  }
+
   _sendHandshake () {
     const m = { protocolVersion: this.protocolVersion, userAgent: this.userAgent }
     const state = { start: 0, end: 0, buffer: null }
@@ -332,6 +360,11 @@ module.exports = class Protocol {
 
     if (batch.length === 0) return
 
+    while (this._pendingCaps.length > 0) {
+      const [key, cap] = this._pendingCaps.pop()
+      hypercoreCapability(this.noiseStream.isInitiator, this.noiseStream.handshakeHash, key, cap)
+    }
+
     const state = { start: 0, end: 0, buffer: null }
     const lens = new Array(batch.length)
 
@@ -372,14 +405,24 @@ module.exports = class Protocol {
   }
 
   _announceCore (alias, key, discoveryKey) {
+    const cap = b4a.alloc(32)
+
+    if (!this.noiseStream.handshakeHash) {
+      this._pendingCaps.push([key, cap]) // encode it later...
+    } else {
+      hypercoreCapability(this.noiseStream.isInitiator, this.noiseStream.handshakeHash, key, cap)
+    }
+
     this.send(2, messages.core, -1, {
       alias: alias,
       discoveryKey: discoveryKey,
-      capability: b4a.alloc(32) // TODO
+      capability: cap
     })
   }
 
   _decode (buffer) {
+    if (buffer.byteLength === 0) return
+
     const state = { start: 0, end: buffer.length, buffer }
 
     if (this._firstMessage === true) {
@@ -453,7 +496,11 @@ module.exports = class Protocol {
     if (m.alias === this._remoteAliases.length) this._remoteAliases.push(null)
 
     if (peer) {
-      // TODO: check cap
+      const expectedCap = hypercoreCapability(!this.noiseStream.isInitiator, this.noiseStream.handshakeHash, peer.key)
+      if (!b4a.equals(expectedCap, m.capability)) {
+        this.destroy(new Error('Remote sent an invalid capability'))
+        return
+      }
 
       if (m.alias >= this._remoteAliases.length) {
         this.destroy(new Error('Remote alias out of bounds'))
@@ -508,6 +555,11 @@ module.exports = class Protocol {
     return this.noiseStream.write(state.buffer)
   }
 
+  ping () {
+    const empty = this.noiseStream.alloc(0)
+    this.noiseStream.write(empty)
+  }
+
   destroy (err) {
     return this.noiseStream.destroy(err)
   }
@@ -523,3 +575,9 @@ function noop () {}
 function isPromise (p) {
   return !!p && typeof p.then === 'function'
 }
+
+function hypercoreCapability (initiator, handshakeHash, key, cap = b4a.alloc(32)) {
+  const ns = initiator ? NS_HYPERCORE_INITIATOR : NS_HYPERCORE_RESPONDER
+  sodium.crypto_generichash_batch(cap, [handshakeHash, key], ns)
+  return cap
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "10.0.0-alpha.19",
+  "version": "10.0.0-alpha.22",
   "description": "Hypercore 10",
   "main": "index.js",
   "scripts": {