hypercore 11.34.0 → 11.35.0

package/index.js

@@ -23,7 +23,8 @@ const Download = require('./lib/download')
 const DefaultEncryption = require('./lib/default-encryption')
 const caps = require('./lib/caps')
 const Replicator = require('./lib/replicator')
-const { manifestHash, createManifest } = require('./lib/verifier')
+const Verifier = require('./lib/verifier')
+const { manifestHash, createManifest, encodeManifest } = Verifier
 const { ReadStream, WriteStream, ByteStream } = require('./lib/streams')
 const { MerkleTree } = require('./lib/merkle-tree')
 const { proof, verify } = require('./lib/fully-remote-proof')
@@ -35,7 +36,8 @@ const {
   SESSION_NOT_WRITABLE,
   SNAPSHOT_NOT_AVAILABLE,
   DECODING_ERROR,
-  REQUEST_CANCELLED
+  REQUEST_CANCELLED,
+  INVALID_CHECKSUM
 } = require('hypercore-errors')
 
 // Hypercore actually does not have any notion of max/min block sizes
@@ -130,11 +132,29 @@ class Hypercore extends EventEmitter {
 
   static key(manifest, { compat, version, namespace } = {}) {
     if (b4a.isBuffer(manifest)) {
-      manifest = { version, signers: [{ publicKey: manifest, namespace }] }
+      manifest =
+        manifest.byteLength === 32
+          ? { version, signers: [{ publicKey: manifest, namespace }] }
+          : this.parseManifest(manifest)
     }
     return compat ? manifest.signers[0].publicKey : manifestHash(createManifest(manifest))
   }
 
+  static parseManifest(manifest, key) {
+    const parsed = createManifest(manifest)
+    if (parsed === null) return null
+
+    if (parsed.quorum > parsed.signers.length) {
+      throw BAD_ARGUMENT('Quorum should not be higher than the number of signers')
+    }
+
+    if (key && !Verifier.isValidManifest(key, parsed)) {
+      throw INVALID_CHECKSUM('Manifest does not hash to provided key')
+    }
+
+    return parsed
+  }
+
   static discoveryKey(key) {
     return crypto.discoveryKey(key)
   }
@@ -453,7 +473,7 @@ class Hypercore extends EventEmitter {
     }
 
     if (opts.manifest && !this.core.header.manifest) {
-      await this.core.setManifest(createManifest(opts.manifest))
+      await this.core.setManifest(opts.manifest)
     }
 
     this.core.replicator.updateActivity(this._active ? 1 : 0)
@@ -606,6 +626,11 @@ class Hypercore extends EventEmitter {
     return this.core === null ? null : this.core.manifest
   }
 
+  getManifest({ raw = false } = {}) {
+    if (this.manifest === null) return null
+    return raw ? encodeManifest(this.manifest) : this.manifest
+  }
+
   get length() {
     if (this._snapshot) return this._snapshot.length
     return this.opened === false ? 0 : this.state.length

package/lib/core.js

@@ -259,15 +259,14 @@ module.exports = class Core {
     }
 
     if (opts.manifest) {
+      const manifest = Verifier.createManifest(opts.manifest)
+
       // if we provide a manifest and no key, verify that the stored key is the same
-      if (
-        !opts.key &&
-        !Verifier.isValidManifest(header.key, Verifier.createManifest(opts.manifest))
-      ) {
+      if (!opts.key && !Verifier.isValidManifest(header.key, manifest)) {
         throw STORAGE_CONFLICT('Manifest does not hash to provided key', this.discoveryKey)
       }
 
-      if (!header.manifest) header.manifest = opts.manifest
+      if (!header.manifest) header.manifest = manifest
     }
 
     if (opts.key && !b4a.equals(header.key, opts.key)) {
@@ -393,12 +392,14 @@ module.exports = class Core {
 
     try {
       if (manifest && this.header.manifest === null) {
+        manifest = Verifier.createManifest(manifest)
+
         if (!Verifier.isValidManifest(this.header.key, manifest)) {
           throw INVALID_CHECKSUM('Manifest hash does not match', this.discoveryKey)
         }
 
         const tx = this.state.createWriteBatch()
-        this._setManifest(tx, Verifier.createManifest(manifest), null)
+        this._setManifest(tx, manifest, null)
         await this.state.flush()
       }
     } finally {

package/lib/replicator.js

@@ -1749,6 +1749,17 @@ class Peer {
     return false
   }
 
+  _addLastRangeBatch(r, start, end) {
+    const { WANT_BATCH } = w
+
+    const next = this.core.bitfield.findLast(false, end - 1)
+    if (next === -1 || next < start) return false
+
+    const b = (next - (next & (WANT_BATCH - 1))) / WANT_BATCH
+
+    return r.addBatch(b)
+  }
+
   _populateRangeBatches(r) {
     const { WANT_BATCH } = w
     for (let i = r.batches.length - 1; i >= 0; i--) {
@@ -1764,10 +1775,13 @@ class Peer {
       r.removeBatch(b)
     }
 
-    while (r.batches.length < 3) {
-      const end = r.end === -1 ? this.core.state.length : r.end
-      if (end <= r.start) return
+    const end = r.end === -1 ? this.core.state.length : r.end
+    if (end <= r.start) return
 
+    // always keep the last batch in the range selected
+    if (r.batches.length < 3) this._addLastRangeBatch(r, r.start, end)
+
+    while (r.batches.length < 3) {
       const len = end - r.start
       const off = r.start + (r.linear ? 0 : Math.floor(Math.random() * len))
 

package/lib/verifier.js

@@ -214,6 +214,8 @@ module.exports = class Verifier {
   static createManifest(inp) {
     if (!inp) return null
 
+    if (b4a.isBuffer(inp)) return Verifier.decodeManifest(inp)
+
     if (inp.quorum && inp.quorum < 0) throw BAD_ARGUMENT('Quorum cannot be negative')
     if (inp.quorum && inp.signers && inp.quorum > inp.signers.length) {
       throw BAD_ARGUMENT('Quorum should not be higher than the number of signers')

package/package.json

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