hypercore 11.18.3 → 11.19.0

package/index.js

@@ -104,8 +104,9 @@ class Hypercore extends EventEmitter {
   static DefaultEncryption = DefaultEncryption
 
   static key(manifest, { compat, version, namespace } = {}) {
-    if (b4a.isBuffer(manifest))
+    if (b4a.isBuffer(manifest)) {
       manifest = { version, signers: [{ publicKey: manifest, namespace }] }
+    }
     return compat ? manifest.signers[0].publicKey : manifestHash(createManifest(manifest))
   }
 
@@ -353,13 +354,15 @@ class Hypercore extends EventEmitter {
     }
 
     if (this.state && checkout !== -1) {
-      if (!opts.name && !opts.atom)
+      if (!opts.name && !opts.atom) {
         throw ASSERTION('Checkouts must be named or atomized', this.discoveryKey)
-      if (checkout > this.state.length)
+      }
+      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}`,
@@ -704,8 +707,9 @@ class Hypercore extends EventEmitter {
     const offset = await s.update()
     if (offset) return offset
 
-    if (this.closing !== null)
+    if (this.closing !== null) {
       throw SESSION_CLOSED('cannot seek on a closed session', this.discoveryKey)
+    }
 
     if (!this._shouldWait(opts, this.wait)) return null
 
@@ -724,8 +728,9 @@ class Hypercore extends EventEmitter {
 
   async has(start, end = start + 1) {
     if (this.opened === false) await this.opening
-    if (!isValidIndex(start) || !isValidIndex(end))
+    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)
@@ -757,8 +762,9 @@ class Hypercore extends EventEmitter {
     if (this.opened === false) await this.opening
     if (!isValidIndex(index)) throw ASSERTION('block index is invalid', this.discoveryKey)
 
-    if (this.closing !== null)
+    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
@@ -784,16 +790,18 @@ class Hypercore extends EventEmitter {
 
   async clear(start, end = start + 1, opts) {
     if (this.opened === false) await this.opening
-    if (this.closing !== null)
+    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))
+    if (!isValidIndex(start) || !isValidIndex(end)) {
       throw ASSERTION('clear range is invalid', this.discoveryKey)
+    }
 
     const cleared = opts && opts.diff ? { blocks: 0 } : null
 
@@ -815,8 +823,9 @@ class Hypercore extends EventEmitter {
 
     if (block !== null) return block
 
-    if (this.closing !== null)
+    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) {
@@ -906,8 +915,9 @@ 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))
+    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 })
 
@@ -925,8 +935,9 @@ class Hypercore extends EventEmitter {
     const writable =
       !isDefault || !!signature || !!(keyPair && keyPair.secretKey) || opts.writable === true
 
-    if (this._readonly || writable === false)
+    if (this._readonly || writable === false) {
       throw SESSION_NOT_WRITABLE('cannot append to a readonly core', this.discoveryKey)
+    }
 
     blocks = Array.isArray(blocks) ? blocks : [blocks]
 
@@ -1108,11 +1119,12 @@ function maybeUnslab(block) {
 }
 
 function checkSnapshot(snapshot, index) {
-  if (index >= snapshot.state.snapshotCompatLength)
+  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/bitfield.js

@@ -350,7 +350,7 @@ module.exports = class Bitfield {
         p = this._pages.set(i, new BitfieldPage(i, s))
       }
 
-      const offset = p.index * BITS_PER_PAGE
+      const offset = i * BITS_PER_PAGE
       const last = Math.min(end - offset, BITS_PER_PAGE)
       const range = last - j
 

package/lib/core.js

@@ -140,7 +140,7 @@ module.exports = class Core {
   async _tryOpen(opts) {
     if (opts.preopen) await opts.preopen // just a hook to allow exclusive access here...
 
-    let storage = await this.db.resume(this.discoveryKey)
+    let storage = await this.db.resumeCore(this.discoveryKey)
 
     let overwrite = opts.overwrite === true
 
@@ -203,7 +203,7 @@ module.exports = class Core {
 
       const discoveryKey = opts.discoveryKey || crypto.discoveryKey(header.key)
 
-      storage = await this.db.create({
+      storage = await this.db.createCore({
         key: header.key,
         manifest,
         keyPair,
@@ -330,8 +330,9 @@ module.exports = class Core {
 
     try {
       if (manifest && this.header.manifest === null) {
-        if (!Verifier.isValidManifest(this.header.key, 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)
@@ -343,8 +344,9 @@ module.exports = class Core {
   }
 
   _setManifest(tx, manifest, keyPair) {
-    if (!manifest && b4a.equals(keyPair.publicKey, this.header.key))
+    if (!manifest && b4a.equals(keyPair.publicKey, this.header.key)) {
       manifest = Verifier.defaultSignerManifest(this.header.key)
+    }
     if (!manifest) return
 
     const verifier = new Verifier(this.header.key, manifest, { legacy: this._legacy })
@@ -499,8 +501,9 @@ 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))
+          if (!Verifier.isValidManifest(this.header.key, manifest)) {
             throw INVALID_CHECKSUM('Manifest hash does not match', this.discoveryKey)
+          }
           this._setManifest(tx, manifest, null)
         }
 

package/lib/default-encryption.js

@@ -25,9 +25,11 @@ module.exports = class DefaultEncryption {
     const blindingKey = subKeys.subarray(sodium.crypto_stream_KEYBYTES)
 
     if (!block) {
-      if (compat) sodium.crypto_generichash_batch(blockKey, [encryptionKey], hypercoreKey)
-      else
+      if (compat) {
+        sodium.crypto_generichash_batch(blockKey, [encryptionKey], hypercoreKey)
+      } else {
         sodium.crypto_generichash_batch(blockKey, [DEFAULT_ENCRYPTION, hypercoreKey, encryptionKey])
+      }
     }
 
     sodium.crypto_generichash(blindingKey, blockKey)

package/lib/fully-remote-proof.js

@@ -39,7 +39,7 @@ async function verify(storage, buffer, { referrer = null } = {}) {
     block: null
   }
 
-  const core = await storage.resume(discoveryKey)
+  const core = await storage.resumeCore(discoveryKey)
   if (core === null) return null
 
   let rx = core.read()

package/lib/merkle-tree.js

@@ -231,8 +231,9 @@ class MerkleTreeBatch {
 
   commit(tx) {
     if (tx === undefined) throw INVALID_OPERATION('No database batch was passed')
-    if (!this.commitable())
+    if (!this.commitable()) {
       throw INVALID_OPERATION('Tree was modified during batch, refusing to commit')
+    }
 
     if (this.upgraded) this._commitUpgrade(tx)
 
@@ -696,8 +697,9 @@ class MerkleTree {
     // TODO: we could prop use a read batch here and do this in blocks of X for perf
     while (!ite.contains(head) && !(await hasTreeNode(session.storage, ite.index))) {
       cnt++
-      if (cnt >= 1024)
+      if (cnt >= 1024) {
         throw ASSERTION('Bad arguments to missingNodes index=' + index + ' at length=' + length)
+      }
       ite.parent()
     }
 
@@ -1023,8 +1025,9 @@ function blockAndSeekProof(session, rx, node, seek, seekRoot, root, p) {
   if (!node.value) p.node.push(getTreeNodeOrError(rx, ite.index))
 
   while (ite.index !== root) {
-    if (++cnt >= 1024)
+    if (++cnt >= 1024) {
       throw ASSERTION('Bad blockAndSeekProof seekRoot=' + seekRoot + ', root=' + root)
+    }
     ite.sibling()
 
     if (seek && ite.contains(seekRoot) && ite.index !== seekRoot) {
@@ -1105,10 +1108,11 @@ function additionalUpgradeProof(session, rx, from, to, p) {
       ite.seek(target)
 
       while (ite.index !== root) {
-        if (++cnt >= 1024)
+        if (++cnt >= 1024) {
           throw ASSERTION(
             'Bad arguments to additionalUpgradeProof root=' + root + ' target=' + target
           )
+        }
         ite.sibling()
         if (ite.index > target) {
           p.additionalUpgrade.push(getTreeNodeOrError(rx, ite.index))
@@ -1171,22 +1175,30 @@ function log2(n) {
 }
 
 function normalizeIndexed(block, hash) {
-  if (block)
-    return { value: true, index: block.index * 2, nodes: block.nodes, lastIndex: block.index }
-  if (hash)
+  if (block) {
+    return {
+      value: true,
+      index: block.index * 2,
+      nodes: block.nodes,
+      lastIndex: block.index
+    }
+  }
+  if (hash) {
     return {
       value: false,
       index: hash.index,
       nodes: hash.nodes,
       lastIndex: flat.rightSpan(hash.index) / 2
     }
+  }
   return null
 }
 
 async function getTreeNodeOrError(rx, index) {
   const node = await rx.getTreeNode(index)
-  if (node === null)
+  if (node === null) {
     throw INVALID_OPERATION('Expected tree node ' + index + ' from storage, got (nil)')
+  }
   return node
 }
 

package/lib/multisig.js

@@ -31,8 +31,9 @@ async function partialSignature(
   if (from > core.state.length) return null
   const nodes = to <= from ? null : await upgradeNodes(core, from, to)
 
-  if (signature.byteLength !== 64)
+  if (signature.byteLength !== 64) {
     signature = c.decode(multiSignature, signature).proofs[0].signature
+  }
 
   return {
     signer,

package/lib/mutex.js

@@ -14,8 +14,9 @@ module.exports = class Mutex {
   }
 
   lock() {
-    if (this.destroyed)
+    if (this.destroyed) {
       return Promise.reject(this._destroyError || new Error('Mutex has been destroyed'))
+    }
     if (this.locked) return new Promise(this._enqueue)
     this.locked = true
     return Promise.resolve()
@@ -30,8 +31,9 @@ module.exports = class Mutex {
   }
 
   destroy(err) {
-    if (!this._destroying)
+    if (!this._destroying) {
       this._destroying = this.locked ? this.lock().catch(() => {}) : Promise.resolve()
+    }
 
     this.destroyed = true
     if (err) this._destroyError = err

package/lib/replicator.js

@@ -496,8 +496,9 @@ class Peer {
   }
 
   signalUpgrade() {
-    if (this.fullyDownloadedSignaled && !this.replicator.fullyDownloaded())
+    if (this.fullyDownloadedSignaled && !this.replicator.fullyDownloaded()) {
       this.fullyDownloadedSignaled = false
+    }
     if (this._shouldUpdateCanUpgrade() === true) this._updateCanUpgradeAndSync()
     else this.sendSync()
   }
@@ -520,8 +521,9 @@ class Peer {
       !this.remoteSegmentsWanted.has(i) &&
       !drop &&
       !contig
-    )
+    ) {
       return
+    }
 
     let force = false
     if (contig && !drop) {
@@ -566,8 +568,9 @@ class Peer {
     const name = message.name || this.lastExtensionRecv
     this.lastExtensionRecv = name
     const ext = this.extensions.get(name)
-    if (ext)
+    if (ext) {
       ext._onmessage({ start: 0, end: message.message.byteLength, buffer: message.message }, this)
+    }
   }
 
   sendSync() {
@@ -1319,10 +1322,19 @@ class Peer {
 
   _canRequest(index) {
     if (!(index >= 0)) throw ASSERTION('bad index to _canRequest: ' + index)
-    if (this.remoteLength >= this.core.state.length) return true
-    if (index < this.lastUpgradableLength && this.lastUpgradableFork === this.core.state.fork)
+
+    if (this.remoteLength >= this.core.state.length) {
       return true
-    if (this.canUpgrade && this.syncsProcessing === 0) return true
+    }
+
+    if (index < this.lastUpgradableLength && this.lastUpgradableFork === this.core.state.fork) {
+      return true
+    }
+
+    if (this.canUpgrade && this.syncsProcessing === 0) {
+      return true
+    }
+
     return false
   }
 
@@ -1888,13 +1900,16 @@ module.exports = class Replicator {
 
       if (this.core.state.length === 0 && peer.remoteLength > 0) return
 
-      if (peer.remoteLength <= this._upgrade.length || peer.remoteFork !== this._upgrade.fork)
+      if (peer.remoteLength <= this._upgrade.length || peer.remoteFork !== this._upgrade.fork) {
         continue
+      }
 
       if (peer.syncsProcessing > 0) return
 
-      if (peer.lengthAcked !== this.core.state.length && peer.remoteFork === this.core.state.fork)
+      if (peer.lengthAcked !== this.core.state.length && peer.remoteFork === this.core.state.fork) {
         return
+      }
+
       if (peer.remoteCanUpgrade === true) return
     }
 
@@ -2080,8 +2095,9 @@ module.exports = class Replicator {
     if (
       this.core.state.length === this._upgrade.length &&
       this.core.state.fork === this._upgrade.fork
-    )
+    ) {
       return false
+    }
 
     const u = this._upgrade
     this._upgrade = null
@@ -2285,8 +2301,9 @@ module.exports = class Replicator {
   }
 
   _unmarkInflight(index) {
-    if (this.core.skipBitfield !== null)
+    if (this.core.skipBitfield !== null) {
       this.core.skipBitfield.set(index, this.core.bitfield.get(index))
+    }
     for (const peer of this.peers) peer._resetMissingBlock(index)
   }
 
@@ -2322,8 +2339,10 @@ module.exports = class Replicator {
       this._manifestPeer = null
     }
 
-    if (this._seeks.length > 0 || this._ranges.length > 0)
+    if (this._seeks.length > 0 || this._ranges.length > 0) {
       this._updateNonPrimary(this._seeks.length > 0)
+    }
+
     this.updatePeer(peer)
   }
 
@@ -2643,8 +2662,9 @@ module.exports = class Replicator {
 
   _makePeer(protomux) {
     const replicator = this
-    if (protomux.opened({ protocol: 'hypercore/alpha', id: this.core.discoveryKey }))
+    if (protomux.opened({ protocol: 'hypercore/alpha', id: this.core.discoveryKey })) {
       return onnochannel()
+    }
 
     const channel = protomux.createChannel({
       userData: null,
@@ -2742,8 +2762,9 @@ module.exports = class Replicator {
 }
 
 function matchingRequest(req, data) {
-  if (data.block !== null && (req.block === null || req.block.index !== data.block.index))
+  if (data.block !== null && (req.block === null || req.block.index !== data.block.index)) {
     return false
+  }
   if (data.hash !== null && (req.hash === null || req.hash.index !== data.hash.index)) return false
   if (data.seek !== null && (req.seek === null || req.seek.bytes !== data.seek.bytes)) return false
   if (data.upgrade !== null && req.upgrade === null) return false

package/lib/session-state.js

@@ -709,11 +709,12 @@ module.exports = class SessionState {
       const truncating = sharedLength < origLength
 
       for (const node of roots) {
-        if (node === null)
+        if (node === null) {
           throw INVALID_OPERATION(
             'Invalid catchup length, tree nodes not available',
             this.core.discoveryKey
           )
+        }
       }
 
       const fork = truncating ? this.fork + 1 : this.fork

package/lib/verifier.js

@@ -336,8 +336,9 @@ function parseSigner(signer) {
 
 function validateSigner(signer) {
   if (!signer || !signer.publicKey) throw BAD_ARGUMENT('Signer missing public key')
-  if (signer.signature && signer.signature !== 'ed25519')
+  if (signer.signature && signer.signature !== 'ed25519') {
     throw BAD_ARGUMENT('Only Ed25519 signatures are supported')
+  }
 }
 
 function manifestHash(manifest) {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "hypercore",
-  "version": "11.18.3",
+  "version": "11.19.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {
     "format": "prettier --write .",
-    "test": "prettier --check . && brittle test/all.js",
+    "lint": "prettier --check .",
+    "test": "brittle test/all.js",
     "test:bare": "bare test/all.js",
     "test:generate": "brittle -r test/all.js test/*.js"
   },
@@ -53,7 +54,7 @@
     "hypercore-crypto": "^3.2.1",
     "hypercore-errors": "^1.5.0",
     "hypercore-id-encoding": "^1.2.0",
-    "hypercore-storage": "^1.0.0",
+    "hypercore-storage": "^2.0.0",
     "is-options": "^1.0.1",
     "nanoassert": "^2.0.0",
     "protomux": "^3.5.0",
@@ -69,6 +70,7 @@
     "brittle": "^3.0.0",
     "debugging-stream": "^3.1.0",
     "hyperswarm": "^4.3.6",
+    "lunte": "^1.2.0",
     "prettier": "^3.6.2",
     "prettier-config-holepunch": "^2.0.0",
     "rache": "^1.0.0",

package/lib/read-batch.js

@@ -1,10 +0,0 @@
-class HypercoreReadBatch {
-  constructor(core) {
-    this.core = core
-    this.gets = []
-  }
-
-  get(index) {}
-
-  tryFlush() {}
-}