hypercore 11.13.3 → 11.13.4

package/index.js

@@ -178,7 +178,7 @@ class Hypercore extends EventEmitter {
       noiseStream = new NoiseSecretStream(isInitiator, null, opts)
       outerStream = noiseStream.rawStream
     }
-    if (!noiseStream) throw BAD_ARGUMENT('Invalid stream')
+    if (!noiseStream) throw BAD_ARGUMENT('Invalid stream', this.discoveryKey)
 
     if (!noiseStream.userData) {
       const protocol = Protomux.from(noiseStream)
@@ -211,10 +211,10 @@ class Hypercore extends EventEmitter {
     if (this.closing) {
       // This makes the closing logic a lot easier. If this turns out to be a problem
       // in practice, open an issue and we'll try to make a solution for it.
-      throw SESSION_CLOSED('Cannot make sessions on a closing core')
+      throw SESSION_CLOSED('Cannot make sessions on a closing core', this.discoveryKey)
     }
     if (opts.checkout !== undefined && !opts.name && !opts.atom) {
-      throw ASSERTION('Checkouts are only supported on atoms or named sessions')
+      throw ASSERTION('Checkouts are only supported on atoms or named sessions', this.discoveryKey)
     }
 
     const wait = opts.wait === false ? false : this.wait
@@ -253,7 +253,7 @@ class Hypercore extends EventEmitter {
     }
 
     if (!isEncryptionProvider(encryption)) {
-      throw ASSERTION('Provider does not satisfy HypercoreEncryption interface')
+      throw ASSERTION('Provider does not satisfy HypercoreEncryption interface', this.discoveryKey)
     }
 
     this.encryption = encryption
@@ -383,10 +383,10 @@ class Hypercore extends EventEmitter {
     }
 
     if (this.state && checkout !== -1) {
-      if (!opts.name && !opts.atom) throw ASSERTION('Checkouts must be named or atomized')
-      if (checkout > this.state.length) throw ASSERTION('Invalid checkout ' + checkout + ' for ' + opts.name + ', length is ' + this.state.length)
+      if (!opts.name && !opts.atom) throw ASSERTION('Checkouts must be named or atomized', this.discoveryKey)
+      if (checkout > this.state.length) throw ASSERTION('Invalid checkout ' + checkout + ' for ' + opts.name + ', length is ' + this.state.length, this.discoveryKey)
       if (this.state.prologue && checkout < this.state.prologue.length) {
-        throw ASSERTION('Invalid checkout ' + checkout + ' for ' + opts.name + ', prologue length is ' + this.state.prologue.length)
+        throw ASSERTION('Invalid checkout ' + checkout + ' for ' + opts.name + ', prologue length is ' + this.state.prologue.length, this.discoveryKey)
       }
       if (checkout < this.state.length) await this.state.truncate(checkout, this.fork)
     }
@@ -697,7 +697,7 @@ class Hypercore extends EventEmitter {
 
   async seek (bytes, opts) {
     if (this.opened === false) await this.opening
-    if (!isValidIndex(bytes)) throw ASSERTION('seek is invalid')
+    if (!isValidIndex(bytes)) throw ASSERTION('seek is invalid', this.discoveryKey)
 
     const activeRequests = (opts && opts.activeRequests) || this.activeRequests
 
@@ -716,7 +716,7 @@ class Hypercore extends EventEmitter {
     const offset = await s.update()
     if (offset) return offset
 
-    if (this.closing !== null) throw SESSION_CLOSED()
+    if (this.closing !== null) throw SESSION_CLOSED('cannot seek on a closed session', this.discoveryKey)
 
     if (!this._shouldWait(opts, this.wait)) return null
 
@@ -735,7 +735,7 @@ class Hypercore extends EventEmitter {
 
   async has (start, end = start + 1) {
     if (this.opened === false) await this.opening
-    if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION('has range is invalid')
+    if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION('has range is invalid', this.discoveryKey)
 
     if (this.state.isDefault()) {
       if (end === start + 1) return this.core.bitfield.get(start)
@@ -765,9 +765,9 @@ class Hypercore extends EventEmitter {
 
   async get (index, opts) {
     if (this.opened === false) await this.opening
-    if (!isValidIndex(index)) throw ASSERTION('block index is invalid')
+    if (!isValidIndex(index)) throw ASSERTION('block index is invalid', this.discoveryKey)
 
-    if (this.closing !== null) throw SESSION_CLOSED()
+    if (this.closing !== null) throw SESSION_CLOSED('cannot get on a closed session', this.discoveryKey)
 
     const encoding = (opts && opts.valueEncoding && c.from(opts.valueEncoding)) || this.valueEncoding
 
@@ -792,14 +792,14 @@ class Hypercore extends EventEmitter {
 
   async clear (start, end = start + 1, opts) {
     if (this.opened === false) await this.opening
-    if (this.closing !== null) throw SESSION_CLOSED()
+    if (this.closing !== null) throw SESSION_CLOSED('cannot clear on a closed session', this.discoveryKey)
 
     if (typeof end === 'object') {
       opts = end
       end = start + 1
     }
 
-    if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION('clear range is invalid')
+    if (!isValidIndex(start) || !isValidIndex(end)) throw ASSERTION('clear range is invalid', this.discoveryKey)
 
     const cleared = (opts && opts.diff) ? { blocks: 0 } : null
 
@@ -821,7 +821,7 @@ class Hypercore extends EventEmitter {
 
     if (block !== null) return block
 
-    if (this.closing !== null) throw SESSION_CLOSED()
+    if (this.closing !== null) throw SESSION_CLOSED('cannot get on a closed session', this.discoveryKey)
 
     // snapshot should check if core has block
     if (this._snapshot !== null) {
@@ -911,7 +911,7 @@ class Hypercore extends EventEmitter {
 
     const isDefault = this.state === this.core.state
     const writable = !this._readonly && !!(signature || (keyPair && keyPair.secretKey))
-    if (isDefault && writable === false && (newLength > 0 || fork !== this.state.fork)) throw SESSION_NOT_WRITABLE()
+    if (isDefault && writable === false && (newLength > 0 || fork !== this.state.fork)) throw SESSION_NOT_WRITABLE('cannot append to a non-writable core', this.discoveryKey)
 
     await this.state.truncate(newLength, fork, { keyPair, signature })
 
@@ -928,7 +928,7 @@ class Hypercore extends EventEmitter {
     const { keyPair = defaultKeyPair, signature = null, maxLength } = opts
     const writable = !isDefault || !!signature || !!(keyPair && keyPair.secretKey) || opts.writable === true
 
-    if (this._readonly || writable === false) throw SESSION_NOT_WRITABLE()
+    if (this._readonly || writable === false) throw SESSION_NOT_WRITABLE('cannot append to a readonly core', this.discoveryKey)
 
     blocks = Array.isArray(blocks) ? blocks : [blocks]
 
@@ -943,7 +943,7 @@ class Hypercore extends EventEmitter {
     }
     for (const b of buffers) {
       if (b.byteLength > MAX_SUGGESTED_BLOCK_SIZE) {
-        throw BAD_ARGUMENT('Appended block exceeds the maximum suggested block size')
+        throw BAD_ARGUMENT('Appended block exceeds the maximum suggested block size', this.discoveryKey)
       }
     }
 
@@ -1055,8 +1055,8 @@ class Hypercore extends EventEmitter {
     if (this.encryption) block = block.subarray(this.encryption.padding(this.core, index))
     try {
       if (enc) return c.decode(enc, block)
-    } catch {
-      throw DECODING_ERROR()
+    } catch (err) {
+      throw DECODING_ERROR(err.message, this.discoveryKey)
     }
     return block
   }
@@ -1097,7 +1097,7 @@ function maybeUnslab (block) {
 }
 
 function checkSnapshot (snapshot, index) {
-  if (index >= snapshot.state.snapshotCompatLength) throw SNAPSHOT_NOT_AVAILABLE()
+  if (index >= snapshot.state.snapshotCompatLength) throw SNAPSHOT_NOT_AVAILABLE(`snapshot at index ${index} not available (max compat length ${snapshot.state.snapshotCompatLength})`, snapshot.discoveryKey)
 }
 
 function readBlock (rx, index) {

package/lib/core.js

@@ -146,17 +146,17 @@ module.exports = class Core {
     }
 
     if (!header && (opts.discoveryKey && !(opts.key || opts.manifest))) {
-      throw STORAGE_EMPTY('No Hypercore is stored here')
+      throw STORAGE_EMPTY('No Hypercore is stored here', this.discoveryKey)
     }
 
     if (!header || overwrite) {
       if (!createIfMissing) {
-        throw STORAGE_EMPTY('No Hypercore is stored here')
+        throw STORAGE_EMPTY('No Hypercore is stored here', this.discoveryKey)
       }
 
       if (compat) {
         if (opts.key && opts.keyPair && !b4a.equals(opts.key, opts.keyPair.publicKey)) {
-          throw BAD_ARGUMENT('Key must match publicKey when in compat mode')
+          throw BAD_ARGUMENT('Key must match publicKey when in compat mode', this.discoveryKey)
         }
       }
 
@@ -216,14 +216,14 @@ module.exports = class Core {
     if (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))) {
-        throw STORAGE_CONFLICT('Manifest does not hash to provided key')
+        throw STORAGE_CONFLICT('Manifest does not hash to provided key', this.discoveryKey)
       }
 
       if (!header.manifest) header.manifest = opts.manifest
     }
 
     if (opts.key && !b4a.equals(header.key, opts.key)) {
-      throw STORAGE_CONFLICT('Another Hypercore is stored here')
+      throw STORAGE_CONFLICT('Another Hypercore is stored here', this.discoveryKey)
     }
 
     // if we signalled compat, but already now this core isn't disable it
@@ -298,7 +298,7 @@ module.exports = class Core {
 
     try {
       if (manifest && this.header.manifest === null) {
-        if (!Verifier.isValidManifest(this.header.key, manifest)) throw INVALID_CHECKSUM('Manifest hash does not match')
+        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)
@@ -385,13 +385,13 @@ module.exports = class Core {
       if (!manifest) manifest = Verifier.defaultSignerManifest(this.header.key)
 
       if (!manifest || !(Verifier.isValidManifest(this.header.key, manifest) || Verifier.isCompat(this.header.key, manifest))) {
-        throw INVALID_SIGNATURE('Proof contains an invalid manifest') // TODO: proper error type
+        throw INVALID_SIGNATURE('Proof contains an invalid manifest', this.discoveryKey) // TODO: proper error type
       }
     }
 
     const verifier = this.verifier || new Verifier(this.header.key, Verifier.createManifest(manifest), { legacy: this._legacy })
     if (!verifier.verify(batch, batch.signature)) {
-      throw INVALID_SIGNATURE('Proof contains an invalid signature')
+      throw INVALID_SIGNATURE('Proof contains an invalid signature', this.discoveryKey)
     }
 
     return manifest
@@ -451,7 +451,7 @@ module.exports = class Core {
 
         // if we got a manifest AND its strictly a non compat one, lets store it
         if (manifest && this.header.manifest === null) {
-          if (!Verifier.isValidManifest(this.header.key, manifest)) throw INVALID_CHECKSUM('Manifest hash does not match')
+          if (!Verifier.isValidManifest(this.header.key, manifest)) throw INVALID_CHECKSUM('Manifest hash does not match', this.discoveryKey)
           this._setManifest(tx, manifest, null)
         }
 

package/lib/replicator.js

@@ -1325,6 +1325,8 @@ class Peer {
   }
 
   _requestRange (r) {
+    if (this.syncsProcessing > 0) return false
+
     const { length, fork } = this.core.state
 
     if (r.blocks) {
@@ -1343,31 +1345,39 @@ class Peer {
       return false
     }
 
-    const end = Math.min(this.core.state.length, Math.min(r.end === -1 ? this.remoteLength : r.end, this.remoteLength))
+    // if we can upgrade the remote, or the remote is ahead, then all the remotes blocks are valid
+    // otherwise truncate to the last length the remote has acked for us
+    const maxLocalLength = this.canUpgrade || this.remoteLength >= this.core.state.length
+      ? this.core.state.length
+      : fork === this.lastUpgradableFork ? Math.min(this.lastUpgradableLength, this.core.state.length) : 0
+
+    const end = Math.min(maxLocalLength, Math.min(r.end === -1 ? this.remoteLength : r.end, this.remoteLength))
     if (end <= r.start || fork !== this.remoteFork) return false
 
     const len = end - r.start
     const off = r.start + (r.linear ? 0 : Math.floor(Math.random() * len))
 
     let i = off
+    // should be way less than this, but this is worst case upper bound for the skiplist
+    let tries = this.inflight
 
-    while (true) {
+    do {
       i = this._findNext(i)
       if (i === -1 || i >= end) break
 
       if (this._requestRangeBlock(i, length)) return true
       i++
-    }
+    } while (tries-- > 0)
 
     i = r.start
 
-    while (true) {
+    do {
       i = this._findNext(i)
       if (i === -1 || i >= off) break
 
       if (this._requestRangeBlock(i, length)) return true
       i++
-    }
+    } while (tries-- > 0)
 
     this._maybeWant(r.start, len)
     return false

package/lib/session-state.js

@@ -373,10 +373,10 @@ module.exports = class SessionState {
 
     try {
       if (this.prologue && length < this.prologue.length) {
-        throw INVALID_OPERATION('Truncation breaks prologue')
+        throw INVALID_OPERATION('Truncation breaks prologue', this.core.discoveryKey)
       }
       if (length > this.length) {
-        throw INVALID_OPERATION('Not a truncation, ' + length + ' must be less or equal to ' + this.length)
+        throw INVALID_OPERATION('Not a truncation, ' + length + ' must be less or equal to ' + this.length, this.core.discoveryKey)
       }
 
       const batch = this.createTreeBatch()
@@ -531,7 +531,7 @@ module.exports = class SessionState {
 
       // only multisig can have prologue so signature is always present
       if (this.prologue && batch.length < this.prologue.length) {
-        throw INVALID_OPERATION('Append is not consistent with prologue')
+        throw INVALID_OPERATION('Append is not consistent with prologue', this.core.discoveryKey)
       }
 
       if (!signature && keyPair) signature = this.core.verifier.sign(batch, keyPair)
@@ -618,7 +618,7 @@ module.exports = class SessionState {
     if (b.drop) {
       // truncation must be from end
       if (p && (b.start + b.length !== p.start + p.appends)) {
-        throw INVALID_OPERATION('Atomic truncations must be contiguous')
+        throw INVALID_OPERATION('Atomic truncations must be contiguous', this.core.discoveryKey)
       }
 
       // actual truncation
@@ -642,7 +642,7 @@ module.exports = class SessionState {
     }
 
     if (b.start !== p.start + p.appends) {
-      throw INVALID_OPERATION('Atomic operations must be contiguous')
+      throw INVALID_OPERATION('Atomic operations must be contiguous', this.core.discoveryKey)
     }
 
     p.appends += b.length
@@ -679,7 +679,7 @@ module.exports = class SessionState {
       const truncating = sharedLength < origLength
 
       for (const node of roots) {
-        if (node === null) throw INVALID_OPERATION('Invalid catchup length, tree nodes not available')
+        if (node === null) throw INVALID_OPERATION('Invalid catchup length, tree nodes not available', this.core.discoveryKey)
       }
 
       const fork = truncating ? this.fork + 1 : this.fork
@@ -755,7 +755,7 @@ module.exports = class SessionState {
       batch.length = length
 
       if (!this.core.verifier.verify(batch, signature)) {
-        throw INVALID_SIGNATURE('Signature is not valid over committed tree')
+        throw INVALID_SIGNATURE('Signature is not valid over committed tree', this.core.discoveryKey)
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "11.13.3",
+  "version": "11.13.4",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {
@@ -50,7 +50,7 @@
     "fast-fifo": "^1.3.0",
     "flat-tree": "^1.9.0",
     "hypercore-crypto": "^3.2.1",
-    "hypercore-errors": "^1.2.0",
+    "hypercore-errors": "^1.5.0",
     "hypercore-id-encoding": "^1.2.0",
     "hypercore-storage": "^1.0.0",
     "is-options": "^1.0.1",