hypercore 11.19.1 → 11.20.0

package/README.md

@@ -594,7 +594,13 @@ Populated after `ready` has been emitted. Will be `0` before the event.
 
 #### `core.contiguousLength`
 
-How many blocks are contiguously available starting from the first block of this core?
+How many blocks are contiguously available starting from the first block of this core.
+
+Populated after `ready` has been emitted. Will be `0` before the event.
+
+#### `core.remoteContiguousLength`
+
+How many blocks are contiguously available starting from the first block of this core on any known remote. This is only updated when a remote thinks it is fully contiguous such that they have all known blocks.
 
 Populated after `ready` has been emitted. Will be `0` before the event.
 
@@ -708,6 +714,10 @@ Emitted when a block is uploaded to a peer.
 
 Emitted when a block is downloaded from a peer.
 
+#### `core.on('remote-contiguous-length', length)`
+
+Emitted when the max known contiguous `length` from a remote, ie `core.remoteContiguousLength`, is updated. Note this is not emitted when core is truncated.
+
 #### `Hypercore.MAX_SUGGESTED_BLOCK_SIZE`
 
 The constant for max size (15MB) for blocks appended to Hypercore. This max ensures blocks are replicated smoothly.

package/index.js

@@ -564,6 +564,11 @@ class Hypercore extends EventEmitter {
     return this.state.byteLength - this.state.length * this.padding
   }
 
+  get remoteContiguousLength() {
+    if (this.opened === false) return 0
+    return Math.min(this.core.state.length, this.core.header.hints.remoteContiguousLength)
+  }
+
   get contiguousLength() {
     if (this.opened === false) return 0
     return Math.min(this.core.state.length, this.core.header.hints.contiguousLength)

package/lib/core.js

@@ -200,7 +200,8 @@ module.exports = class Core {
         },
         hints: {
           reorgs: [],
-          contiguousLength: 0
+          contiguousLength: 0,
+          remoteContiguousLength: 0
         }
       }
 
@@ -284,7 +285,7 @@ module.exports = class Core {
     if (header.hints.contiguousLength !== len) {
       header.hints.contiguousLength = len
       const tx = storage.write()
-      tx.setHints({ contiguousLength: len })
+      tx.setHints(header.hints)
       await tx.flush()
     }
 
@@ -718,6 +719,16 @@ module.exports = class Core {
     }
   }
 
+  async updateRemoteContiguousLength(length) {
+    this.header.hints.remoteContiguousLength = length
+    await this.state.flushHints()
+    if (this.header.hints.remoteContiguousLength !== length) return
+
+    for (let i = this.monitors.length - 1; i >= 0; i--) {
+      this.monitors[i].emit('remote-contiguous-length', length)
+    }
+  }
+
   onappend(tree, bitfield) {
     this.header.tree = tree
 
@@ -860,7 +871,8 @@ function parseHeader(info) {
     tree: info.head || getDefaultTree(),
     hints: {
       reorgs: [],
-      contiguousLength: info.hints ? info.hints.contiguousLength : 0
+      contiguousLength: info.hints ? info.hints.contiguousLength : 0,
+      remoteContiguousLength: info.hints ? info.hints.remoteContiguousLength : 0
     }
   }
 }

package/lib/replicator.js

@@ -514,19 +514,19 @@ class Peer {
     else this._clearLocalRange(start, length)
 
     const i = Math.floor(start / DEFAULT_SEGMENT_SIZE)
-    const contig = this.core.header.hints.contiguousLength === this.core.state.length
+    const fullyContig = this.core.header.hints.contiguousLength === this.core.state.length
 
     if (
       start + LAST_BLOCKS < this.core.state.length &&
       !this.remoteSegmentsWanted.has(i) &&
       !drop &&
-      !contig
+      !fullyContig
     ) {
       return
     }
 
     let force = false
-    if (contig && !drop) {
+    if (fullyContig && !drop) {
       start = 0
       length = this.core.state.length
 
@@ -1152,7 +1152,7 @@ class Peer {
     this._clearLocalRange(fixedStart, length)
   }
 
-  onrange({ drop, start, length }) {
+  async onrange({ drop, start, length }) {
     const has = drop === false
 
     if (drop === true && start < this._remoteContiguousLength) {
@@ -1160,7 +1160,15 @@ class Peer {
     }
 
     if (start === 0 && drop === false) {
-      if (length > this._remoteContiguousLength) this._remoteContiguousLength = length
+      if (length > this._remoteContiguousLength) {
+        this._remoteContiguousLength = length
+        if (
+          this.remoteFork === this.core.state.fork &&
+          length > this.core.header.hints.remoteContiguousLength
+        ) {
+          await this.core.updateRemoteContiguousLength(length)
+        }
+      }
     } else if (length === 1) {
       const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield
       this.remoteBitfield.set(start, has)

package/lib/session-state.js

@@ -473,13 +473,37 @@ module.exports = class SessionState {
     if (this.isDefault()) {
       await storeBitfieldRange(this.storage, storage, batch.ancestors, batch.treeLength, false)
       if (batch.ancestors < this.core.header.hints.contiguousLength) {
-        storage.setHints({ contiguousLength: batch.ancestors })
+        this.core.header.hints.remoteContiguousLength = Math.min(
+          batch.length,
+          this.core.header.hints.remoteContiguousLength
+        )
+        storage.setHints({
+          contiguousLength: batch.ancestors,
+          remoteContiguousLength: this.core.header.hints.remoteContiguousLength
+        })
       }
     }
 
     return { dependency, tree, roots: batch.roots }
   }
 
+  async flushHints() {
+    await this.mutex.lock()
+
+    try {
+      const tx = this.createWriteBatch()
+
+      tx.setHints({
+        contiguousLength: this.core.header.hints.contiguousLength,
+        remoteContiguousLength: this.core.header.hints.remoteContiguousLength
+      })
+
+      await tx.flush()
+    } finally {
+      this._unlock()
+    }
+  }
+
   async clear(start, end, cleared) {
     await this.mutex.lock()
 
@@ -505,7 +529,10 @@ module.exports = class SessionState {
       if (this.isDefault()) {
         await storeBitfieldRange(this.storage, tx, start, end, false)
         if (start < this.core.header.hints.contiguousLength) {
-          tx.setHints({ contiguousLength: start })
+          tx.setHints({
+            contiguousLength: start,
+            remoteContiguousLength: this.core.header.hints.remoteContiguousLength
+          })
         }
       }
 
@@ -577,7 +604,10 @@ module.exports = class SessionState {
       if (this.isDefault()) {
         await storeBitfieldRange(this.storage, tx, batch.ancestors, batch.length, true)
         if (this.length === this.core.header.hints.contiguousLength) {
-          tx.setHints({ contiguousLength: this.length + values.length })
+          tx.setHints({
+            contiguousLength: this.length + values.length,
+            remoteContiguousLength: this.core.header.hints.remoteContiguousLength
+          })
         }
       }
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "hypercore",
-  "version": "11.19.1",
+  "version": "11.20.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {
     "format": "prettier --write .",
-    "lint": "prettier --check .",
+    "lint": "prettier --check . && lunte",
     "test": "brittle test/all.js",
     "test:bare": "bare test/all.js",
     "test:generate": "brittle -r test/all.js test/*.js"
@@ -70,7 +70,7 @@
     "brittle": "^3.0.0",
     "debugging-stream": "^3.1.0",
     "hyperswarm": "^4.3.6",
-    "lunte": "^1.2.0",
+    "lunte": "^1.3.0",
     "prettier": "^3.6.2",
     "prettier-config-holepunch": "^2.0.0",
     "rache": "^1.0.0",