hypercore 10.0.0-alpha.20 → 10.0.0-alpha.24

package/README.md

@@ -212,6 +212,12 @@ Buffer containing the public key identifying this core.
 
 Populated after `ready` has been emitted. Will be `null` before the event.
 
+#### `core.keyPair`
+
+Object containing buffers of the core's public and secret key
+
+Populated after `ready` has been emitted. Will be `null` before the event.
+
 #### `core.discoveryKey`
 
 Buffer containing a key derived from the core's public key.
@@ -274,6 +280,6 @@ socket.pipe(localCore.replicate(true)).pipe(socket)
 
 Emitted when the core has been appended to (i.e. has a new length / byteLength), either locally or remotely.
 
-#### `core.on('truncate')`
+#### `core.on('truncate', ancestors, forkId)`
 
 Emitted when the core has been truncated, either locally or remotely.

package/index.js

@@ -58,6 +58,7 @@ module.exports = class Hypercore extends EventEmitter {
     this.encodeBatch = null
 
     this.key = key || null
+    this.keyPair = null
     this.discoveryKey = null
     this.readable = true
     this.writable = false
@@ -107,7 +108,7 @@ module.exports = class Hypercore extends EventEmitter {
     if (!noiseStream) throw new Error('Invalid stream')
 
     if (!noiseStream.userData) {
-      const protocol = Replicator.createProtocol(noiseStream)
+      const protocol = Replicator.createProtocol(noiseStream, opts)
       if (opts.keepAlive !== false) protocol.setKeepAlive(true)
       noiseStream.userData = protocol
       noiseStream.on('error', noop) // All noise errors already propagate through outerStream
@@ -231,6 +232,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)
@@ -243,11 +246,13 @@ module.exports = class Hypercore extends EventEmitter {
     }
 
     this.replicator = new Replicator(this.core, {
-      onupdate: this._onpeerupdate.bind(this)
+      onupdate: this._onpeerupdate.bind(this),
+      onupload: this._onupload.bind(this)
     })
 
     this.discoveryKey = this.crypto.discoveryKey(this.core.header.signer.publicKey)
     this.key = this.core.header.signer.publicKey
+    this.keyPair = this.core.header.signer
 
     if (!this.encryption && opts.encryptionKey) {
       this.encryption = new BlockEncryption(opts.encryptionKey, this.key)
@@ -328,12 +333,20 @@ module.exports = class Hypercore extends EventEmitter {
     return this.opening
   }
 
+  _onupload (index, value, from) {
+    const byteLength = value.byteLength - this.padding
+
+    for (let i = 0; i < this.sessions.length; i++) {
+      this.sessions[i].emit('upload', index, byteLength, from)
+    }
+  }
+
   _oncoreupdate (status, bitfield, value, from) {
     if (status !== 0) {
       for (let i = 0; i < this.sessions.length; i++) {
         if ((status & 0b10) !== 0) {
           if (this.cache) this.cache.clear()
-          this.sessions[i].emit('truncate', this.core.tree.fork)
+          this.sessions[i].emit('truncate', bitfield.start, this.core.tree.fork)
         }
         if ((status & 0b01) !== 0) {
           this.sessions[i].emit('append')

package/lib/messages.js

@@ -256,16 +256,25 @@ exports.info = {
   preencode (state, i) {
     c.uint.preencode(state, i.length)
     c.uint.preencode(state, i.fork)
+    c.uint.preencode(state, 1) // flags
   },
   encode (state, i) {
     c.uint.encode(state, i.length)
     c.uint.encode(state, i.fork)
+    c.uint.encode(state, (i.uploading ? 1 : 0) | (i.downloading ? 2 : 0))
   },
   decode (state) {
-    return {
+    const i = {
       length: c.uint.decode(state),
-      fork: c.uint.decode(state)
+      fork: c.uint.decode(state),
+      uploading: true,
+      downloading: true
     }
+    if (state.end <= state.start) return i // backwards compat with prev alphas
+    const flags = c.uint.decode(state)
+    i.uploading = (flags & 1) !== 0
+    i.downloading = (flags & 2) !== 0
+    return i
   }
 }
 

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
@@ -126,11 +136,34 @@ class Peer {
     this.resend = false
     this.state = state
     this.extensions = new Map()
+    this.uploading = true
+    this.downloading = true
     this.destroyed = false
 
     this._destroyer = this._safeDestroy.bind(this)
   }
 
+  setUploading (uploading) {
+    if (uploading === this.uploading) return
+    this.uploading = uploading
+    this._sendInfo()
+  }
+
+  setDownloading (downloading) {
+    if (downloading === this.downloading) return
+    this.downloading = downloading
+    this._sendInfo()
+  }
+
+  _sendInfo () {
+    this.info({
+      length: this.handlers.core.tree.length,
+      fork: this.handlers.core.tree.fork,
+      uploading: this.uploading,
+      downloading: this.downloading
+    })
+  }
+
   onmessage (type, state) {
     const handlers = this.handlers
 
@@ -257,10 +290,14 @@ module.exports = class Protocol {
     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
@@ -346,6 +383,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)
 
@@ -386,10 +428,18 @@ 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
     })
   }
 
@@ -469,7 +519,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'))
@@ -544,3 +598,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/lib/replicator.js

@@ -14,6 +14,8 @@ class RemoteState {
     this.bitfield = new RemoteBitfield()
     this.length = 0
     this.fork = 0
+    this.uploading = true
+    this.downloading = true
   }
 }
 
@@ -241,6 +243,7 @@ class RequestPool {
 
   update (peer) {
     if (peer.state.inflight >= peer.state.maxInflight) return false
+    if (peer.downloading === false || peer.state.uploading === false) return false
     if (this.paused) return false
 
     if (peer.state.fork > this.core.tree.fork) {
@@ -624,17 +627,19 @@ class RequestPool {
 }
 
 module.exports = class Replicator {
-  constructor (core, { onupdate }) {
+  constructor (core, { onupdate, onupload }) {
     this.core = core
     this.peers = []
     this.requests = new RequestPool(this, core)
     this.updating = null
     this.pendingPeers = new Set()
     this.onupdate = onupdate
+    this.onupload = onupload
   }
 
-  static createProtocol (noiseStream) {
+  static createProtocol (noiseStream, opts) {
     return new Protocol(noiseStream, {
+      ...opts,
       protocolVersion: 0,
       userAgent: USER_AGENT
     })
@@ -658,8 +663,14 @@ module.exports = class Replicator {
   }
 
   broadcastInfo () {
-    const msg = { length: this.core.tree.length, fork: this.core.tree.fork }
-    for (const peer of this.peers) peer.info(msg)
+    for (const peer of this.peers) {
+      peer.info({
+        length: this.core.tree.length,
+        fork: this.core.tree.fork,
+        uploading: peer.uploading,
+        downloading: peer.downloading
+      })
+    }
     this.updateAll()
   }
 
@@ -737,7 +748,12 @@ module.exports = class Replicator {
     this.peers.push(peer)
     this.onupdate(true, peer)
 
-    peer.info({ length: this.core.tree.length, fork: this.core.tree.fork })
+    peer.info({
+      length: this.core.tree.length,
+      fork: this.core.tree.fork,
+      uploading: peer.uploading,
+      downloading: peer.downloading
+    })
 
     // YOLO send over all the pages for now
     const p = pages(this.core)
@@ -752,12 +768,14 @@ module.exports = class Replicator {
     // This is a no-op because there isn't any state to dealloc currently
   }
 
-  oninfo ({ length, fork }, peer) {
+  oninfo ({ length, fork, uploading, downloading }, peer) {
     const len = peer.state.length
     const forked = peer.state.fork !== fork
 
     peer.state.length = length
     peer.state.fork = fork
+    peer.state.downloading = downloading
+    peer.state.uploading = uploading
 
     if (forked) {
       for (let i = peer.state.length; i < len; i++) {
@@ -813,11 +831,13 @@ module.exports = class Replicator {
   async onrequest (req, peer) {
     const fork = req.fork || peer.state.fork
     if (fork !== this.core.tree.fork) return
+    if (!peer.uploading) return
 
     const proof = await this.core.tree.proof(req)
 
     if (req.block && req.block.value) {
       proof.block.value = await this.core.blocks.get(req.block.index)
+      this.onupload(req.block.index, proof.block.value, peer)
     }
 
     peer.data(proof)

package/package.json

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