add lint

Author: mafintosh

.github/workflows/test-node.yml

@@ -25,6 +25,7 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
+      - run: npm run lint
       - run: npm test
       - run: npm -g install bare
       - run: npm run test:bare

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) {

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)
         }
 

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)

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()

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
 }
 

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,

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