hypercore 11.16.2 → 11.17.0

package/lib/merkle-tree.js

@@ -3,17 +3,23 @@ const crypto = require('hypercore-crypto')
 const b4a = require('b4a')
 const unslab = require('unslab')
 const caps = require('./caps')
-const { INVALID_PROOF, INVALID_CHECKSUM, INVALID_OPERATION, BAD_ARGUMENT, ASSERTION } = require('hypercore-errors')
+const {
+  INVALID_PROOF,
+  INVALID_CHECKSUM,
+  INVALID_OPERATION,
+  BAD_ARGUMENT,
+  ASSERTION
+} = require('hypercore-errors')
 
 class NodeQueue {
-  constructor (nodes, extra = null) {
+  constructor(nodes, extra = null) {
     this.i = 0
     this.nodes = nodes
     this.extra = extra
     this.length = nodes.length + (this.extra === null ? 0 : 1)
   }
 
-  shift (index) {
+  shift(index) {
     if (this.extra !== null && this.extra.index === index) {
       const node = this.extra
       this.extra = null
@@ -36,7 +42,7 @@ class NodeQueue {
 }
 
 class MerkleTreeBatch {
-  constructor (session) {
+  constructor(session) {
     this.fork = session.fork
     this.roots = [...session.roots]
     this.length = session.length
@@ -56,7 +62,7 @@ class MerkleTreeBatch {
     this.upgraded = false
   }
 
-  checkout (length, additionalRoots) {
+  checkout(length, additionalRoots) {
     const roots = []
     let r = 0
 
@@ -98,7 +104,7 @@ class MerkleTreeBatch {
     }
   }
 
-  prune (length) {
+  prune(length) {
     if (length === 0) return
 
     const head = 2 * length - 2
@@ -118,7 +124,7 @@ class MerkleTreeBatch {
     }
   }
 
-  clone () {
+  clone() {
     const b = new MerkleTreeBatch(this.session)
 
     b.fork = this.fork
@@ -135,20 +141,20 @@ class MerkleTreeBatch {
     return b
   }
 
-  hash () {
+  hash() {
     if (this.hashCached === null) this.hashCached = unslab(crypto.tree(this.roots))
     return this.hashCached
   }
 
-  signable (manifestHash) {
+  signable(manifestHash) {
     return caps.treeSignable(manifestHash, this.hash(), this.length, this.fork)
   }
 
-  signableCompat (noHeader) {
+  signableCompat(noHeader) {
     return caps.treeSignableCompat(this.hash(), this.length, this.fork, noHeader)
   }
 
-  get (index) {
+  get(index) {
     if (index >= this.length * 2) {
       return null
     }
@@ -161,11 +167,11 @@ class MerkleTreeBatch {
   }
 
   // deprecated, use sssion proof instead
-  proof (batch, { block, hash, seek, upgrade }) {
+  proof(batch, { block, hash, seek, upgrade }) {
     return generateProof(this.session, batch, block, hash, seek, upgrade)
   }
 
-  verifyUpgrade (proof) {
+  verifyUpgrade(proof) {
     const unverified = verifyTree(proof, this.nodes)
 
     if (!proof.upgrade) throw INVALID_OPERATION('Expected upgrade proof')
@@ -173,13 +179,13 @@ class MerkleTreeBatch {
     return verifyUpgrade(proof, unverified, this)
   }
 
-  addNodesUnsafe (nodes) {
+  addNodesUnsafe(nodes) {
     for (let i = 0; i < nodes.length; i++) {
       this.nodes.push(nodes[i])
     }
   }
 
-  append (buf) {
+  append(buf) {
     const head = this.length * 2
     const ite = flat.iterator(head)
     const node = blockNode(head, buf)
@@ -187,7 +193,7 @@ class MerkleTreeBatch {
     this.appendRoot(node, ite)
   }
 
-  appendRoot (node, ite) {
+  appendRoot(node, ite) {
     node = unslabNode(node)
     this.hashCached = null
     this.upgraded = true
@@ -214,17 +220,19 @@ class MerkleTreeBatch {
     }
   }
 
-  commitable () {
-    return this.treeFork === this.session.fork && (
-      this.upgraded
+  commitable() {
+    return (
+      this.treeFork === this.session.fork &&
+      (this.upgraded
         ? this.treeLength === this.session.length
-        : this.treeLength <= this.session.length
+        : this.treeLength <= this.session.length)
     )
   }
 
-  commit (tx) {
+  commit(tx) {
     if (tx === undefined) throw INVALID_OPERATION('No database batch was passed')
-    if (!this.commitable()) throw INVALID_OPERATION('Tree was modified during batch, refusing to commit')
+    if (!this.commitable())
+      throw INVALID_OPERATION('Tree was modified during batch, refusing to commit')
 
     if (this.upgraded) this._commitUpgrade(tx)
 
@@ -238,7 +246,7 @@ class MerkleTreeBatch {
     return this
   }
 
-  _commitUpgrade (tx) {
+  _commitUpgrade(tx) {
     // TODO: If easy to detect, we should refuse an trunc+append here without a fork id
     // change. Will only happen on user error so mostly to prevent that.
 
@@ -262,11 +270,11 @@ class MerkleTreeBatch {
     }
   }
 
-  seek (bytes, padding) {
+  seek(bytes, padding) {
     return new ByteSeeker(this, this, bytes, padding)
   }
 
-  byteRange (index) {
+  byteRange(index) {
     const rx = this.storage.read()
     const range = getByteRange(this, index, rx)
     rx.tryFlush()
@@ -274,7 +282,7 @@ class MerkleTreeBatch {
     return range
   }
 
-  byteOffset (index) {
+  byteOffset(index) {
     if (index === 2 * this.length) return this.byteLength
 
     const rx = this.storage.read()
@@ -284,7 +292,7 @@ class MerkleTreeBatch {
     return offset
   }
 
-  async restore (length) {
+  async restore(length) {
     if (length === this.length) return this
 
     const roots = unslabNodes(await MerkleTree.getRootsFromStorage(this.storage, length))
@@ -301,7 +309,7 @@ class MerkleTreeBatch {
 }
 
 class ReorgBatch extends MerkleTreeBatch {
-  constructor (session) {
+  constructor(session) {
     super(session)
 
     this.roots = []
@@ -319,11 +327,11 @@ class ReorgBatch extends MerkleTreeBatch {
     }
   }
 
-  get finished () {
+  get finished() {
     return this.want === null
   }
 
-  update (proof) {
+  update(proof) {
     if (this.want === null) return true
 
     const nodes = []
@@ -335,7 +343,7 @@ class ReorgBatch extends MerkleTreeBatch {
     return this._update(nodes)
   }
 
-  async _update (nodes) {
+  async _update(nodes) {
     const n = new Map()
     for (const node of nodes) n.set(node.index, node)
 
@@ -362,7 +370,7 @@ class ReorgBatch extends MerkleTreeBatch {
     return this._updateDiffRoot(diff)
   }
 
-  _updateDiffRoot (diff) {
+  _updateDiffRoot(diff) {
     if (this.want === null) return true
 
     const spans = flat.spans(diff.index)
@@ -387,21 +395,22 @@ class ReorgBatch extends MerkleTreeBatch {
 }
 
 class ByteSeeker {
-  constructor (session, bytes, padding = 0) {
+  constructor(session, bytes, padding = 0) {
     this.session = session
     this.bytes = bytes
     this.padding = padding
 
-    const size = session.byteLength - (session.length * padding)
+    const size = session.byteLength - session.length * padding
 
     this.start = bytes >= size ? session.length : 0
     this.end = bytes < size ? session.length : 0
   }
 
-  async _seek (bytes) {
+  async _seek(bytes) {
     if (!bytes) return [0, 0]
 
-    for (const node of this.session.roots) { // all async ticks happen once we find the root so safe
+    for (const node of this.session.roots) {
+      // all async ticks happen once we find the root so safe
       const size = getUnpaddedSize(node, this.padding, null)
 
       if (bytes === size) return [flat.rightSpan(node.index) + 2, 0]
@@ -434,7 +443,8 @@ class ByteSeeker {
     return null
   }
 
-  async update () { // TODO: combine _seek and this, much simpler
+  async update() {
+    // TODO: combine _seek and this, much simpler
     const res = await this._seek(this.bytes)
     if (!res) return null
     if ((res[0] & 1) === 0) return [res[0] / 2, res[1]]
@@ -448,7 +458,7 @@ class ByteSeeker {
 }
 
 class TreeProof {
-  constructor (session, block, hash, seek, upgrade) {
+  constructor(session, block, hash, seek, upgrade) {
     this.fork = session.fork
     this.signature = session.signature
 
@@ -465,8 +475,15 @@ class TreeProof {
     }
   }
 
-  async settle () {
-    const result = { fork: this.fork, block: null, hash: null, seek: null, upgrade: null, manifest: null }
+  async settle() {
+    const result = {
+      fork: this.fork,
+      block: null,
+      hash: null,
+      seek: null,
+      upgrade: null,
+      manifest: null
+    }
 
     const [pNode, pSeek, pUpgrade, pAdditional] = await settleProof(this.pending)
 
@@ -507,27 +524,27 @@ class TreeProof {
 }
 
 class MerkleTree {
-  static hash (s) {
+  static hash(s) {
     return unslab(crypto.tree(s.roots))
   }
 
-  static signable (s, namespace) {
+  static signable(s, namespace) {
     return caps.treeSignable(namespace, MerkleTree.hash(s), s.length, s.fork)
   }
 
-  static size (roots) {
+  static size(roots) {
     return totalSize(roots)
   }
 
-  static span (roots) {
+  static span(roots) {
     return totalSpan(roots)
   }
 
-  static getRoots (session, length) {
+  static getRoots(session, length) {
     return MerkleTree.getRootsFromStorage(session.storage, length)
   }
 
-  static getRootsFromStorage (storage, length) {
+  static getRootsFromStorage(storage, length) {
     const indexes = flat.fullRoots(2 * length)
     const roots = new Array(indexes.length)
     const rx = storage.read()
@@ -541,7 +558,7 @@ class MerkleTree {
     return Promise.all(roots)
   }
 
-  static async upgradeable (session, length) {
+  static async upgradeable(session, length) {
     const indexes = flat.fullRoots(2 * length)
     const roots = new Array(indexes.length)
     const rx = session.storage.read()
@@ -559,15 +576,15 @@ class MerkleTree {
     return true
   }
 
-  static seek (session, bytes, padding) {
+  static seek(session, bytes, padding) {
     return new ByteSeeker(session, bytes, padding)
   }
 
-  static get (session, index) {
+  static get(session, index) {
     return getTreeNodeFromStorage(session.storage, index)
   }
 
-  static async truncate (session, length, batch, fork = batch.fork) {
+  static async truncate(session, length, batch, fork = batch.fork) {
     const head = length * 2
     const fullRoots = flat.fullRoots(head)
 
@@ -592,7 +609,7 @@ class MerkleTree {
     return batch
   }
 
-  static async reorg (session, proof, batch) {
+  static async reorg(session, proof, batch) {
     let unverified = null
 
     if (proof.block || proof.hash || proof.seek) {
@@ -620,7 +637,7 @@ class MerkleTree {
     return batch
   }
 
-  static verifyFullyRemote (session, proof) {
+  static verifyFullyRemote(session, proof) {
     // TODO: impl this less hackishly
     const batch = new MerkleTreeBatch(session)
 
@@ -641,7 +658,7 @@ class MerkleTree {
     return batch
   }
 
-  static async verify (session, proof) {
+  static async verify(session, proof) {
     const batch = new MerkleTreeBatch(session)
 
     let unverified = verifyTree(proof, batch.nodes)
@@ -662,11 +679,11 @@ class MerkleTree {
     return batch
   }
 
-  static proof (session, rx, { block, hash, seek, upgrade }) {
+  static proof(session, rx, { block, hash, seek, upgrade }) {
     return generateProof(session, rx, block, hash, seek, upgrade)
   }
 
-  static async missingNodes (session, index, length) {
+  static async missingNodes(session, index, length) {
     const head = 2 * length
     const ite = flat.iterator(index)
 
@@ -679,18 +696,19 @@ 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) throw ASSERTION('Bad arguments to missingNodes index=' + index + ' at length=' + length)
+      if (cnt >= 1024)
+        throw ASSERTION('Bad arguments to missingNodes index=' + index + ' at length=' + length)
       ite.parent()
     }
 
     return cnt
   }
 
-  static byteOffset (session, index) {
+  static byteOffset(session, index) {
     return getByteOffsetSession(session, index, null)
   }
 
-  static byteRange (session, index) {
+  static byteRange(session, index) {
     const rx = session.storage.read()
     const offset = getByteOffsetSession(session, index, rx)
     const size = getNodeSize(index, rx)
@@ -705,16 +723,17 @@ module.exports = {
   MerkleTree
 }
 
-async function getNodeSize (index, rx) {
+async function getNodeSize(index, rx) {
   return (await getTreeNodeOrError(rx, index)).size
 }
 
-async function getByteOffsetSession (session, index, rx) {
+async function getByteOffsetSession(session, index, rx) {
   if (index === 2 * session.length) return session.byteLength
 
-  const treeNodes = rx === null
-    ? await getByteOffsetBatchFlush(session.roots, index, session.storage.read())
-    : await getByteOffsetBatch(session.roots, index, rx)
+  const treeNodes =
+    rx === null
+      ? await getByteOffsetBatchFlush(session.roots, index, session.storage.read())
+      : await getByteOffsetBatch(session.roots, index, rx)
 
   let offset = 0
   for (const node of treeNodes) offset += node.size
@@ -722,7 +741,7 @@ async function getByteOffsetSession (session, index, rx) {
   return offset
 }
 
-async function getByteOffset (tree, index, rx) {
+async function getByteOffset(tree, index, rx) {
   if (index === 2 * tree.length) return tree.byteLength
 
   const treeNodes = await getByteOffsetBatch(tree.roots, index, rx)
@@ -733,13 +752,13 @@ async function getByteOffset (tree, index, rx) {
   return offset
 }
 
-function getByteOffsetBatchFlush (roots, index, rx) {
+function getByteOffsetBatchFlush(roots, index, rx) {
   const treeNodes = getByteOffsetBatch(roots, index, rx)
   rx.tryFlush()
   return treeNodes
 }
 
-function getByteOffsetBatch (roots, index, rx) {
+function getByteOffsetBatch(roots, index, rx) {
   if ((index & 1) === 1) index = flat.leftSpan(index)
 
   let head = 0
@@ -747,8 +766,9 @@ function getByteOffsetBatch (roots, index, rx) {
 
   const promises = []
 
-  for (const node of roots) { // all async ticks happen once we find the root so safe
-    head += 2 * ((node.index - head) + 1)
+  for (const node of roots) {
+    // all async ticks happen once we find the root so safe
+    head += 2 * (node.index - head + 1)
 
     if (index >= head) {
       promises.push(node.size)
@@ -774,7 +794,7 @@ function getByteOffsetBatch (roots, index, rx) {
   throw ASSERTION('Failed to find offset')
 }
 
-function getByteRange (tree, index, rx) {
+function getByteRange(tree, index, rx) {
   const head = 2 * tree.length
   if (((index & 1) === 0 ? index : flat.rightSpan(index)) >= head) {
     throw BAD_ARGUMENT('Index is out of bounds')
@@ -788,7 +808,7 @@ function getByteRange (tree, index, rx) {
 
 // All the methods needed for proof verification
 
-function verifyTree ({ block, hash, seek }, nodes) {
+function verifyTree({ block, hash, seek }, nodes) {
   const untrustedNode = block
     ? { index: 2 * block.index, value: block.value, nodes: block.nodes }
     : hash
@@ -836,7 +856,7 @@ function verifyTree ({ block, hash, seek }, nodes) {
   return root
 }
 
-function verifyUpgrade ({ fork, upgrade }, blockRoot, batch) {
+function verifyUpgrade({ fork, upgrade }, blockRoot, batch) {
   const prologue = batch.prologue
 
   if (prologue) {
@@ -908,7 +928,7 @@ function verifyUpgrade ({ fork, upgrade }, blockRoot, batch) {
   return q.extra === null
 }
 
-async function seekFromHead (session, head, bytes, padding) {
+async function seekFromHead(session, head, bytes, padding) {
   const roots = flat.fullRoots(head)
 
   for (let i = 0; i < roots.length; i++) {
@@ -930,7 +950,7 @@ async function seekFromHead (session, head, bytes, padding) {
 
 // trust that bytes are within the root tree and find the block at bytes
 
-async function seekTrustedTree (session, root, bytes, padding) {
+async function seekTrustedTree(session, root, bytes, padding) {
   if (!bytes) return root
 
   const ite = flat.iterator(root)
@@ -957,8 +977,10 @@ async function seekTrustedTree (session, root, bytes, padding) {
 
 // try to find the block at bytes without trusting that is *is* within the root passed
 
-async function seekUntrustedTree (session, root, bytes, padding) {
-  const offset = await getByteOffsetSession(session, root, null) - (padding ? padding * flat.leftSpan(root) / 2 : 0)
+async function seekUntrustedTree(session, root, bytes, padding) {
+  const offset =
+    (await getByteOffsetSession(session, root, null)) -
+    (padding ? (padding * flat.leftSpan(root)) / 2 : 0)
 
   if (offset > bytes) throw INVALID_OPERATION('Invalid seek')
   if (offset === bytes) return root
@@ -976,7 +998,7 @@ async function seekUntrustedTree (session, root, bytes, padding) {
 // Note, that all these methods are sync as we can statically infer which nodes
 // are needed for the remote to verify given they arguments they passed us
 
-function seekProof (session, rx, seekRoot, root, p) {
+function seekProof(session, rx, seekRoot, root, p) {
   const ite = flat.iterator(seekRoot)
   let cnt = 0
 
@@ -991,7 +1013,7 @@ function seekProof (session, rx, seekRoot, root, p) {
   }
 }
 
-function blockAndSeekProof (session, rx, node, seek, seekRoot, root, p) {
+function blockAndSeekProof(session, rx, node, seek, seekRoot, root, p) {
   if (!node) return seekProof(session, rx, seekRoot, root, p)
 
   const ite = flat.iterator(node.index)
@@ -1001,7 +1023,8 @@ 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) throw ASSERTION('Bad blockAndSeekProof seekRoot=' + seekRoot + ', root=' + root)
+    if (++cnt >= 1024)
+      throw ASSERTION('Bad blockAndSeekProof seekRoot=' + seekRoot + ', root=' + root)
     ite.sibling()
 
     if (seek && ite.contains(seekRoot) && ite.index !== seekRoot) {
@@ -1014,7 +1037,7 @@ function blockAndSeekProof (session, rx, node, seek, seekRoot, root, p) {
   }
 }
 
-function upgradeProof (session, rx, node, seek, from, to, subTree, p) {
+function upgradeProof(session, rx, node, seek, from, to, subTree, p) {
   if (from === 0) p.upgrade = []
 
   for (const ite = flat.iterator(0); ite.fullRoot(to); ite.nextTree()) {
@@ -1064,7 +1087,7 @@ function upgradeProof (session, rx, node, seek, from, to, subTree, p) {
   }
 }
 
-function additionalUpgradeProof (session, rx, from, to, p) {
+function additionalUpgradeProof(session, rx, from, to, p) {
   if (from === 0) p.additionalUpgrade = []
 
   for (const ite = flat.iterator(0); ite.fullRoot(to); ite.nextTree()) {
@@ -1082,7 +1105,10 @@ function additionalUpgradeProof (session, rx, from, to, p) {
       ite.seek(target)
 
       while (ite.index !== root) {
-        if (++cnt >= 1024) throw ASSERTION('Bad arguments to additionalUpgradeProof root=' + root + ' target=' + target)
+        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))
@@ -1102,7 +1128,7 @@ function additionalUpgradeProof (session, rx, from, to, p) {
   }
 }
 
-function nodesToRoot (index, nodes, head) {
+function nodesToRoot(index, nodes, head) {
   const ite = flat.iterator(index)
 
   for (let i = 0; i < nodes; i++) {
@@ -1113,27 +1139,27 @@ function nodesToRoot (index, nodes, head) {
   return ite.index
 }
 
-function totalSize (nodes) {
+function totalSize(nodes) {
   let s = 0
   for (const node of nodes) s += node.size
   return s
 }
 
-function totalSpan (nodes) {
+function totalSpan(nodes) {
   let s = 0
-  for (const node of nodes) s += 2 * ((node.index - s) + 1)
+  for (const node of nodes) s += 2 * (node.index - s + 1)
   return s
 }
 
-function blockNode (index, value) {
+function blockNode(index, value) {
   return { index, size: value.byteLength, hash: crypto.data(value) }
 }
 
-function parentNode (index, a, b) {
+function parentNode(index, a, b) {
   return { index, size: a.size + b.size, hash: crypto.parent(a, b) }
 }
 
-function log2 (n) {
+function log2(n) {
   let res = 1
 
   while (n > 2) {
@@ -1144,40 +1170,48 @@ function log2 (n) {
   return res
 }
 
-function normalizeIndexed (block, 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 }
+function normalizeIndexed(block, 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) {
+async function getTreeNodeOrError(rx, index) {
   const node = await rx.getTreeNode(index)
-  if (node === null) throw INVALID_OPERATION('Expected tree node ' + index + ' from storage, got (nil)')
+  if (node === null)
+    throw INVALID_OPERATION('Expected tree node ' + index + ' from storage, got (nil)')
   return node
 }
 
-function getTreeNodeFromStorageOrError (storage, index) {
+function getTreeNodeFromStorageOrError(storage, index) {
   const rx = storage.read()
   const p = getTreeNodeOrError(rx, index)
   rx.tryFlush()
   return p
 }
 
-function getTreeNodeFromStorage (storage, index) {
+function getTreeNodeFromStorage(storage, index) {
   const rx = storage.read()
   const node = rx.getTreeNode(index)
   rx.tryFlush()
   return node
 }
 
-function hasTreeNode (storage, index) {
+function hasTreeNode(storage, index) {
   const rx = storage.read()
   const has = rx.hasTreeNode(index)
   rx.tryFlush()
   return has
 }
 
-async function settleProof (p) {
+async function settleProof(p) {
   const result = [
     p.node && Promise.all(p.node),
     p.seek && Promise.all(p.seek),
@@ -1197,13 +1231,14 @@ async function settleProof (p) {
 }
 
 // tree can be either the merkle tree or a merkle tree batch
-async function generateProof (session, rx, block, hash, seek, upgrade) {
+async function generateProof(session, rx, block, hash, seek, upgrade) {
   // Important that this does not throw inbetween making the promise arrays
   // and finalise being called, otherwise there will be lingering promises in the background
 
   if (session.prologue && upgrade) {
     upgrade.start = upgrade.start < session.prologue.length ? 0 : upgrade.start
-    upgrade.length = upgrade.start < session.prologue.length ? session.prologue.length : upgrade.length
+    upgrade.length =
+      upgrade.start < session.prologue.length ? session.prologue.length : upgrade.length
   }
 
   const head = 2 * session.length
@@ -1227,7 +1262,9 @@ async function generateProof (session, rx, block, hash, seek, upgrade) {
 
   if (node !== null && (!upgrade || node.lastIndex < upgrade.start)) {
     subTree = nodesToRoot(node.index, node.nodes, to)
-    const seekRoot = seek ? await seekUntrustedTree(session, subTree, seek.bytes, seek.padding) : head
+    const seekRoot = seek
+      ? await seekUntrustedTree(session, subTree, seek.bytes, seek.padding)
+      : head
     blockAndSeekProof(session, rx, node, seek, seekRoot, subTree, p.pending)
   } else if ((node || seek) && upgrade) {
     subTree = seek ? await seekFromHead(session, to, seek.bytes, seek.padding) : node.index
@@ -1241,16 +1278,18 @@ async function generateProof (session, rx, block, hash, seek, upgrade) {
   return p
 }
 
-function getUnpaddedSize (node, padding, ite) {
-  return padding === 0 ? node.size : node.size - padding * (ite ? ite.countLeaves() : flat.countLeaves(node.index))
+function getUnpaddedSize(node, padding, ite) {
+  return padding === 0
+    ? node.size
+    : node.size - padding * (ite ? ite.countLeaves() : flat.countLeaves(node.index))
 }
 
-function unslabNodes (nodes) {
+function unslabNodes(nodes) {
   for (const node of nodes) unslabNode(node)
   return nodes
 }
 
-function unslabNode (node) {
+function unslabNode(node) {
   if (node === null) return node
   node.hash = unslab(node.hash)
   return node