hypercore 11.23.1 → 11.24.0

package/index.js

@@ -318,6 +318,11 @@ class Hypercore extends EventEmitter {
       this.encodeBatch = opts.encodeBatch
     }
 
+    // one session sets for pushOnly for all
+    if (opts.pushOnly === true) {
+      this.core.replicator.setPushOnly(true)
+    }
+
     if (parent) {
       if (parent._stateIndex === -1) await parent.ready()
       if (!this.keyPair) this.keyPair = parent.keyPair
@@ -858,7 +863,8 @@ class Hypercore extends EventEmitter {
 
     const activeRequests = (opts && opts.activeRequests) || this.activeRequests
 
-    const req = this.core.replicator.addBlock(activeRequests, index)
+    const force = opts ? opts.force === true : false
+    const req = this.core.replicator.addBlock(activeRequests, index, force)
     req.snapshot = index < this.length
 
     const timeout = opts && opts.timeout !== undefined ? opts.timeout : this.timeout
@@ -980,6 +986,7 @@ class Hypercore extends EventEmitter {
   async treeHash(length = -1) {
     if (this.opened === false) await this.opening
     if (length === -1) length = this.length
+    if (length > 0 && !(await this.has(length - 1))) await this.get(length - 1)
 
     const roots = await MerkleTree.getRoots(this.state, length)
     return crypto.tree(roots)
@@ -1150,6 +1157,7 @@ function initOnce(session, storage, key, opts) {
     notDownloadingLinger: opts.notDownloadingLinger,
     allowFork: opts.allowFork !== false,
     allowPush: !!opts.allowPush,
+    pushOnly: !!opts.pushOnly,
     alwaysLatestBlock: !!opts.allowLatestBlock,
     inflightRange: opts.inflightRange,
     compat: opts.compat === true,

package/lib/replicator.js

@@ -197,7 +197,7 @@ class Attachable {
 }
 
 class BlockRequest extends Attachable {
-  constructor(replicator, tracker, index, priority) {
+  constructor(replicator, tracker, index, priority, force) {
     super(replicator)
 
     this.index = index
@@ -206,6 +206,7 @@ class BlockRequest extends Attachable {
     this.queued = false
     this.hotswap = null
     this.tracker = tracker
+    this.force = force
   }
 
   _unref() {
@@ -409,11 +410,11 @@ class BlockTracker {
     return this._map.get(index) || null
   }
 
-  add(index, priority) {
+  add(index, priority, force) {
     let b = this._map.get(index)
     if (b) return b
 
-    b = new BlockRequest(this._replicator, this, index, priority)
+    b = new BlockRequest(this._replicator, this, index, priority, force)
     this._map.set(index, b)
 
     return b
@@ -1452,6 +1453,8 @@ class Peer {
 
   _requestManifest() {
     const req = this._makeRequest(false, 0, 0)
+    if (req === null) return
+
     this._send(req)
   }
 
@@ -1465,15 +1468,17 @@ class Peer {
 
     // do the normal checks
     if (!this._remoteHasBlock(index)) return null
-    if (!this._canRequest(index)) return null
+    if (!this._canRequest(index, false)) return null
 
     // atm we only ever do one upgrade request in parallel, if that changes
     // then we should add some check here for inflights to avoid over requesting
-    const b = this.replicator._blocks.add(index, PRIORITY.NORMAL)
+    const b = this.replicator._blocks.add(index, PRIORITY.NORMAL, false)
     return b
   }
 
   _requestUpgrade(u) {
+    if (this.replicator.pushOnly) return false
+
     const req = this._makeRequest(true, 0, 0)
     if (req === null) return false
 
@@ -1488,6 +1493,7 @@ class Peer {
   _requestSeek(s) {
     // if replicator is updating the seeks etc, bail and wait for it to drain
     if (this.replicator._updatesPending > 0) return false
+    if (this.replicator.pushOnly) return false
 
     const { length, fork } = this.core.state
 
@@ -1518,14 +1524,14 @@ class Peer {
 
       if (this._remoteHasBlock(index) === false) continue
       if (this.core.bitfield.get(index) === true) continue
-      if (!this._canRequest(index)) continue
+      if (!this._canRequest(index, false)) continue
 
       // Check if this block is currently inflight - if so pick another
       const b = this.replicator._blocks.get(index)
       if (b !== null && b.inflight.length > 0) continue
 
       // Block is not inflight, but we only want the hash, check if that is inflight
-      const h = this.replicator._hashes.add(index, PRIORITY.NORMAL)
+      const h = this.replicator._hashes.add(index, PRIORITY.NORMAL, false)
       if (h.inflight.length > 0) continue
 
       const req = this._makeRequest(false, h.priority, index + 1)
@@ -1549,9 +1555,13 @@ class Peer {
     return false
   }
 
-  _canRequest(index) {
+  _canRequest(index, force) {
     if (!(index >= 0)) throw ASSERTION('bad index to _canRequest: ' + index)
 
+    if (!force && this.replicator.pushOnly) {
+      return false
+    }
+
     if (this.remoteLength >= this.core.state.length) {
       return true
     }
@@ -1588,7 +1598,7 @@ class Peer {
       return false
     }
 
-    if (!this._canRequest(b.index)) return false
+    if (!this._canRequest(b.index, b.force)) return false
 
     const req = this._makeRequest(b.index >= length, b.priority, b.index + 1)
     if (req === null) return false
@@ -1636,9 +1646,9 @@ class Peer {
   }
 
   _requestRangeBlock(index, length) {
-    if (this.core.bitfield.get(index) === true || !this._canRequest(index)) return false
+    if (this.core.bitfield.get(index) === true || !this._canRequest(index, false)) return false
 
-    const b = this.replicator._blocks.add(index, PRIORITY.NORMAL)
+    const b = this.replicator._blocks.add(index, PRIORITY.NORMAL, false)
     if (b.inflight.length > 0) {
       this.missingBlocks.set(index, false) // in case we missed some states just set them ondemand, nbd
       return false
@@ -1789,8 +1799,10 @@ class Peer {
 
   _requestForkProof(f) {
     if (!this.remoteLength) return
+    if (this.replicator.pushOnly) return
 
     const req = this._makeRequest(false, 0, 0)
+    if (req === null) return
 
     req.upgrade = { start: 0, length: this.remoteLength }
     req.manifest = !this.core.header.manifest
@@ -1801,6 +1813,7 @@ class Peer {
 
   _requestForkRange(f) {
     if (f.fork !== this.remoteFork || f.batch.want === null) return false
+    if (this.replicator.pushOnly) return false
 
     const end = Math.min(f.batch.want.end, this.remoteLength)
     if (end < f.batch.want.start) return false
@@ -1815,6 +1828,7 @@ class Peer {
       if (this._remoteHasBlock(index) === false) continue
 
       const req = this._makeRequest(false, 0, 0)
+      if (req === null) return false
 
       req.hash = { index: 2 * index, nodes: f.batch.want.nodes }
 
@@ -1901,6 +1915,7 @@ module.exports = class Replicator {
     this.findingPeers = 0 // updatable from the outside
     this.destroyed = false
     this.downloading = false
+    this.pushOnly = false
     this.activeSessions = 0
 
     this.hotswaps = new HotswapQueue()
@@ -1988,6 +2003,11 @@ module.exports = class Replicator {
     return this.downloading
   }
 
+  setPushOnly(pushOnly) {
+    if (pushOnly === this.pushOnly) return
+    this.pushOnly = pushOnly
+  }
+
   setDownloading(downloading) {
     const allowPush = this.isAllowingPush()
     const linger = this._notDownloadingLinger
@@ -2124,8 +2144,8 @@ module.exports = class Replicator {
     return ref
   }
 
-  addBlock(session, index) {
-    const b = this._blocks.add(index, PRIORITY.HIGH)
+  addBlock(session, index, force) {
+    const b = this._blocks.add(index, PRIORITY.HIGH, force)
     const ref = b.attach(session)
 
     this._queueBlock(b)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "11.23.1",
+  "version": "11.24.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {