hypercore 11.0.26 → 11.0.28

package/lib/session-state.js

@@ -134,19 +134,32 @@ module.exports = class SessionState {
     rx.tryFlush()
     const [head, auth] = await Promise.all([headPromise, authPromise])
 
+    const fork = head ? head.fork : 0
+    const length = head ? head.length : 0
+
     rx = storage.read()
     const rootPromises = []
-    for (const r of flat.fullRoots(head.length * 2)) {
+    for (const r of flat.fullRoots(length * 2)) {
       rootPromises.push(rx.getTreeNode(r))
     }
 
     rx.tryFlush()
+
+    const roots = await Promise.all(rootPromises)
+
+    // 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)
+      }
+    }
+
     return {
-      fork: head.fork,
-      roots: await Promise.all(rootPromises),
-      length: head.length,
+      fork,
+      roots,
+      length,
       prologue: auth.manifest && auth.manifest.prologue,
-      signature: head.signature
+      signature: head && head.signature
     }
   }
 
@@ -184,6 +197,7 @@ module.exports = class SessionState {
 
   async snapshot () {
     const storage = this.storage.snapshot()
+    const treeInfo = await this.getFlushedTreeInfo(storage)
 
     const s = new SessionState(
       this.core,
@@ -191,7 +205,7 @@ module.exports = class SessionState {
       storage,
       this.blocks,
       this.tree.clone(storage),
-      await this.getFlushedTreeInfo(storage),
+      treeInfo,
       this.name
     )
 
@@ -447,7 +461,7 @@ module.exports = class SessionState {
   async _truncate (storage, batch) {
     storage.deleteBlockRange(batch.ancestors, batch.treeLength)
 
-    if (batch.commitable()) batch.commit(storage)
+    assert(batch.commitable(), 'Batch must be commitable')
 
     const tree = {
       fork: batch.fork,
@@ -456,7 +470,8 @@ module.exports = class SessionState {
       signature: batch.signature
     }
 
-    if (tree) storage.setHead(tree)
+    storage.setHead(tree)
+    batch.commit(storage)
 
     const truncated = batch.length < this.flushedLength()
     const dependency = truncated ? updateDependency(this, batch.length, true) : null
@@ -667,6 +682,10 @@ module.exports = class SessionState {
       const roots = await Promise.all(rootPromises)
       const truncating = sharedLength < origLength
 
+      for (const node of roots) {
+        if (node === null) throw new INVALID_OPERATION('Invalid catchup length, tree nodes not available')
+      }
+
       const fork = truncating ? this.fork + 1 : this.fork
 
       // overwrite it atm, TODO: keep what we can connect to the tree
@@ -706,7 +725,7 @@ module.exports = class SessionState {
     }
   }
 
-  async _overwrite (source, fork, length, treeLength, signature, isDependent, shallow) {
+  async _overwrite (source, fork, length, treeLength, signature) {
     const blockPromises = []
     const treePromises = []
     const rootPromises = []
@@ -717,16 +736,14 @@ module.exports = class SessionState {
       rootPromises.push(rx.getTreeNode(root))
     }
 
-    if (shallow !== true) {
-      for (const index of flat.patch(treeLength * 2, length * 2)) {
-        treePromises.push(rx.getTreeNode(index))
-      }
+    for (const index of flat.patch(treeLength * 2, length * 2)) {
+      treePromises.push(rx.getTreeNode(index))
+    }
 
-      for (let i = treeLength; i < length; i++) {
-        treePromises.push(rx.getTreeNode(i * 2))
-        treePromises.push(rx.getTreeNode(i * 2 + 1))
-        blockPromises.push(rx.getBlock(i))
-      }
+    for (let i = treeLength; i < length; i++) {
+      treePromises.push(rx.getTreeNode(i * 2))
+      treePromises.push(rx.getTreeNode(i * 2 + 1))
+      blockPromises.push(rx.getBlock(i))
     }
 
     rx.tryFlush()
@@ -754,6 +771,9 @@ module.exports = class SessionState {
       tx.deleteBlockRange(treeLength, this.length)
     }
 
+    for (const root of roots) tx.putTreeNode(root)
+
+    // no nodes will be copied in shallow mode
     for (const node of nodes) {
       if (node !== null) tx.putTreeNode(node)
     }
@@ -803,8 +823,6 @@ module.exports = class SessionState {
 
     if (upgraded) tx.setHead(tree)
 
-    const dependency = isDependent ? updateDependency(this, length, true) : null
-
     const flushed = await this.flush()
 
     this.fork = tree.fork
@@ -812,39 +830,10 @@ module.exports = class SessionState {
     this.length = length
     this.signature = signature
 
-    if (dependency) this.storage.updateDependencyLength(dependency.length, true)
-
     return { tree, flushed }
   }
 
-  async overwrite (state, { length = state.tree.length, treeLength = state.flushedLength(), shallow = false } = {}) {
-    assert(!this.isDefault(), 'Cannot overwrite signed state') // TODO: make this check better
-
-    await this.mutex.lock()
-
-    try {
-      const origLength = this.length
-      const fork = treeLength < origLength ? this.fork + 1 : this.fork
-
-      const { tree, flushed } = await this._overwrite(state, fork, length, treeLength, null, state === this.core.state, shallow)
-
-      const bitfield = { start: treeLength, length: tree.length - treeLength, drop: false }
-
-      if (treeLength < origLength) this.ontruncate(tree, treeLength, origLength, flushed)
-      if (treeLength < tree.length) this.onappend(tree, bitfield, flushed)
-
-      return {
-        length: this.length,
-        byteLength: this.byteLength
-      }
-    } finally {
-      this._clearActiveBatch()
-      this.updating = false
-      this.mutex.unlock()
-    }
-  }
-
-  async commit (state, { signature, keyPair, length = state.length, treeLength = state.flushedLength(), overwrite = false } = {}) {
+  async commit (state, { signature, keyPair, length = state.length, treeLength = -1, overwrite = false } = {}) {
     assert(this.isDefault() || (this.parent && this.parent.isDefault()), 'Can only commit into default state')
 
     let srcLocked = false
@@ -854,6 +843,8 @@ module.exports = class SessionState {
       await state.mutex.lock()
       srcLocked = true
 
+      if (treeLength === -1) treeLength = state.flushedLength()
+
       if (!(await this.core._validateCommit(state, treeLength))) return null
       if (this.length > length) return null
 
@@ -864,7 +855,7 @@ module.exports = class SessionState {
         signature = this.core.verifier.sign(batch, keyPair)
       }
 
-      const { tree, flushed } = await this._overwrite(state, this.fork, length, treeLength, signature, false, false)
+      const { tree, flushed } = await this._overwrite(state, this.fork, length, treeLength, signature)
 
       // gc blocks from source
       if (treeLength < length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "11.0.26",
+  "version": "11.0.28",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {