hypercore 11.6.1 → 11.6.3

package/lib/replicator.js

@@ -705,9 +705,14 @@ class Peer {
     }
 
     const manifest = (msg.manifest && !this.core.compat) ? this.core.header.manifest : null
-    const proof = await MerkleTree.proof(this.core.state, batch, msg)
 
-    return new ProofRequest(msg, proof, block, manifest)
+    try {
+      const proof = await MerkleTree.proof(this.core.state, batch, msg)
+      return new ProofRequest(msg, proof, block, manifest)
+    } catch (err) {
+      batch.destroy()
+      throw err
+    }
   }
 
   async onrequest (msg) {
@@ -1340,6 +1345,8 @@ class Peer {
   }
 
   _requestForkProof (f) {
+    if (!this.remoteLength) return
+
     const req = this._makeRequest(false, 0, 0)
 
     req.upgrade = { start: 0, length: this.remoteLength }

package/lib/session-state.js

@@ -287,14 +287,16 @@ module.exports = class SessionState {
 
       if (dependency) this.storage.setDependencyHead(dependency)
 
-      const truncated = bitfield ? bitfield.truncated : -1
+      const b = bitfield
 
-      if (truncated !== -1 && truncated < currLength) {
-        this.ontruncate(tree, truncated, currLength, true)
-        if (!bitfield || bitfield.length === 0) return
+      if (b && b.truncated && b.start < currLength) {
+        this.ontruncate(tree, b.start, currLength, true)
+        if (!b || b.appends === 0) return
       }
 
-      this.onappend(tree, bitfield, true)
+      const append = b ? { start: b.start, length: b.appends, drop: false } : null
+
+      this.onappend(tree, append, true)
     } finally {
       this.mutex.unlock()
       this.core.checkIfIdle()
@@ -604,35 +606,36 @@ module.exports = class SessionState {
     const b = bitfield
 
     if (b.drop) {
-      if (p === null) {
-        this._pendingBitfield = { truncated: b.start, start: b.start, length: 0, drop: false }
-        return
+      // truncation must be from end
+      if (p && (b.start + b.length !== p.start + p.appends)) {
+        throw INVALID_OPERATION('Atomic truncations must be contiguous')
       }
 
-      if (p.drop || p.truncated !== -1) {
-        if (p.truncated !== b.start + b.length) throw INVALID_OPERATION('Atomic truncations must be contiguous')
-        p.truncated = b.start
+      // actual truncation
+      if (p === null || b.start < p.start) {
+        this._pendingBitfield = { truncated: true, start: b.start, appends: 0 }
         return
       }
 
-      if (b.start < p.start) throw INVALID_OPERATION('Atomic truncations must be contiguous')
-      p.length = b.start - p.start
+      // just clearing batch data
+      p.appends = b.start - p.start
+
+      // we cleared the current batch
+      if (p.appends === 0) this._pendingBitfield = null
 
-      if (p.length === 0) this._pendingBitfield = null
       return
     }
 
     if (p === null) {
-      this._pendingBitfield = { truncated: -1, start: b.start, length: b.length, drop: false }
+      this._pendingBitfield = { truncated: false, start: b.start, appends: b.length }
       return
     }
 
-    const start = p.truncated === -1 ? p.start : p.truncated
-    if (b.start !== start + p.length) {
+    if (b.start !== p.start + p.appends) {
       throw INVALID_OPERATION('Atomic operations must be contiguous')
     }
 
-    p.length += b.length
+    p.appends += b.length
   }
 
   async catchup (length) {

package/package.json

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