hypercore 11.16.2 → 11.18.0

package/lib/replicator.js

@@ -30,14 +30,20 @@ const ReceiverQueue = require('./receiver-queue')
 const HotswapQueue = require('./hotswap-queue')
 const RemoteBitfield = require('./remote-bitfield')
 const { MerkleTree } = require('./merkle-tree')
-const { REQUEST_CANCELLED, REQUEST_TIMEOUT, INVALID_CAPABILITY, SNAPSHOT_NOT_AVAILABLE, ASSERTION } = require('hypercore-errors')
+const {
+  REQUEST_CANCELLED,
+  REQUEST_TIMEOUT,
+  INVALID_CAPABILITY,
+  SNAPSHOT_NOT_AVAILABLE,
+  ASSERTION
+} = require('hypercore-errors')
 const m = require('./messages')
 const caps = require('./caps')
 
 const DEFAULT_MAX_INFLIGHT = [16, 512]
 const SCALE_LATENCY = 50
 const DEFAULT_SEGMENT_SIZE = 256 * 1024 * 8 // 256 KiB in bits
-const NOT_DOWNLOADING_SLACK = 20000 + (Math.random() * 20000) | 0
+const NOT_DOWNLOADING_SLACK = (20000 + Math.random() * 20000) | 0
 const MAX_PEERS_UPGRADE = 3
 const LAST_BLOCKS = 256
 const MAX_REMOTE_SEGMENTS = 2048
@@ -57,14 +63,14 @@ const PRIORITY = {
 }
 
 class Attachable {
-  constructor (replicator) {
+  constructor(replicator) {
     this.replicator = replicator
     this.resolved = false
     this.processing = false
     this.refs = []
   }
 
-  attach (session) {
+  attach(session) {
     const r = {
       context: this,
       session,
@@ -87,7 +93,7 @@ class Attachable {
     return r
   }
 
-  detach (r, err = null) {
+  detach(r, err = null) {
     if (r.context !== this) return false
 
     this._detach(r)
@@ -97,12 +103,12 @@ class Attachable {
     return true
   }
 
-  _detach (r) {
+  _detach(r) {
     const rh = this.refs.pop()
     const sh = r.session.pop()
 
-    if (r.rindex < this.refs.length) this.refs[rh.rindex = r.rindex] = rh
-    if (r.sindex < r.session.length) r.session[sh.sindex = r.sindex] = sh
+    if (r.rindex < this.refs.length) this.refs[(rh.rindex = r.rindex)] = rh
+    if (r.sindex < r.session.length) r.session[(sh.sindex = r.sindex)] = sh
 
     destroyRequestTimeout(r)
     r.context = null
@@ -110,45 +116,45 @@ class Attachable {
     return r
   }
 
-  gc () {
+  gc() {
     if (this.refs.length === 0 && !this.processing) this._unref()
   }
 
-  processed () {
+  processed() {
     this.processing = false
     this.gc()
   }
 
-  _cancel (r, err) {
+  _cancel(r, err) {
     r.reject(err || REQUEST_CANCELLED())
   }
 
-  _unref () {
+  _unref() {
     // overwrite me
   }
 
-  resolve (val) {
+  resolve(val) {
     this.resolved = true
     while (this.refs.length > 0) {
       this._detach(this.refs[this.refs.length - 1]).resolve(val)
     }
   }
 
-  reject (err) {
+  reject(err) {
     this.resolved = true
     while (this.refs.length > 0) {
       this._detach(this.refs[this.refs.length - 1]).reject(err)
     }
   }
 
-  setTimeout (r, ms) {
+  setTimeout(r, ms) {
     destroyRequestTimeout(r)
     r.timeout = setTimeout(onrequesttimeout, ms, r)
   }
 }
 
 class BlockRequest extends Attachable {
-  constructor (replicator, tracker, index, priority) {
+  constructor(replicator, tracker, index, priority) {
     super(replicator)
 
     this.index = index
@@ -159,7 +165,7 @@ class BlockRequest extends Attachable {
     this.tracker = tracker
   }
 
-  _unref () {
+  _unref() {
     this.queued = false
 
     for (const req of this.inflight) {
@@ -172,7 +178,7 @@ class BlockRequest extends Attachable {
 }
 
 class RangeRequest extends Attachable {
-  constructor (replicator, ranges, start, end, linear, ifAvailable, blocks) {
+  constructor(replicator, ranges, start, end, linear, ifAvailable, blocks) {
     super(replicator)
 
     this.start = start
@@ -187,20 +193,20 @@ class RangeRequest extends Attachable {
     this.userEnd = end
   }
 
-  _unref () {
+  _unref() {
     const i = this.ranges.indexOf(this)
     if (i === -1) return
     const h = this.ranges.pop()
     if (i < this.ranges.length) this.ranges[i] = h
   }
 
-  _cancel (r) {
+  _cancel(r) {
     r.resolve(false)
   }
 }
 
 class UpgradeRequest extends Attachable {
-  constructor (replicator, fork, length) {
+  constructor(replicator, fork, length) {
     super(replicator)
 
     this.fork = fork
@@ -208,18 +214,18 @@ class UpgradeRequest extends Attachable {
     this.inflight = []
   }
 
-  _unref () {
+  _unref() {
     if (this.replicator.eagerUpgrade === true || this.inflight.length > 0) return
     this.replicator._upgrade = null
   }
 
-  _cancel (r) {
+  _cancel(r) {
     r.resolve(false)
   }
 }
 
 class SeekRequest extends Attachable {
-  constructor (replicator, seeks, seeker) {
+  constructor(replicator, seeks, seeker) {
     super(replicator)
 
     this.seeker = seeker
@@ -227,7 +233,7 @@ class SeekRequest extends Attachable {
     this.seeks = seeks
   }
 
-  _unref () {
+  _unref() {
     if (this.inflight.length > 0) return
     const i = this.seeks.indexOf(this)
     if (i === -1) return
@@ -237,23 +243,23 @@ class SeekRequest extends Attachable {
 }
 
 class InflightTracker {
-  constructor () {
+  constructor() {
     this._requests = []
     this._free = []
     this._active = 0
   }
 
-  get idle () {
+  get idle() {
     return this._active === 0
   }
 
-  * [Symbol.iterator] () {
+  *[Symbol.iterator]() {
     for (const req of this._requests) {
       if (req !== null) yield req
     }
   }
 
-  add (req) {
+  add(req) {
     const id = this._free.length ? this._free.pop() : this._requests.push(null)
     req.id = id
     this._requests[id - 1] = req
@@ -261,45 +267,45 @@ class InflightTracker {
     return req
   }
 
-  get (id) {
+  get(id) {
     return id <= this._requests.length ? this._requests[id - 1] : null
   }
 
-  remove (id, roundtrip) {
+  remove(id, roundtrip) {
     if (id > this._requests.length) return
     if (this._requests[id - 1]) this._active--
     this._requests[id - 1] = null
     if (roundtrip === true) this._free.push(id)
   }
 
-  reusable (id) {
+  reusable(id) {
     this._free.push(id)
   }
 }
 
 class BlockTracker {
-  constructor (replicator) {
+  constructor(replicator) {
     this._replicator = replicator
     this._map = new Map()
   }
 
-  [Symbol.iterator] () {
+  [Symbol.iterator]() {
     return this._map.values()
   }
 
-  isEmpty () {
+  isEmpty() {
     return this._map.size === 0
   }
 
-  has (index) {
+  has(index) {
     return this._map.has(index)
   }
 
-  get (index) {
+  get(index) {
     return this._map.get(index) || null
   }
 
-  add (index, priority) {
+  add(index, priority) {
     let b = this._map.get(index)
     if (b) return b
 
@@ -309,7 +315,7 @@ class BlockTracker {
     return b
   }
 
-  remove (index) {
+  remove(index) {
     const b = this.get(index)
     this._map.delete(index)
     return b
@@ -317,12 +323,12 @@ class BlockTracker {
 }
 
 class RoundtripQueue {
-  constructor () {
+  constructor() {
     this.queue = []
     this.tick = 0
   }
 
-  clear () {
+  clear() {
     const ids = new Array(this.queue.length)
     for (let i = 0; i < ids.length; i++) {
       ids[i] = this.queue[i][1]
@@ -333,11 +339,11 @@ class RoundtripQueue {
     return ids
   }
 
-  add (id) {
+  add(id) {
     this.queue.push([++this.tick, id])
   }
 
-  flush (tick) {
+  flush(tick) {
     let flushed = null
 
     for (let i = 0; i < this.queue.length; i++) {
@@ -352,14 +358,14 @@ class RoundtripQueue {
 }
 
 class ProofRequest {
-  constructor (msg, proof, block, manifest) {
+  constructor(msg, proof, block, manifest) {
     this.msg = msg
     this.proof = proof
     this.block = block
     this.manifest = manifest
   }
 
-  async fulfill () {
+  async fulfill() {
     if (this.proof === null) return null
 
     const [proof, block] = await Promise.all([this.proof.settle(), this.block])
@@ -374,7 +380,7 @@ class ProofRequest {
 }
 
 class Peer {
-  constructor (replicator, protomux, channel, inflightRange) {
+  constructor(replicator, protomux, channel, inflightRange) {
     this.core = replicator.core
     this.replicator = replicator
     this.stream = protomux.stream
@@ -466,34 +472,41 @@ class Peer {
     replicator._active++
   }
 
-  get remoteContiguousLength () {
+  get remoteContiguousLength() {
     return this.remoteBitfield.findFirst(false, this._remoteContiguousLength)
   }
 
-  getMaxInflight () {
+  getMaxInflight() {
     const stream = this.stream.rawStream
     if (!stream.udx) return Math.min(this.inflightRange[1], this.inflightRange[0] * 3)
 
-    const scale = stream.rtt <= SCALE_LATENCY ? 1 : stream.rtt / SCALE_LATENCY * Math.min(1, 2 / this.replicator.peers.length)
-    return Math.max(this.inflightRange[0], Math.round(Math.min(this.inflightRange[1], this.inflightRange[0] * scale)))
+    const scale =
+      stream.rtt <= SCALE_LATENCY
+        ? 1
+        : (stream.rtt / SCALE_LATENCY) * Math.min(1, 2 / this.replicator.peers.length)
+    return Math.max(
+      this.inflightRange[0],
+      Math.round(Math.min(this.inflightRange[1], this.inflightRange[0] * scale))
+    )
   }
 
-  getMaxHotswapInflight () {
+  getMaxHotswapInflight() {
     const inf = this.getMaxInflight()
     return Math.max(16, inf / 2)
   }
 
-  signalUpgrade () {
-    if (this.fullyDownloadedSignaled && !this.replicator.fullyDownloaded()) this.fullyDownloadedSignaled = false
+  signalUpgrade() {
+    if (this.fullyDownloadedSignaled && !this.replicator.fullyDownloaded())
+      this.fullyDownloadedSignaled = false
     if (this._shouldUpdateCanUpgrade() === true) this._updateCanUpgradeAndSync()
     else this.sendSync()
   }
 
-  _markInflight (index) {
+  _markInflight(index) {
     this.missingBlocks.set(index, false)
   }
 
-  broadcastRange (start, length, drop) {
+  broadcastRange(start, length, drop) {
     if (!this.isActive()) return
 
     if (drop) this._unclearLocalRange(start, length)
@@ -502,7 +515,13 @@ class Peer {
     const i = Math.floor(start / DEFAULT_SEGMENT_SIZE)
     const contig = this.core.header.hints.contiguousLength === this.core.state.length
 
-    if (start + LAST_BLOCKS < this.core.state.length && !this.remoteSegmentsWanted.has(i) && !drop && !contig) return
+    if (
+      start + LAST_BLOCKS < this.core.state.length &&
+      !this.remoteSegmentsWanted.has(i) &&
+      !drop &&
+      !contig
+    )
+      return
 
     let force = false
     if (contig && !drop) {
@@ -537,20 +556,21 @@ class Peer {
     incrementTx(this.stats.wireRange, this.replicator.stats.wireRange)
   }
 
-  extension (name, message) {
+  extension(name, message) {
     this.wireExtension.send({ name: name === this.lastExtensionSent ? '' : name, message })
     incrementTx(this.stats.wireExtension, this.replicator.stats.wireExtension)
     this.lastExtensionSent = name
   }
 
-  onextension (message) {
+  onextension(message) {
     const name = message.name || this.lastExtensionRecv
     this.lastExtensionRecv = name
     const ext = this.extensions.get(name)
-    if (ext) ext._onmessage({ start: 0, end: message.message.byteLength, buffer: message.message }, this)
+    if (ext)
+      ext._onmessage({ start: 0, end: message.message.byteLength, buffer: message.message }, this)
   }
 
-  sendSync () {
+  sendSync() {
     if (this.syncsProcessing !== 0) {
       this.needsSync = true
       return
@@ -574,10 +594,15 @@ class Peer {
     incrementTx(this.stats.wireSync, this.replicator.stats.wireSync)
   }
 
-  onopen ({ seeks, capability }) {
-    const expected = caps.replicate(this.stream.isInitiator === false, this.core.key, this.stream.handshakeHash)
+  onopen({ seeks, capability }) {
+    const expected = caps.replicate(
+      this.stream.isInitiator === false,
+      this.core.key,
+      this.stream.handshakeHash
+    )
 
-    if (b4a.equals(capability, expected) !== true) { // TODO: change this to a rejection instead, less leakage
+    if (b4a.equals(capability, expected) !== true) {
+      // TODO: change this to a rejection instead, less leakage
       throw INVALID_CAPABILITY('Remote sent an invalid replication capability')
     }
 
@@ -606,12 +631,16 @@ class Peer {
     this.core.checkIfIdle()
   }
 
-  onclose (isRemote) {
+  onclose(isRemote) {
     // we might have signalled to the remote that we are done (ie not downloading) and the remote might agree on that
     // if that happens, the channel might be closed by the remote. if so just renegotiate it.
     // TODO: add a CLOSE_REASON to mux to we can make this cleaner...
-    const reopen = isRemote === true && this.remoteOpened === true && this.remoteDownloading === false &&
-       this.remoteUploading === true && this.replicator.downloading === true
+    const reopen =
+      isRemote === true &&
+      this.remoteOpened === true &&
+      this.remoteDownloading === false &&
+      this.remoteUploading === true &&
+      this.replicator.downloading === true
 
     if (this.remoteOpened === false) {
       this.replicator._ifAvailable--
@@ -635,7 +664,7 @@ class Peer {
     }
   }
 
-  closeIfIdle () {
+  closeIfIdle() {
     if (this.remoteDownloading === false && this.replicator.isDownloading() === false) {
       // idling, shut it down...
       this.channel.close()
@@ -645,7 +674,7 @@ class Peer {
     return false
   }
 
-  async onsync ({ fork, length, remoteLength, canUpgrade, uploading, downloading, hasManifest }) {
+  async onsync({ fork, length, remoteLength, canUpgrade, uploading, downloading, hasManifest }) {
     const lengthChanged = length !== this.remoteLength
     const sameFork = fork === this.core.state.fork
 
@@ -668,9 +697,10 @@ class Peer {
       if (this.replicator._addUpgradeMaybe() !== null) this._update()
     }
 
-    const upgrade = (lengthChanged === false || sameFork === false)
-      ? this.canUpgrade && sameFork
-      : await this._canUpgrade(length, fork)
+    const upgrade =
+      lengthChanged === false || sameFork === false
+        ? this.canUpgrade && sameFork
+        : await this._canUpgrade(length, fork)
 
     if (length === this.remoteLength && fork === this.core.state.fork) {
       this.canUpgrade = upgrade
@@ -682,28 +712,37 @@ class Peer {
 
     if (--this.syncsProcessing !== 0) return // ie not latest
 
-    if (this.needsSync === true || (this.core.state.fork === this.remoteFork && this.core.state.length > this.remoteLength)) {
+    if (
+      this.needsSync === true ||
+      (this.core.state.fork === this.remoteFork && this.core.state.length > this.remoteLength)
+    ) {
       this.signalUpgrade()
     }
 
     this._update()
   }
 
-  _shouldUpdateCanUpgrade () {
-    return this.core.state.fork === this.remoteFork &&
+  _shouldUpdateCanUpgrade() {
+    return (
+      this.core.state.fork === this.remoteFork &&
       this.core.state.length > this.remoteLength &&
       this.canUpgrade === false &&
       this.syncsProcessing === 0
+    )
   }
 
-  async _updateCanUpgradeAndSync () {
+  async _updateCanUpgradeAndSync() {
     const { length, fork } = this.core.state
 
     const remoteLength = this.remoteLength
     const remoteFork = this.remoteFork
     const canUpgrade = await this._canUpgrade(this.remoteLength, this.remoteFork)
 
-    if (this.syncsProcessing > 0 || length !== this.core.state.length || fork !== this.core.state.fork) {
+    if (
+      this.syncsProcessing > 0 ||
+      length !== this.core.state.length ||
+      fork !== this.core.state.fork
+    ) {
       return
     }
     if (remoteLength !== this.remoteLength || remoteFork !== this.remoteFork) {
@@ -723,7 +762,7 @@ class Peer {
   }
 
   // Safe to call in the background - never fails
-  async _canUpgrade (remoteLength, remoteFork) {
+  async _canUpgrade(remoteLength, remoteFork) {
     if (remoteFork !== this.core.state.fork) return false
 
     if (remoteLength === 0) return true
@@ -741,7 +780,7 @@ class Peer {
     }
   }
 
-  async _getProof (batch, msg) {
+  async _getProof(batch, msg) {
     let block = null
 
     if (msg.block) {
@@ -755,7 +794,7 @@ class Peer {
       block.catch(noop)
     }
 
-    const manifest = (msg.manifest && !this.core.compat) ? this.core.header.manifest : null
+    const manifest = msg.manifest && !this.core.compat ? this.core.header.manifest : null
 
     try {
       const proof = await MerkleTree.proof(this.core.state, batch, msg)
@@ -772,7 +811,7 @@ class Peer {
     }
   }
 
-  async onrequest (msg) {
+  async onrequest(msg) {
     const size = this.remoteRequests.size
     this.remoteRequests.set(msg.id, msg)
 
@@ -792,25 +831,30 @@ class Peer {
     await this._handleRequest(msg)
   }
 
-  oncancel (msg) {
+  oncancel(msg) {
     this._cancel(msg.request)
   }
 
-  _cancel (id) {
+  _cancel(id) {
     this.remoteRequests.delete(id)
     this.receiverQueue.delete(id)
   }
 
-  ondrain () {
+  ondrain() {
     return this._handleRequests()
   }
 
-  async _handleRequests () {
+  async _handleRequests() {
     if (this.receiverBusy || this.replicator.destroyed) return
     this.receiverBusy = true
     this.protomux.cork()
 
-    while (this.remoteOpened && this.protomux.drained && this.receiverQueue.length > 0 && !this.removed) {
+    while (
+      this.remoteOpened &&
+      this.protomux.drained &&
+      this.receiverQueue.length > 0 &&
+      !this.removed
+    ) {
       const msg = this.receiverQueue.shift()
       await this._handleRequest(msg)
     }
@@ -819,13 +863,14 @@ class Peer {
     this.receiverBusy = false
   }
 
-  async _handleRequest (msg) {
+  async _handleRequest(msg) {
     const batch = this.core.storage.read()
 
     // TODO: could still be answerable if (index, fork) is an ancestor of the current fork
-    const req = msg.fork === this.core.state.fork
-      ? await this._getProof(batch, msg)
-      : new ProofRequest(msg, null, null, null)
+    const req =
+      msg.fork === this.core.state.fork
+        ? await this._getProof(batch, msg)
+        : new ProofRequest(msg, null, null, null)
 
     if (req === null) {
       this.wireNoData.send({ request: msg.id, reason: INVALID_REQUEST })
@@ -837,7 +882,7 @@ class Peer {
     await this._fulfillRequest(req)
   }
 
-  async _fulfillRequest (req) {
+  async _fulfillRequest(req) {
     const proof = await req.fulfill()
 
     // if cancelled do not reply
@@ -855,7 +900,15 @@ class Peer {
     if (proof === null) {
       if (req.msg.manifest && this.core.header.manifest) {
         const manifest = this.core.header.manifest
-        this.wireData.send({ request: req.msg.id, fork: this.core.state.fork, block: null, hash: null, seek: null, upgrade: null, manifest })
+        this.wireData.send({
+          request: req.msg.id,
+          fork: this.core.state.fork,
+          block: null,
+          hash: null,
+          seek: null,
+          upgrade: null,
+          manifest
+        })
         incrementTx(this.stats.wireData, this.replicator.stats.wireData)
         return
       }
@@ -880,7 +933,7 @@ class Peer {
     incrementTx(this.stats.wireData, this.replicator.stats.wireData)
   }
 
-  _cancelRequest (req) {
+  _cancelRequest(req) {
     if (req.priority === PRIORITY.CANCELLED) return
     // mark as cancelled also and avoid re-entry
     req.priority = PRIORITY.CANCELLED
@@ -898,7 +951,7 @@ class Peer {
     incrementTx(this.stats.wireCancel, this.replicator.stats.wireCancel)
   }
 
-  _checkIfConflict () {
+  _checkIfConflict() {
     this.paused = true
 
     const length = Math.min(this.core.state.length, this.remoteLength)
@@ -919,7 +972,7 @@ class Peer {
     incrementTx(this.stats.wireRequest, this.replicator.stats.wireRequest)
   }
 
-  async ondata (data) {
+  async ondata(data) {
     // always allow a fork conflict proof to be sent
     if (data.request === 0 && data.upgrade && data.upgrade.start === 0) {
       if (await this.core.checkConflict(data, this)) return
@@ -991,7 +1044,7 @@ class Peer {
     }
   }
 
-  onnodata ({ request, reason }) {
+  onnodata({ request, reason }) {
     const req = request > 0 ? this.replicator._inflight.get(request) : null
     if (req === null || req.peer !== this) return
 
@@ -999,7 +1052,7 @@ class Peer {
     this.replicator._onnodata(this, req, reason)
   }
 
-  _onrequestroundtrip (req) {
+  _onrequestroundtrip(req) {
     if (req.priority === PRIORITY.CANCELLED) return
     // to avoid re-entry we also just mark it as cancelled
     req.priority = PRIORITY.CANCELLED
@@ -1012,18 +1065,18 @@ class Peer {
     for (const id of flushed) this.replicator._inflight.reusable(id)
   }
 
-  onwant ({ start, length }) {
+  onwant({ start, length }) {
     const i = Math.floor(start / DEFAULT_SEGMENT_SIZE)
     if (this.remoteSegmentsWanted.size >= MAX_REMOTE_SEGMENTS) this.remoteSegmentsWanted.clear() // just in case of abuse
     this.remoteSegmentsWanted.add(i)
     this.replicator._onwant(this, start, length)
   }
 
-  onunwant () {
+  onunwant() {
     // TODO
   }
 
-  onbitfield ({ start, bitfield }) {
+  onbitfield({ start, bitfield }) {
     if (start < this._remoteContiguousLength) this._remoteContiguousLength = start // bitfield is always the truth
     this.remoteBitfield.insert(start, bitfield)
     this.missingBlocks.insert(start, bitfield)
@@ -1031,7 +1084,7 @@ class Peer {
     this._update()
   }
 
-  _clearLocalRange (start, length) {
+  _clearLocalRange(start, length) {
     const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield
 
     if (length === 1) {
@@ -1064,12 +1117,12 @@ class Peer {
     }
   }
 
-  _resetMissingBlock (index) {
+  _resetMissingBlock(index) {
     const bitfield = this.core.skipBitfield === null ? this.core.bitfield : this.core.skipBitfield
     this.missingBlocks.set(index, this._remoteHasBlock(index) && !bitfield.get(index))
   }
 
-  _unclearLocalRange (start, length) {
+  _unclearLocalRange(start, length) {
     if (length === 1) {
       this._resetMissingBlock(start)
       return
@@ -1096,7 +1149,7 @@ class Peer {
     this._clearLocalRange(fixedStart, length)
   }
 
-  onrange ({ drop, start, length }) {
+  onrange({ drop, start, length }) {
     const has = drop === false
 
     if (drop === true && start < this._remoteContiguousLength) {
@@ -1123,17 +1176,17 @@ class Peer {
     if (drop === false) this._update()
   }
 
-  onreorghint () {
+  onreorghint() {
     // TODO
   }
 
-  _update () {
+  _update() {
     // TODO: if this is in a batch or similar it would be better to defer it
     // we could do that with nextTick/microtick mb? (combined with a property on the session to signal read buffer mb)
     this.replicator.updatePeer(this)
   }
 
-  async _onconflict () {
+  async _onconflict() {
     this.protomux.cork()
     if (this.remoteLength > 0 && this.core.state.fork === this.remoteFork) {
       await this.onrequest({
@@ -1152,7 +1205,7 @@ class Peer {
     this.protomux.uncork()
   }
 
-  _makeRequest (needsUpgrade, priority, minLength) {
+  _makeRequest(needsUpgrade, priority, minLength) {
     if (needsUpgrade === true && this.replicator._shouldUpgrade(this) === false) {
       return null
     }
@@ -1174,9 +1227,10 @@ class Peer {
       block: null,
       hash: null,
       seek: null,
-      upgrade: needsUpgrade === false
-        ? null
-        : { start: this.core.state.length, length: this.remoteLength - this.core.state.length },
+      upgrade:
+        needsUpgrade === false
+          ? null
+          : { start: this.core.state.length, length: this.remoteLength - this.core.state.length },
       // remote manifest check can be removed eventually...
       manifest: this.core.header.manifest === null && this.remoteHasManifest === true,
       priority,
@@ -1185,12 +1239,12 @@ class Peer {
     }
   }
 
-  _requestManifest () {
+  _requestManifest() {
     const req = this._makeRequest(false, 0, 0)
     this._send(req)
   }
 
-  _requestUpgrade (u) {
+  _requestUpgrade(u) {
     const req = this._makeRequest(true, 0, 0)
     if (req === null) return false
 
@@ -1199,7 +1253,7 @@ class Peer {
     return true
   }
 
-  _requestSeek (s) {
+  _requestSeek(s) {
     // if replicator is updating the seeks etc, bail and wait for it to drain
     if (this.replicator._updatesPending > 0) return false
 
@@ -1213,7 +1267,9 @@ class Peer {
       // We need an upgrade for the seek, if non can be provided, skip
       if (req === null) return false
 
-      req.seek = this.remoteSupportsSeeks ? { bytes: s.seeker.bytes, padding: s.seeker.padding } : null
+      req.seek = this.remoteSupportsSeeks
+        ? { bytes: s.seeker.bytes, padding: s.seeker.padding }
+        : null
 
       s.inflight.push(req)
       this._send(req)
@@ -1246,7 +1302,9 @@ class Peer {
       const nodes = flatTree.depth(s.seeker.start + s.seeker.end - 1)
 
       req.hash = { index: 2 * index, nodes }
-      req.seek = this.remoteSupportsSeeks ? { bytes: s.seeker.bytes, padding: s.seeker.padding } : null
+      req.seek = this.remoteSupportsSeeks
+        ? { bytes: s.seeker.bytes, padding: s.seeker.padding }
+        : null
 
       s.inflight.push(req)
       h.inflight.push(req)
@@ -1259,19 +1317,20 @@ class Peer {
     return false
   }
 
-  _canRequest (index) {
+  _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) return true
+    if (index < this.lastUpgradableLength && this.lastUpgradableFork === this.core.state.fork)
+      return true
     if (this.canUpgrade && this.syncsProcessing === 0) return true
     return false
   }
 
-  _remoteHasBlock (index) {
+  _remoteHasBlock(index) {
     return index < this._remoteContiguousLength || this.remoteBitfield.get(index) === true
   }
 
-  _sendBlockRequest (req, b) {
+  _sendBlockRequest(req, b) {
     req.block = { index: b.index, nodes: 0 }
     this.replicator._markInflight(b.index)
 
@@ -1280,7 +1339,7 @@ class Peer {
     this._send(req)
   }
 
-  _requestBlock (b) {
+  _requestBlock(b) {
     const { length, fork } = this.core.state
 
     if (this._remoteHasBlock(b.index) === false || fork !== this.remoteFork) {
@@ -1298,7 +1357,7 @@ class Peer {
     return true
   }
 
-  _requestRangeBlock (index, length) {
+  _requestRangeBlock(index, length) {
     if (this.core.bitfield.get(index) === true || !this._canRequest(index)) return false
 
     const b = this.replicator._blocks.add(index, PRIORITY.NORMAL)
@@ -1323,7 +1382,7 @@ class Peer {
     return true
   }
 
-  _findNext (i) {
+  _findNext(i) {
     if (i < this._remoteContiguousLength) {
       if (this.core.skipBitfield === null) this.replicator._openSkipBitfield()
       i = this.core.skipBitfield.findFirst(false, i)
@@ -1334,7 +1393,7 @@ class Peer {
     return this.missingBlocks.findFirst(true, i)
   }
 
-  _requestRange (r) {
+  _requestRange(r) {
     if (this.syncsProcessing > 0) return false
 
     const { length, fork } = this.core.state
@@ -1357,11 +1416,17 @@ class Peer {
 
     // 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))
+    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
@@ -1393,7 +1458,7 @@ class Peer {
     return false
   }
 
-  _requestForkProof (f) {
+  _requestForkProof(f) {
     if (!this.remoteLength) return
 
     const req = this._makeRequest(false, 0, 0)
@@ -1405,7 +1470,7 @@ class Peer {
     this._send(req)
   }
 
-  _requestForkRange (f) {
+  _requestForkRange(f) {
     if (f.fork !== this.remoteFork || f.batch.want === null) return false
 
     const end = Math.min(f.batch.want.end, this.remoteLength)
@@ -1434,7 +1499,7 @@ class Peer {
     return false
   }
 
-  _maybeWant (start, length = 1) {
+  _maybeWant(start, length = 1) {
     if (start + length <= this.remoteContiguousLength) return
 
     let i = Math.floor(start / DEFAULT_SEGMENT_SIZE)
@@ -1452,12 +1517,12 @@ class Peer {
     }
   }
 
-  isActive () {
+  isActive() {
     if (this.paused || this.removed || this.core.header.frozen) return false
     return true
   }
 
-  async _send (req) {
+  async _send(req) {
     const fork = this.core.state.fork
 
     this.inflight++
@@ -1470,11 +1535,19 @@ class Peer {
 
     try {
       if (req.block !== null && req.fork === fork) {
-        req.block.nodes = await MerkleTree.missingNodes(this.core.state, 2 * req.block.index, this.core.state.length)
+        req.block.nodes = await MerkleTree.missingNodes(
+          this.core.state,
+          2 * req.block.index,
+          this.core.state.length
+        )
         if (req.priority === PRIORITY.CANCELLED) return
       }
       if (req.hash !== null && req.fork === fork && req.hash.nodes === 0) {
-        req.hash.nodes = await MerkleTree.missingNodes(this.core.state, req.hash.index, this.core.state.length)
+        req.hash.nodes = await MerkleTree.missingNodes(
+          this.core.state,
+          req.hash.index,
+          this.core.state.length
+        )
         if (req.priority === PRIORITY.CANCELLED) return
 
         // nodes === 0, we already have it, bail
@@ -1497,12 +1570,15 @@ class Peer {
 module.exports = class Replicator {
   static Peer = Peer // hack to be able to access Peer from outside this module
 
-  constructor (core, {
-    notDownloadingLinger = NOT_DOWNLOADING_SLACK,
-    eagerUpgrade = true,
-    allowFork = true,
-    inflightRange = null
-  } = {}) {
+  constructor(
+    core,
+    {
+      notDownloadingLinger = NOT_DOWNLOADING_SLACK,
+      eagerUpgrade = true,
+      allowFork = true,
+      inflightRange = null
+    } = {}
+  ) {
     this.core = core
     this.eagerUpgrade = eagerUpgrade
     this.allowFork = allowFork
@@ -1557,21 +1633,21 @@ module.exports = class Replicator {
     const self = this
     this._onstreamclose = onstreamclose
 
-    function onstreamclose () {
+    function onstreamclose() {
       self.detachFrom(this.userData)
     }
   }
 
-  updateActivity (inc, session) {
+  updateActivity(inc, session) {
     this.activeSessions += inc
     this.setDownloading(this.activeSessions !== 0, session)
   }
 
-  isDownloading () {
+  isDownloading() {
     return this.downloading || !this._inflight.idle
   }
 
-  setDownloading (downloading) {
+  setDownloading(downloading) {
     clearTimeout(this._downloadingTimer)
 
     if (this.destroyed) return
@@ -1580,11 +1656,16 @@ module.exports = class Replicator {
       return
     }
 
-    this._downloadingTimer = setTimeout(setDownloadingLater, this._notDownloadingLinger, this, downloading)
+    this._downloadingTimer = setTimeout(
+      setDownloadingLater,
+      this._notDownloadingLinger,
+      this,
+      downloading
+    )
     if (this._downloadingTimer.unref) this._downloadingTimer.unref()
   }
 
-  setDownloadingNow (downloading) {
+  setDownloadingNow(downloading) {
     this._downloadingTimer = null
     if (this.downloading === downloading) return
     this.downloading = downloading
@@ -1592,7 +1673,8 @@ module.exports = class Replicator {
 
     for (const peer of this.peers) peer.signalUpgrade()
 
-    if (downloading) { // restart channel if needed...
+    if (downloading) {
+      // restart channel if needed...
       for (const protomux of this._attached) {
         if (!protomux.stream.handshakeHash) continue
         if (protomux.opened({ protocol: 'hypercore/alpha', id: this.core.discoveryKey })) continue
@@ -1605,21 +1687,21 @@ module.exports = class Replicator {
     if (this.ondownloading !== null && downloading) this.ondownloading()
   }
 
-  cork () {
+  cork() {
     for (const peer of this.peers) peer.protomux.cork()
   }
 
-  uncork () {
+  uncork() {
     for (const peer of this.peers) peer.protomux.uncork()
   }
 
   // Called externally when a range of new blocks has been processed/removed
-  onhave (start, length, drop = false) {
+  onhave(start, length, drop = false) {
     for (const peer of this.peers) peer.broadcastRange(start, length, drop)
   }
 
   // Called externally when a truncation upgrade has been processed
-  ontruncate (newLength, truncated) {
+  ontruncate(newLength, truncated) {
     const notify = []
 
     for (const blk of this._blocks) {
@@ -1638,7 +1720,7 @@ module.exports = class Replicator {
   }
 
   // Called externally when a upgrade has been processed
-  onupgrade () {
+  onupgrade() {
     for (const peer of this.peers) peer.signalUpgrade()
     if (this._blocks.isEmpty() === false) this._resolveBlocksLocally()
     if (this._upgrade !== null) this._resolveUpgradeRequest(null)
@@ -1648,7 +1730,7 @@ module.exports = class Replicator {
   }
 
   // Called externally when a conflict has been detected and verified
-  async onconflict () {
+  async onconflict() {
     const all = []
     for (const peer of this.peers) {
       all.push(peer._onconflict())
@@ -1656,7 +1738,7 @@ module.exports = class Replicator {
     await Promise.allSettled(all)
   }
 
-  async applyPendingReorg () {
+  async applyPendingReorg() {
     if (this._applyingReorg !== null) {
       await this._applyingReorg
       return true
@@ -1673,7 +1755,7 @@ module.exports = class Replicator {
     return false
   }
 
-  addUpgrade (session) {
+  addUpgrade(session) {
     if (this._upgrade !== null) {
       const ref = this._upgrade.attach(session)
       this._checkUpgradeIfAvailable()
@@ -1687,7 +1769,7 @@ module.exports = class Replicator {
     return ref
   }
 
-  addBlock (session, index) {
+  addBlock(session, index) {
     const b = this._blocks.add(index, PRIORITY.HIGH)
     const ref = b.attach(session)
 
@@ -1697,7 +1779,7 @@ module.exports = class Replicator {
     return ref
   }
 
-  addSeek (session, seeker) {
+  addSeek(session, seeker) {
     const s = new SeekRequest(this, this._seeks, seeker)
     const ref = s.attach(session)
 
@@ -1707,8 +1789,19 @@ module.exports = class Replicator {
     return ref
   }
 
-  addRange (session, { start = 0, end = -1, length = toLength(start, end), blocks = null, linear = false, ifAvailable = false } = {}) {
-    if (blocks !== null) { // if using blocks, start, end just acts as frames around the blocks array
+  addRange(
+    session,
+    {
+      start = 0,
+      end = -1,
+      length = toLength(start, end),
+      blocks = null,
+      linear = false,
+      ifAvailable = false
+    } = {}
+  ) {
+    if (blocks !== null) {
+      // if using blocks, start, end just acts as frames around the blocks array
       start = 0
       end = length = blocks.length
     }
@@ -1741,11 +1834,11 @@ module.exports = class Replicator {
     return ref
   }
 
-  cancel (ref) {
+  cancel(ref) {
     ref.context.detach(ref, null)
   }
 
-  static clearRequests (session, err) {
+  static clearRequests(session, err) {
     if (session.length === 0) return
 
     const updated = new Set()
@@ -1761,7 +1854,7 @@ module.exports = class Replicator {
     }
   }
 
-  clearRequests (session, err = null) {
+  clearRequests(session, err = null) {
     let cleared = false
     while (session.length > 0) {
       const ref = session[session.length - 1]
@@ -1772,14 +1865,14 @@ module.exports = class Replicator {
     if (cleared) this.updateAll()
   }
 
-  _addUpgradeMaybe () {
+  _addUpgradeMaybe() {
     return this.eagerUpgrade === true ? this._addUpgrade() : this._upgrade
   }
 
   // TODO: this function is OVER called atm, at each updatePeer/updateAll
   // instead its more efficient to only call it when the conditions in here change - ie on sync/add/remove peer
   // Do this when we have more tests.
-  _checkUpgradeIfAvailable () {
+  _checkUpgradeIfAvailable() {
     if (this._ifAvailable > 0 && this.peers.length < MAX_PEERS_UPGRADE) return
     if (this._upgrade === null || this._upgrade.refs.length === 0) return
     if (this._hadPeers === false && this.findingPeers > 0) return
@@ -1795,11 +1888,13 @@ 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) continue
+      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) return
+      if (peer.lengthAcked !== this.core.state.length && peer.remoteFork === this.core.state.fork)
+        return
       if (peer.remoteCanUpgrade === true) return
     }
 
@@ -1825,7 +1920,7 @@ module.exports = class Replicator {
     u.resolve(false)
   }
 
-  _addUpgrade () {
+  _addUpgrade() {
     if (this._upgrade !== null) return this._upgrade
 
     // TODO: needs a reorg: true/false flag to indicate if the user requested a reorg
@@ -1834,7 +1929,7 @@ module.exports = class Replicator {
     return this._upgrade
   }
 
-  _addReorg (fork, peer) {
+  _addReorg(fork, peer) {
     if (this.allowFork === false) return null
 
     // TODO: eager gc old reorgs from the same peer
@@ -1864,31 +1959,37 @@ module.exports = class Replicator {
     return f
   }
 
-  _shouldUpgrade (peer) {
+  _shouldUpgrade(peer) {
     if (this._upgrade !== null && this._upgrade.inflight.length > 0) return false
-    return peer.remoteCanUpgrade === true &&
+    return (
+      peer.remoteCanUpgrade === true &&
       peer.remoteLength > this.core.state.length &&
       peer.lengthAcked === this.core.state.length
+    )
   }
 
-  _autoUpgrade (peer) {
-    return this._upgrade !== null && peer.remoteFork === this.core.state.fork && this._shouldUpgrade(peer)
+  _autoUpgrade(peer) {
+    return (
+      this._upgrade !== null &&
+      peer.remoteFork === this.core.state.fork &&
+      this._shouldUpgrade(peer)
+    )
   }
 
-  _addPeer (peer) {
+  _addPeer(peer) {
     this._hadPeers = true
     this.peers.push(peer)
     this.updatePeer(peer)
     this._onpeerupdate(true, peer)
   }
 
-  _requestDone (id, roundtrip) {
+  _requestDone(id, roundtrip) {
     this._inflight.remove(id, roundtrip)
     if (this.isDownloading() === true) return
     for (const peer of this.peers) peer.signalUpgrade()
   }
 
-  _removePeer (peer) {
+  _removePeer(peer) {
     this.peers.splice(this.peers.indexOf(peer), 1)
 
     if (this._manifestPeer === peer) this._manifestPeer = null
@@ -1903,20 +2004,20 @@ module.exports = class Replicator {
     this.updateAll()
   }
 
-  _queueBlock (b) {
+  _queueBlock(b) {
     if (b.inflight.length > 0 || b.queued === true) return
     b.queued = true
     this._queued.push(b)
   }
 
-  _resolveHashLocally (peer, req) {
+  _resolveHashLocally(peer, req) {
     this._requestDone(req.id, false)
     this._resolveBlockRequest(this._hashes, req.hash.index / 2, null, req)
     this.updatePeer(peer)
   }
 
   // Runs in the background - not allowed to throw
-  async _resolveBlocksLocally () {
+  async _resolveBlocksLocally() {
     // TODO: check if fork compat etc. Requires that we pass down truncation info
 
     const clear = []
@@ -1941,7 +2042,7 @@ module.exports = class Replicator {
     }
   }
 
-  async _resolveLocalBlock (b, reader, resolved) {
+  async _resolveLocalBlock(b, reader, resolved) {
     try {
       b.resolve(await reader.getBlock(b.index))
     } catch (err) {
@@ -1952,7 +2053,7 @@ module.exports = class Replicator {
     resolved.push(b)
   }
 
-  _resolveBlockRequest (tracker, index, value, req) {
+  _resolveBlockRequest(tracker, index, value, req) {
     const b = tracker.remove(index)
     if (b === null) return false
 
@@ -1962,7 +2063,8 @@ module.exports = class Replicator {
 
     b.resolve(value)
 
-    if (b.inflight.length > 0) { // if anything is still inflight, cancel it
+    if (b.inflight.length > 0) {
+      // if anything is still inflight, cancel it
       for (let i = b.inflight.length - 1; i >= 0; i--) {
         const req = b.inflight[i]
         req.peer._cancelRequest(req)
@@ -1972,10 +2074,14 @@ module.exports = class Replicator {
     return true
   }
 
-  _resolveUpgradeRequest (req) {
+  _resolveUpgradeRequest(req) {
     if (req !== null) removeInflight(this._upgrade.inflight, req)
 
-    if (this.core.state.length === this._upgrade.length && this.core.state.fork === this._upgrade.fork) return false
+    if (
+      this.core.state.length === this._upgrade.length &&
+      this.core.state.fork === this._upgrade.fork
+    )
+      return false
 
     const u = this._upgrade
     this._upgrade = null
@@ -1984,7 +2090,7 @@ module.exports = class Replicator {
     return true
   }
 
-  _resolveRangeRequest (req, index) {
+  _resolveRangeRequest(req, index) {
     const head = this._ranges.pop()
 
     if (index < this._ranges.length) this._ranges[index] = head
@@ -1992,7 +2098,7 @@ module.exports = class Replicator {
     req.resolve(true)
   }
 
-  _clearInflightBlock (tracker, req) {
+  _clearInflightBlock(tracker, req) {
     const isBlock = tracker === this._blocks
     const index = isBlock === true ? req.block.index : req.hash.index / 2
     const b = tracker.get(index)
@@ -2011,25 +2117,25 @@ module.exports = class Replicator {
     b.gc()
   }
 
-  _clearInflightUpgrade (req) {
+  _clearInflightUpgrade(req) {
     if (removeInflight(this._upgrade.inflight, req) === false) return
     this._upgrade.gc()
   }
 
-  _clearInflightSeeks (req) {
+  _clearInflightSeeks(req) {
     for (const s of this._seeks) {
       if (removeInflight(s.inflight, req) === false) continue
       s.gc()
     }
   }
 
-  _clearInflightReorgs (req) {
+  _clearInflightReorgs(req) {
     for (const r of this._reorgs) {
       removeInflight(r.inflight, req)
     }
   }
 
-  _clearOldReorgs (fork) {
+  _clearOldReorgs(fork) {
     for (let i = 0; i < this._reorgs.length; i++) {
       const f = this._reorgs[i]
       if (f.fork >= fork) continue
@@ -2040,7 +2146,7 @@ module.exports = class Replicator {
   }
 
   // "slow" updates here - async but not allowed to ever throw
-  async _updateNonPrimary (updateAll) {
+  async _updateNonPrimary(updateAll) {
     // Check if running, if so skip it and the running one will issue another update for us (debounce)
     while (++this._updatesPending === 1) {
       let len = Math.min(MAX_RANGES, this._ranges.length)
@@ -2089,7 +2195,7 @@ module.exports = class Replicator {
     if (this._inflight.idle || updateAll) this.updateAll()
   }
 
-  _maybeResolveIfAvailableRanges () {
+  _maybeResolveIfAvailableRanges() {
     if (this._ifAvailable > 0 || !this._inflight.idle || !this._ranges.length) return
 
     for (let i = 0; i < this.peers.length; i++) {
@@ -2105,7 +2211,7 @@ module.exports = class Replicator {
     }
   }
 
-  _clearRequest (peer, req) {
+  _clearRequest(peer, req) {
     if (req.block !== null) {
       this._clearInflightBlock(this._blocks, req)
       this._unmarkInflight(req.block.index)
@@ -2128,7 +2234,7 @@ module.exports = class Replicator {
     }
   }
 
-  _onnodata (peer, req, reason) {
+  _onnodata(peer, req, reason) {
     if (reason === INVALID_REQUEST) {
       peer.stats.backoffs++
       this.stats.backoffs++
@@ -2142,7 +2248,7 @@ module.exports = class Replicator {
     this.updateAll()
   }
 
-  _openSkipBitfield () {
+  _openSkipBitfield() {
     // technically the skip bitfield gets bits cleared if .clear() is called
     // also which might be in inflight also, but that just results in that section being overcalled shortly
     // worst case, so ok for now
@@ -2154,7 +2260,7 @@ module.exports = class Replicator {
     }
   }
 
-  _markProcessing (index) {
+  _markProcessing(index) {
     const b = this._blocks.get(index)
     if (b) {
       b.processing = true
@@ -2165,7 +2271,7 @@ module.exports = class Replicator {
     if (h) h.processing = true
   }
 
-  _markProcessed (index) {
+  _markProcessed(index) {
     const b = this._blocks.get(index)
     if (b) return b.processed()
 
@@ -2173,22 +2279,23 @@ module.exports = class Replicator {
     if (h) h.processed()
   }
 
-  _markInflight (index) {
+  _markInflight(index) {
     if (this.core.skipBitfield !== null) this.core.skipBitfield.set(index, true)
     for (const peer of this.peers) peer._markInflight(index)
   }
 
-  _unmarkInflight (index) {
-    if (this.core.skipBitfield !== null) this.core.skipBitfield.set(index, this.core.bitfield.get(index))
+  _unmarkInflight(index) {
+    if (this.core.skipBitfield !== null)
+      this.core.skipBitfield.set(index, this.core.bitfield.get(index))
     for (const peer of this.peers) peer._resetMissingBlock(index)
   }
 
-  fullyDownloaded () {
+  fullyDownloaded() {
     if (!this.core.state.length) return false
     return this.core.state.length === this.core.header.hints.contiguousLength
   }
 
-  _ondata (peer, req, data) {
+  _ondata(peer, req, data) {
     req.elapsed = Date.now() - req.timestamp
     if (data.block !== null) {
       this._resolveBlockRequest(this._blocks, data.block.index, data.block.value, req)
@@ -2215,16 +2322,17 @@ module.exports = class Replicator {
       this._manifestPeer = null
     }
 
-    if (this._seeks.length > 0 || this._ranges.length > 0) this._updateNonPrimary(this._seeks.length > 0)
+    if (this._seeks.length > 0 || this._ranges.length > 0)
+      this._updateNonPrimary(this._seeks.length > 0)
     this.updatePeer(peer)
   }
 
-  _onwant (peer, start, length) {
+  _onwant(peer, start, length) {
     if (!peer.isActive()) return
 
     const contig = Math.min(this.core.state.length, this.core.header.hints.contiguousLength)
 
-    if (start + length < contig || (this.core.state.length === contig)) {
+    if (start + length < contig || this.core.state.length === contig) {
       peer.wireRange.send({
         drop: false,
         start: 0,
@@ -2246,8 +2354,8 @@ module.exports = class Replicator {
     peer.protomux.uncork()
   }
 
-  async _onreorgdata (peer, req, data) {
-    const newBatch = data.upgrade && await this.core.verifyReorg(data)
+  async _onreorgdata(peer, req, data) {
+    const newBatch = data.upgrade && (await this.core.verifyReorg(data))
     const f = this._addReorg(data.fork, peer)
 
     if (f === null) {
@@ -2276,7 +2384,7 @@ module.exports = class Replicator {
   }
 
   // Never throws, allowed to run in the background
-  async _applyReorg (f) {
+  async _applyReorg(f) {
     // TODO: more optimal here to check if potentially a better reorg
     // is available, ie higher fork, and request that one first.
     // This will request that one after this finishes, which is fine, but we
@@ -2311,16 +2419,20 @@ module.exports = class Replicator {
     this.updateAll()
   }
 
-  _maybeUpdate () {
+  _maybeUpdate() {
     return this._upgrade !== null && this._upgrade.inflight.length === 0
   }
 
-  _maybeRequestManifest () {
+  _maybeRequestManifest() {
     return this.core.header.manifest === null && this._manifestPeer === null
   }
 
-  _updateFork (peer) {
-    if (this._applyingReorg !== null || this.allowFork === false || peer.remoteFork <= this.core.state.fork) {
+  _updateFork(peer) {
+    if (
+      this._applyingReorg !== null ||
+      this.allowFork === false ||
+      peer.remoteFork <= this.core.state.fork
+    ) {
       return false
     }
 
@@ -2334,7 +2446,7 @@ module.exports = class Replicator {
     return false
   }
 
-  _updateHotswap (peer) {
+  _updateHotswap(peer) {
     const maxHotswaps = peer.getMaxHotswapInflight()
     if (!peer.isActive() || peer.inflight >= maxHotswaps) return
 
@@ -2346,13 +2458,17 @@ module.exports = class Replicator {
     }
   }
 
-  _updatePeer (peer) {
+  _updatePeer(peer) {
     if (!peer.isActive() || peer.inflight >= peer.getMaxInflight() || !peer.remoteUploading) {
       return false
     }
 
     // Eagerly request the manifest even if the remote length is 0. If not 0 we'll get as part of the upgrade request...
-    if (this._maybeRequestManifest() === true && peer.remoteLength === 0 && peer.remoteHasManifest === true) {
+    if (
+      this._maybeRequestManifest() === true &&
+      peer.remoteLength === 0 &&
+      peer.remoteHasManifest === true
+    ) {
       this._manifestPeer = peer
       peer._requestManifest()
     }
@@ -2378,7 +2494,7 @@ module.exports = class Replicator {
     return false
   }
 
-  _updatePeerNonPrimary (peer) {
+  _updatePeerNonPrimary(peer) {
     if (!peer.isActive() || peer.inflight >= peer.getMaxInflight() || !peer.remoteUploading) {
       return false
     }
@@ -2408,7 +2524,7 @@ module.exports = class Replicator {
     return false
   }
 
-  updatePeer (peer) {
+  updatePeer(peer) {
     // Quick shortcut to wait for flushing reorgs - not needed but less waisted requests
     if (this._applyingReorg !== null) return
 
@@ -2423,7 +2539,7 @@ module.exports = class Replicator {
     this._maybeResolveIfAvailableRanges()
   }
 
-  updateAll () {
+  updateAll() {
     // Quick shortcut to wait for flushing reorgs - not needed but less waisted requests
     if (this._applyingReorg !== null) return
 
@@ -2451,15 +2567,15 @@ module.exports = class Replicator {
     this._maybeResolveIfAvailableRanges()
   }
 
-  onpeerdestroy () {
+  onpeerdestroy() {
     if (--this._active === 0) this.core.checkIfIdle()
   }
 
-  attached (protomux) {
+  attached(protomux) {
     return this._attached.has(protomux)
   }
 
-  attachTo (protomux) {
+  attachTo(protomux) {
     if (this.core.closed) return
 
     const makePeer = this._makePeer.bind(this, protomux)
@@ -2483,18 +2599,18 @@ module.exports = class Replicator {
     })
   }
 
-  detachFrom (protomux) {
+  detachFrom(protomux) {
     if (this._attached.delete(protomux)) {
       protomux.stream.removeListener('close', this._onstreamclose)
       protomux.unpair({ protocol: 'hypercore/alpha', id: this.core.discoveryKey })
     }
   }
 
-  idle () {
+  idle() {
     return this.peers.length === 0 && this._active === 0
   }
 
-  close () {
+  close() {
     const waiting = []
 
     for (const peer of this.peers) {
@@ -2505,7 +2621,7 @@ module.exports = class Replicator {
     return Promise.all(waiting)
   }
 
-  destroy () {
+  destroy() {
     if (this.destroyed) return
     this.destroyed = true
 
@@ -2525,9 +2641,10 @@ module.exports = class Replicator {
     }
   }
 
-  _makePeer (protomux) {
+  _makePeer(protomux) {
     const replicator = this
-    if (protomux.opened({ protocol: 'hypercore/alpha', id: this.core.discoveryKey })) return onnochannel()
+    if (protomux.opened({ protocol: 'hypercore/alpha', id: this.core.discoveryKey }))
+      return onnochannel()
 
     const channel = protomux.createChannel({
       userData: null,
@@ -2565,12 +2682,12 @@ module.exports = class Replicator {
 
     return true
 
-    function onnochannel () {
+    function onnochannel() {
       return false
     }
   }
 
-  _onpeerupdate (added, peer) {
+  _onpeerupdate(added, peer) {
     const name = added ? 'peer-add' : 'peer-remove'
     const sessions = this.core.monitors
 
@@ -2585,7 +2702,7 @@ module.exports = class Replicator {
     }
   }
 
-  _ondownload (index, byteLength, from, req) {
+  _ondownload(index, byteLength, from, req) {
     const sessions = this.core.monitors
 
     for (let i = sessions.length - 1; i >= 0; i--) {
@@ -2594,7 +2711,7 @@ module.exports = class Replicator {
     }
   }
 
-  _onupload (index, byteLength, from) {
+  _onupload(index, byteLength, from) {
     const sessions = this.core.monitors
 
     for (let i = sessions.length - 1; i >= 0; i--) {
@@ -2603,7 +2720,7 @@ module.exports = class Replicator {
     }
   }
 
-  _oninvaliddata (err, req, res, from) {
+  _oninvaliddata(err, req, res, from) {
     const sessions = this.core.monitors
 
     this.stats.invalidData++
@@ -2613,7 +2730,7 @@ module.exports = class Replicator {
     }
   }
 
-  _oninvalidrequest (err, req, from) {
+  _oninvalidrequest(err, req, from) {
     const sessions = this.core.monitors
 
     from.stats.invalidRequests++
@@ -2624,21 +2741,22 @@ module.exports = class Replicator {
   }
 }
 
-function matchingRequest (req, data) {
-  if (data.block !== null && (req.block === null || req.block.index !== data.block.index)) return false
+function matchingRequest(req, data) {
+  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
   return req.fork === data.fork
 }
 
-function removeHotswap (block) {
+function removeHotswap(block) {
   if (block.hotswap === null) return false
   block.hotswap.ref.remove(block)
   return true
 }
 
-function removeInflight (inf, req) {
+function removeInflight(inf, req) {
   const i = inf.indexOf(req)
   if (i === -1) return false
   if (i < inf.length - 1) inf[i] = inf.pop()
@@ -2646,11 +2764,11 @@ function removeInflight (inf, req) {
   return true
 }
 
-function toLength (start, end) {
-  return end === -1 ? -1 : (end < start ? 0 : end - start)
+function toLength(start, end) {
+  return end === -1 ? -1 : end < start ? 0 : end - start
 }
 
-function clampRange (core, r) {
+function clampRange(core, r) {
   if (r.blocks === null) {
     const start = core.bitfield.firstUnset(r.start)
 
@@ -2670,111 +2788,111 @@ function clampRange (core, r) {
   }
 }
 
-function onrequesttimeout (req) {
+function onrequesttimeout(req) {
   if (req.context) req.context.detach(req, REQUEST_TIMEOUT())
 }
 
-function destroyRequestTimeout (req) {
+function destroyRequestTimeout(req) {
   if (req.timeout !== null) {
     clearTimeout(req.timeout)
     req.timeout = null
   }
 }
 
-function isCriticalError (err) {
+function isCriticalError(err) {
   // TODO: expose .critical or similar on the hypercore errors that are critical (if all not are)
   return err.name === 'HypercoreError'
 }
 
-function onwireopen (m, c) {
+function onwireopen(m, c) {
   return c.userData.onopen(m)
 }
 
-function onwireclose (isRemote, c) {
+function onwireclose(isRemote, c) {
   return c.userData.onclose(isRemote)
 }
 
-function onwiredestroy (c) {
+function onwiredestroy(c) {
   c.userData.replicator.onpeerdestroy()
 }
 
-function onwiredrain (c) {
+function onwiredrain(c) {
   return c.userData.ondrain()
 }
 
-function onwiresync (m, c) {
+function onwiresync(m, c) {
   incrementRx(c.userData.stats.wireSync, c.userData.replicator.stats.wireSync)
   return c.userData.onsync(m)
 }
 
-function onwirerequest (m, c) {
+function onwirerequest(m, c) {
   incrementRx(c.userData.stats.wireRequest, c.userData.replicator.stats.wireRequest)
   return c.userData.onrequest(m)
 }
 
-function onwirecancel (m, c) {
+function onwirecancel(m, c) {
   incrementRx(c.userData.stats.wireCancel, c.userData.replicator.stats.wireCancel)
   return c.userData.oncancel(m)
 }
 
-function onwiredata (m, c) {
+function onwiredata(m, c) {
   incrementRx(c.userData.stats.wireData, c.userData.replicator.stats.wireData)
   return c.userData.ondata(m)
 }
 
-function onwirenodata (m, c) {
+function onwirenodata(m, c) {
   return c.userData.onnodata(m)
 }
 
-function onwirewant (m, c) {
+function onwirewant(m, c) {
   incrementRx(c.userData.stats.wireWant, c.userData.replicator.stats.wireWant)
   return c.userData.onwant(m)
 }
 
-function onwireunwant (m, c) {
+function onwireunwant(m, c) {
   return c.userData.onunwant(m)
 }
 
-function onwirebitfield (m, c) {
+function onwirebitfield(m, c) {
   incrementRx(c.userData.stats.wireBitfield, c.userData.replicator.stats.wireBitfield)
   return c.userData.onbitfield(m)
 }
 
-function onwirerange (m, c) {
+function onwirerange(m, c) {
   incrementRx(c.userData.stats.wireRange, c.userData.replicator.stats.wireRange)
   return c.userData.onrange(m)
 }
 
-function onwireextension (m, c) {
+function onwireextension(m, c) {
   incrementRx(c.userData.stats.wireExtension, c.userData.replicator.stats.wireExtension)
   return c.userData.onextension(m)
 }
 
-function setDownloadingLater (repl, downloading, session) {
+function setDownloadingLater(repl, downloading, session) {
   repl.setDownloadingNow(downloading, session)
 }
 
-function isBlockRequest (req) {
+function isBlockRequest(req) {
   return req !== null && req.block !== null
 }
 
-function isUpgradeRequest (req) {
+function isUpgradeRequest(req) {
   return req !== null && req.upgrade !== null
 }
 
-function incrementTx (stats1, stats2) {
+function incrementTx(stats1, stats2) {
   stats1.tx++
   stats2.tx++
 }
 
-function incrementRx (stats1, stats2) {
+function incrementRx(stats1, stats2) {
   stats1.rx++
   stats2.rx++
 }
 
-function noop () {}
+function noop() {}
 
-function backoff (times) {
+function backoff(times) {
   const sleep = times < 2 ? 200 : times < 5 ? 500 : times < 40 ? 1000 : 5000
-  return new Promise(resolve => setTimeout(resolve, sleep))
+  return new Promise((resolve) => setTimeout(resolve, sleep))
 }