hypercore 11.16.1 → 11.17.0

package/lib/session-state.js

@@ -11,7 +11,7 @@ const Bitfield = require('./bitfield')
 const { MerkleTree, MerkleTreeBatch } = require('./merkle-tree')
 
 module.exports = class SessionState {
-  constructor (core, parent, storage, treeInfo, name) {
+  constructor(core, parent, storage, treeInfo, name) {
     this.core = core
     this.index = this.core.sessionStates.push(this) - 1
 
@@ -35,7 +35,9 @@ module.exports = class SessionState {
     this.prologue = treeInfo.prologue || null
     this.signature = treeInfo.signature || null
 
-    this.snapshotCompatLength = this.isSnapshot() ? Math.min(this.length, this.core.state.length) : -1
+    this.snapshotCompatLength = this.isSnapshot()
+      ? Math.min(this.length, this.core.state.length)
+      : -1
     this.lastTruncation = null
 
     this.active = 0
@@ -46,29 +48,29 @@ module.exports = class SessionState {
     this.ref()
   }
 
-  isSnapshot () {
+  isSnapshot() {
     return this.storage.snapshotted
   }
 
-  isDefault () {
+  isDefault() {
     return this.core.state === this || this.isAtomicDefault()
   }
 
-  isAtomicDefault () {
+  isAtomicDefault() {
     return !!this.storage.atom && !!this.parent && this.parent.isDefault()
   }
 
-  createTreeBatch () {
+  createTreeBatch() {
     return new MerkleTreeBatch(this)
   }
 
-  addSession (s) {
+  addSession(s) {
     if (s._stateIndex !== -1) return
     s._stateIndex = this.sessions.push(s) - 1
     if (s.weak === false) this.core.activeSessions++
   }
 
-  removeSession (s) {
+  removeSession(s) {
     if (s._stateIndex === -1) return
     const head = this.sessions.pop()
     if (head !== s) this.sessions[(head._stateIndex = s._stateIndex)] = head
@@ -77,43 +79,43 @@ module.exports = class SessionState {
     this.core.checkIfIdle()
   }
 
-  flushedLength () {
+  flushedLength() {
     if (this.isDefault() || this.isSnapshot()) return this.length
     const deps = this.storage.dependencies
     if (deps.length) return deps[deps.length - 1].length
     return 0
   }
 
-  signedLength () {
+  signedLength() {
     const l = Math.min(this.flushedLength(), this.core.state.length)
     return this.isSnapshot() && l > this.snapshotCompatLength ? this.snapshotCompatLength : l
   }
 
-  unref () {
+  unref() {
     if (--this.active > 0) return
     this.close().catch(noop) // technically async, but only for the last db session
   }
 
-  ref () {
+  ref() {
     this.active++
     return this
   }
 
-  hash () {
+  hash() {
     return MerkleTree.hash(this)
   }
 
-  setRoots (roots) {
+  setRoots(roots) {
     this.roots = roots
     this.length = MerkleTree.span(roots) / 2
     this.byteLength = MerkleTree.size(roots)
   }
 
-  get encryptionFork () {
+  get encryptionFork() {
     return this.core.header.tree.fork
   }
 
-  async updateSnapshotStorage (storage) {
+  async updateSnapshotStorage(storage) {
     if (!this.atomized || !this.atomized.flushing) return this.treeInfo()
     await this.atomized.flushed()
 
@@ -143,7 +145,14 @@ module.exports = class SessionState {
     // dbl check if we are hitting an regression from earler
     for (const root of roots) {
       if (root === null) {
-        throw new Error('Bad snapshot from atomized session, id = ' + this.core.id + ' length = ' + length + ' fork = ' + fork)
+        throw new Error(
+          'Bad snapshot from atomized session, id = ' +
+            this.core.id +
+            ' length = ' +
+            length +
+            ' fork = ' +
+            fork
+        )
       }
     }
 
@@ -156,7 +165,7 @@ module.exports = class SessionState {
     }
   }
 
-  treeInfo () {
+  treeInfo() {
     return {
       fork: this.fork,
       roots: this.roots.slice(),
@@ -166,7 +175,7 @@ module.exports = class SessionState {
     }
   }
 
-  async close () {
+  async close() {
     if (this.index === -1) return
 
     this.active = 0
@@ -188,45 +197,39 @@ module.exports = class SessionState {
     return closing
   }
 
-  async snapshot () {
+  async snapshot() {
     const storage = this.storage.snapshot()
     const treeInfo = await this.updateSnapshotStorage(storage)
 
-    const s = new SessionState(
-      this.core,
-      null,
-      storage,
-      treeInfo,
-      this.name
-    )
+    const s = new SessionState(this.core, null, storage, treeInfo, this.name)
 
     return s
   }
 
-  updateDependency (tx, length) {
+  updateDependency(tx, length) {
     const dependency = updateDependency(this, length, false)
     if (dependency) tx.setDependency(dependency)
     return dependency
   }
 
-  _clearActiveBatch () {
+  _clearActiveBatch() {
     this._activeTx = null
   }
 
-  createWriteBatch () {
+  createWriteBatch() {
     assert(!this._activeTx && !this.storage.snapshotted)
 
     this._activeTx = this.storage.write()
     return this._activeTx
   }
 
-  _unlock () {
+  _unlock() {
     this._clearActiveBatch()
     this.mutex.unlock()
     this.core.checkIfIdle()
   }
 
-  async flush () {
+  async flush() {
     const tx = this._activeTx
     this._activeTx = null
 
@@ -240,11 +243,11 @@ module.exports = class SessionState {
     return true
   }
 
-  _precommit () {
+  _precommit() {
     this.commiting = true
   }
 
-  async _commit () {
+  async _commit() {
     await this.mutex.lock()
 
     try {
@@ -258,7 +261,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _oncommit (src, bitfield) {
+  async _oncommit(src, bitfield) {
     await this.mutex.lock()
 
     try {
@@ -303,7 +306,7 @@ module.exports = class SessionState {
     }
   }
 
-  async setUserData (key, value) {
+  async setUserData(key, value) {
     await this.mutex.lock()
 
     try {
@@ -316,7 +319,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _verifyBlock (batch, bitfield, value, manifest, from) {
+  async _verifyBlock(batch, bitfield, value, manifest, from) {
     await this.mutex.lock()
 
     try {
@@ -366,7 +369,7 @@ module.exports = class SessionState {
     return true
   }
 
-  async truncate (length, fork, { signature, keyPair } = {}) {
+  async truncate(length, fork, { signature, keyPair } = {}) {
     if (!keyPair && this.isDefault()) keyPair = this.core.header.keyPair
 
     await this.mutex.lock()
@@ -376,7 +379,10 @@ module.exports = class SessionState {
         throw INVALID_OPERATION('Truncation breaks prologue', this.core.discoveryKey)
       }
       if (length > this.length) {
-        throw INVALID_OPERATION('Not a truncation, ' + length + ' must be less or equal to ' + this.length, this.core.discoveryKey)
+        throw INVALID_OPERATION(
+          'Not a truncation, ' + length + ' must be less or equal to ' + this.length,
+          this.core.discoveryKey
+        )
       }
 
       const batch = this.createTreeBatch()
@@ -393,7 +399,11 @@ module.exports = class SessionState {
       const { dependency, tree, roots } = await this._truncate(tx, batch)
 
       for (const sessionState of this.core.sessionStates) {
-        if (sessionState.isSnapshot() && sessionState.name === this.name && length < sessionState.snapshotCompatLength) {
+        if (
+          sessionState.isSnapshot() &&
+          sessionState.name === this.name &&
+          length < sessionState.snapshotCompatLength
+        ) {
           sessionState.snapshotCompatLength = length
         }
       }
@@ -414,7 +424,7 @@ module.exports = class SessionState {
     }
   }
 
-  async reorg (batch) {
+  async reorg(batch) {
     await this.mutex.lock()
 
     const storage = this.createWriteBatch()
@@ -440,7 +450,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _truncate (storage, batch) {
+  async _truncate(storage, batch) {
     storage.deleteBlockRange(batch.ancestors, batch.treeLength)
 
     assert(batch.commitable(), 'Batch must be commitable')
@@ -470,7 +480,7 @@ module.exports = class SessionState {
     return { dependency, tree, roots: batch.roots }
   }
 
-  async clear (start, end, cleared) {
+  async clear(start, end, cleared) {
     await this.mutex.lock()
 
     try {
@@ -484,8 +494,8 @@ module.exports = class SessionState {
 
         const [left, right] = flat.spans(b)
         const s = left / 2
-        const e = (right / 2) + 1
-        const has = (s <= start && e <= end) ? false : this.core.bitfield.hasSet(s, e - s)
+        const e = right / 2 + 1
+        const has = s <= start && e <= end ? false : this.core.bitfield.hasSet(s, e - s)
         if (has) break
 
         tx.deleteTreeNode(a)
@@ -499,7 +509,7 @@ module.exports = class SessionState {
         }
       }
 
-      if ((end - start) === 1) tx.deleteBlock(start)
+      if (end - start === 1) tx.deleteBlock(start)
       else tx.deleteBlockRange(start, end)
 
       const dependency = start < this.flushedLength() ? updateDependency(this, start, true) : null
@@ -520,13 +530,13 @@ module.exports = class SessionState {
     }
   }
 
-  async append (values, { signature, keyPair, preappend, maxLength = -1 } = {}) {
+  async append(values, { signature, keyPair, preappend, maxLength = -1 } = {}) {
     if (!keyPair && this.isDefault()) keyPair = this.core.header.keyPair
 
     await this.mutex.lock()
 
     try {
-      if (maxLength >= 0 && (this.length + values.length) > maxLength) {
+      if (maxLength >= 0 && this.length + values.length > maxLength) {
         return { length: this.length, byteLength: this.byteLength }
       }
 
@@ -597,7 +607,7 @@ module.exports = class SessionState {
     }
   }
 
-  onappend (tree, bitfield, flushed) {
+  onappend(tree, bitfield, flushed) {
     if (!flushed) this._updateBitfield(bitfield)
     else if (this.isDefault()) this.core.onappend(tree, bitfield)
 
@@ -606,7 +616,7 @@ module.exports = class SessionState {
     }
   }
 
-  ontruncate (tree, to, from, flushed) {
+  ontruncate(tree, to, from, flushed) {
     const bitfield = { start: to, length: from - to, drop: true }
 
     this.lastTruncation = { from, to }
@@ -615,7 +625,11 @@ module.exports = class SessionState {
     else if (this.isDefault()) this.core.ontruncate(tree, bitfield)
 
     for (const sessionState of this.core.sessionStates) {
-      if (sessionState.isSnapshot() && sessionState.name === this.name && to < sessionState.snapshotCompatLength) {
+      if (
+        sessionState.isSnapshot() &&
+        sessionState.name === this.name &&
+        to < sessionState.snapshotCompatLength
+      ) {
         sessionState.snapshotCompatLength = to
       }
     }
@@ -625,7 +639,7 @@ module.exports = class SessionState {
     }
   }
 
-  _updateBitfield (bitfield, flushed) {
+  _updateBitfield(bitfield, flushed) {
     if (!bitfield) return
 
     const p = this._pendingBitfield
@@ -633,7 +647,7 @@ module.exports = class SessionState {
 
     if (b.drop) {
       // truncation must be from end
-      if (p && (b.start + b.length !== p.start + p.appends)) {
+      if (p && b.start + b.length !== p.start + p.appends) {
         throw INVALID_OPERATION('Atomic truncations must be contiguous', this.core.discoveryKey)
       }
 
@@ -664,7 +678,7 @@ module.exports = class SessionState {
     p.appends += b.length
   }
 
-  async catchup (length) {
+  async catchup(length) {
     assert(!this.isDefault(), 'Cannot catchup signed state') // TODO: make this check better
 
     await this.mutex.lock()
@@ -695,7 +709,11 @@ module.exports = class SessionState {
       const truncating = sharedLength < origLength
 
       for (const node of roots) {
-        if (node === null) throw INVALID_OPERATION('Invalid catchup length, tree nodes not available', this.core.discoveryKey)
+        if (node === null)
+          throw INVALID_OPERATION(
+            'Invalid catchup length, tree nodes not available',
+            this.core.discoveryKey
+          )
       }
 
       const fork = truncating ? this.fork + 1 : this.fork
@@ -736,7 +754,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _overwrite (source, fork, length, treeLength, signature) {
+  async _overwrite(source, fork, length, treeLength, signature) {
     const blockPromises = []
     const treePromises = []
     const rootPromises = []
@@ -771,7 +789,10 @@ module.exports = class SessionState {
       batch.length = length
 
       if (!this.core.verifier.verify(batch, signature)) {
-        throw INVALID_SIGNATURE('Signature is not valid over committed tree', this.core.discoveryKey)
+        throw INVALID_SIGNATURE(
+          'Signature is not valid over committed tree',
+          this.core.discoveryKey
+        )
       }
     }
 
@@ -848,8 +869,11 @@ module.exports = class SessionState {
     return { tree, flushed }
   }
 
-  async commit (state, { signature, keyPair, length = state.length, treeLength = -1 } = {}) {
-    assert(this.isDefault() || (this.parent && this.parent.isDefault()), 'Can only commit into default state')
+  async commit(state, { signature, keyPair, length = state.length, treeLength = -1 } = {}) {
+    assert(
+      this.isDefault() || (this.parent && this.parent.isDefault()),
+      'Can only commit into default state'
+    )
 
     let srcLocked = false
     await this.mutex.lock()
@@ -870,7 +894,13 @@ module.exports = class SessionState {
         signature = this.core.verifier.sign(batch, keyPair)
       }
 
-      const { tree, flushed } = await this._overwrite(state, this.fork, length, treeLength, signature)
+      const { tree, flushed } = await this._overwrite(
+        state,
+        this.fork,
+        length,
+        treeLength,
+        signature
+      )
 
       // gc blocks from source
       if (treeLength < length) {
@@ -904,7 +934,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _getTreeHeadAt (length) {
+  async _getTreeHeadAt(length) {
     if (length === null) return this.treeInfo()
 
     const head = getDefaultTree()
@@ -922,7 +952,7 @@ module.exports = class SessionState {
     return head
   }
 
-  _moveToCore (core, truncated, appended) {
+  _moveToCore(core, truncated, appended) {
     const head = this.core.sessionStates.pop()
     if (head !== this) this.core.sessionStates[(head.index = this.index)] = head
 
@@ -939,7 +969,7 @@ module.exports = class SessionState {
     }
   }
 
-  async moveTo (core, length) {
+  async moveTo(core, length) {
     const state = core.state
 
     await this.mutex.lock()
@@ -961,7 +991,11 @@ module.exports = class SessionState {
         const resumed = await state.storage.resumeSession(this.name)
 
         const truncation = length < this.length ? await truncateAndFlush(this, length) : null
-        const treeInfo = truncation ? truncation.tree : resumed ? null : await state._getTreeHeadAt(this.length)
+        const treeInfo = truncation
+          ? truncation.tree
+          : resumed
+            ? null
+            : await state._getTreeHeadAt(this.length)
 
         const fork = truncation ? this.fork + 1 : this.fork
 
@@ -1009,7 +1043,7 @@ module.exports = class SessionState {
     }
   }
 
-  async createSession (name, overwrite, atom) {
+  async createSession(name, overwrite, atom) {
     let storage = null
     let treeInfo = null
 
@@ -1037,7 +1071,10 @@ module.exports = class SessionState {
 
     const head = {
       fork: this.fork,
-      roots: length === this.length ? this.roots.slice() : await MerkleTree.getRootsFromStorage(storage, length),
+      roots:
+        length === this.length
+          ? this.roots.slice()
+          : await MerkleTree.getRootsFromStorage(storage, length),
       length,
       prologue: this.prologue,
       signature: length === this.length ? this.signature : null
@@ -1060,13 +1097,13 @@ module.exports = class SessionState {
   }
 }
 
-function noop () {}
+function noop() {}
 
-function getBitfieldPage (index) {
+function getBitfieldPage(index) {
   return Math.floor(index / Bitfield.BITS_PER_PAGE)
 }
 
-function fillBitfieldPage (page, start, end, pageIndex, value) {
+function fillBitfieldPage(page, start, end, pageIndex, value) {
   const offset = pageIndex * Bitfield.BITS_PER_PAGE
   const max = offset + Bitfield.BITS_PER_PAGE
 
@@ -1080,7 +1117,7 @@ function fillBitfieldPage (page, start, end, pageIndex, value) {
   return index
 }
 
-async function storeBitfieldRange (storage, tx, from, to, value) {
+async function storeBitfieldRange(storage, tx, from, to, value) {
   if (from >= to) return
 
   const firstPage = getBitfieldPage(from)
@@ -1109,7 +1146,7 @@ async function storeBitfieldRange (storage, tx, from, to, value) {
   }
 }
 
-async function truncateAndFlush (s, length) {
+async function truncateAndFlush(s, length) {
   const batch = s.createTreeBatch()
   await MerkleTree.truncate(s, length, batch, s.fork)
   const tx = s.createWriteBatch()
@@ -1125,7 +1162,7 @@ async function truncateAndFlush (s, length) {
   }
 }
 
-function updateDependency (state, length, truncated) {
+function updateDependency(state, length, truncated) {
   const i = state.storage.findDependencyIndex(length, truncated)
   if (i === -1) return null // skip default state and overlays of default
 
@@ -1135,7 +1172,7 @@ function updateDependency (state, length, truncated) {
   }
 }
 
-function getDefaultTree () {
+function getDefaultTree() {
   return {
     fork: 0,
     length: 0,
@@ -1144,14 +1181,14 @@ function getDefaultTree () {
   }
 }
 
-function getCoreHead (storage) {
+function getCoreHead(storage) {
   const b = storage.read()
   const p = b.getHead()
   b.tryFlush()
   return p
 }
 
-function isRootIndex (index, roots) {
+function isRootIndex(index, roots) {
   for (const node of roots) {
     if (node.index === index) return true
   }

package/lib/streams.js

@@ -1,7 +1,7 @@
 const { Writable, Readable } = require('streamx')
 
 class ReadStream extends Readable {
-  constructor (core, opts = {}) {
+  constructor(core, opts = {}) {
     super()
 
     this.core = core
@@ -13,22 +13,22 @@ class ReadStream extends Readable {
     this.timeout = opts.timeout || core.timeout
   }
 
-  _open (cb) {
+  _open(cb) {
     this._openP().then(cb, cb)
   }
 
-  _read (cb) {
+  _read(cb) {
     this._readP().then(cb, cb)
   }
 
-  async _openP () {
+  async _openP() {
     if (this.end === -1) await this.core.update()
     else await this.core.ready()
     if (this.snapshot && this.end === -1) this.end = this.core.length
   }
 
-  async _readP () {
-    const end = this.live ? -1 : (this.end === -1 ? this.core.length : this.end)
+  async _readP() {
+    const end = this.live ? -1 : this.end === -1 ? this.core.length : this.end
     if (end >= 0 && this.start >= end) {
       this.push(null)
       return
@@ -41,16 +41,16 @@ class ReadStream extends Readable {
 exports.ReadStream = ReadStream
 
 class WriteStream extends Writable {
-  constructor (core) {
+  constructor(core) {
     super()
     this.core = core
   }
 
-  _writev (batch, cb) {
+  _writev(batch, cb) {
     this._writevP(batch).then(cb, cb)
   }
 
-  async _writevP (batch) {
+  async _writevP(batch) {
     await this.core.append(batch)
   }
 }
@@ -58,7 +58,7 @@ class WriteStream extends Writable {
 exports.WriteStream = WriteStream
 
 class ByteStream extends Readable {
-  constructor (core, opts = {}) {
+  constructor(core, opts = {}) {
     super()
 
     this._core = core
@@ -72,22 +72,22 @@ class ByteStream extends Readable {
     this._applyOffset = this._byteOffset > 0
   }
 
-  _open (cb) {
+  _open(cb) {
     this._openp().then(cb, cb)
   }
 
-  _read (cb) {
+  _read(cb) {
     this._readp().then(cb, cb)
   }
 
-  async _openp () {
+  async _openp() {
     if (this._byteLength === -1) {
       await this._core.update()
       this._byteLength = Math.max(this._core.byteLength - this._byteOffset, 0)
     }
   }
 
-  async _readp () {
+  async _readp() {
     let data = null
 
     if (this._byteLength === 0) {
@@ -118,12 +118,12 @@ class ByteStream extends Readable {
     if (this._byteLength === 0) this.push(null)
   }
 
-  _predownload (index) {
+  _predownload(index) {
     if (this._range) this._range.destroy()
     this._range = this._core.download({ start: index, end: index + this._prefetch, linear: true })
   }
 
-  _destroy (cb) {
+  _destroy(cb) {
     if (this._range) this._range.destroy()
     cb(null)
   }