hypercore 11.0.1 → 11.0.2

package/index.js

@@ -207,7 +207,7 @@ class Hypercore extends EventEmitter {
     }
 
     const wait = opts.wait === false ? false : this.wait
-    const writable = opts.writable === false ? false : !this._readonly
+    const writable = opts.writable === undefined ? !this._readonly : opts.writable === true
     const onwait = opts.onwait === undefined ? this.onwait : opts.onwait
     const timeout = opts.timeout === undefined ? this.timeout : opts.timeout
     const weak = opts.weak === undefined ? this.weak : opts.weak
@@ -245,7 +245,6 @@ class Hypercore extends EventEmitter {
 
   _setupSession (parent) {
     if (!this.keyPair) this.keyPair = parent.keyPair
-    this.writable = this._isWritable()
 
     const s = parent.state
 
@@ -341,13 +340,13 @@ class Hypercore extends EventEmitter {
     }
 
     const parent = opts.parent || this.core
+    const checkout = opts.checkout === undefined ? -1 : opts.checkout
 
     if (opts.atom) {
-      this.state = await parent.state.createSession(null, -1, false, opts.atom)
+      this.state = await parent.state.createSession(null, checkout, false, opts.atom)
     } else if (opts.name) {
       // todo: need to make named sessions safe before ready
       // atm we always copy the state in passCapabilities
-      const checkout = opts.checkout === undefined ? -1 : opts.checkout
       const state = this.state
 
       this.state = await parent.state.createSession(opts.name, checkout, !!opts.overwrite, null)
@@ -360,6 +359,8 @@ class Hypercore extends EventEmitter {
       this.state = this.core.state.ref()
     }
 
+    this.writable = this._isWritable()
+
     if (this.snapshotted && this.core) this._updateSnapshot()
 
     this.state.addSession(this)
@@ -404,8 +405,9 @@ class Hypercore extends EventEmitter {
   }
 
   _isWritable () {
-    if (this.draft) return true
-    return !this._readonly && !!(this.keyPair && this.keyPair.secretKey)
+    if (this._readonly) return false
+    if (this.state && !this.state.isDefault()) return true
+    return !!(this.keyPair && this.keyPair.secretKey)
   }
 
   close ({ error } = {}) {

package/lib/copy-prologue.js

@@ -126,7 +126,7 @@ async function flushBatch (prologue, src, dst, batch) {
   }
 
   for (const { key, value } of userData) {
-    tx.setUserData(key, value)
+    tx.putUserData(key, value)
   }
 
   let upgraded = batch.first && !head

package/lib/core.js

@@ -8,7 +8,7 @@ const BlockStore = require('./block-store')
 const BitInterlude = require('./bit-interlude')
 const Bitfield = require('./bitfield')
 const RemoteBitfield = require('./remote-bitfield')
-const { BAD_ARGUMENT, STORAGE_EMPTY, STORAGE_CONFLICT, INVALID_OPERATION, INVALID_SIGNATURE, INVALID_CHECKSUM } = require('hypercore-errors')
+const { BAD_ARGUMENT, STORAGE_EMPTY, STORAGE_CONFLICT, INVALID_SIGNATURE, INVALID_CHECKSUM } = require('hypercore-errors')
 const Verifier = require('./verifier')
 const audit = require('./audit')
 const copyPrologue = require('./copy-prologue')
@@ -374,21 +374,23 @@ module.exports = class Core {
 
   async _validateCommit (state, treeLength) {
     if (this.state.length > state.length) {
-      throw new Error('Invalid commit: partial commit') // TODO: partial commit in the future if possible
+      return false // TODO: partial commit in the future if possible
     }
 
     if (this.state.length > treeLength) {
       for (const root of this.state.roots) {
         const batchRoot = await state.tree.get(root.index)
         if (batchRoot.size !== root.size || !b4a.equals(batchRoot.hash, root.hash)) {
-          throw new Error('Invalid commit: tree conflict')
+          return false
         }
       }
     }
 
     if (this.verifier === null) {
-      throw INVALID_OPERATION('Cannot commit without manifest') // easier to assert than upsert
+      return false // easier to assert than upsert
     }
+
+    return true
   }
 
   _verifyBatchUpgrade (batch, manifest) {

package/lib/multisig.js

@@ -21,7 +21,7 @@ function inflate (data) {
 }
 
 async function partialSignature (core, signer, from, to = core.state.length, signature = core.state.signature) {
-  if (from > core.tree.length) return null
+  if (from > core.state.length) return null
   const nodes = to <= from ? null : await upgradeNodes(core, from, to)
 
   if (signature.byteLength !== 64) signature = c.decode(multiSignature, signature).proofs[0].signature
@@ -35,10 +35,10 @@ async function partialSignature (core, signer, from, to = core.state.length, sig
 }
 
 async function upgradeNodes (core, from, to) {
-  const batch = core.storage.read()
+  const rx = core.state.storage.read()
   const treeBatch = core.state.createTreeBatch()
-  const p = await core.tree.proof(batch, treeBatch, { upgrade: { start: from, length: to - from } })
-  batch.tryFlush()
+  const p = await core.state.tree.proof(rx, treeBatch, { upgrade: { start: from, length: to - from } })
+  rx.tryFlush()
   return (await p.settle()).upgrade.nodes
 }
 

package/lib/session-state.js

@@ -35,6 +35,7 @@ module.exports = class SessionState {
     const deps = this.storage.dependencies
     this.dependencyLength = deps.length ? deps[deps.length - 1].length : Infinity
 
+    if (treeInfo.length < this.dependencyLength) this.dependencyLength = treeInfo.length
     if (treeInfo.roots.length) this.setRoots(treeInfo.roots)
 
     this.snapshotCompatLength = this.isSnapshot() ? this.length : -1
@@ -109,7 +110,8 @@ module.exports = class SessionState {
       fork: this.fork,
       roots: this.roots.slice(),
       length: this.length,
-      prologue: this.prologue
+      prologue: this.prologue,
+      signature: this.signature
     }
   }
 
@@ -144,11 +146,11 @@ module.exports = class SessionState {
     return s
   }
 
-  updateDependency (storage, length) {
+  updateDependency (tx, length) {
     const dependency = updateDependency(this, length)
     if (dependency) {
       this.dependencyLength = dependency.length
-      storage.setDependency(dependency)
+      tx.setDependency(dependency)
     }
 
     return dependency
@@ -202,6 +204,8 @@ module.exports = class SessionState {
   }
 
   async _oncommit (src, bitfield) {
+    const currLength = this.length
+
     this.fork = src.fork
     this.length = src.length
     this.roots = src.roots.slice()
@@ -229,11 +233,16 @@ module.exports = class SessionState {
       this._moveToCore(src.core)
     }
 
-    if (!bitfield || !bitfield.drop) {
-      this.onappend(tree, bitfield, true)
-    } else {
-      this.ontruncate(tree, bitfield.start, bitfield.start + bitfield.length, true)
+    const truncated = (bitfield && bitfield.truncated !== -1)
+      ? bitfield.truncated
+      : src.dependencyLength
+
+    if (truncated < currLength) {
+      this.ontruncate(tree, truncated, currLength, true)
+      if (!bitfield || bitfield.length === 0) return
     }
+
+    this.onappend(tree, bitfield, true)
   }
 
   flushed () {
@@ -511,22 +520,40 @@ module.exports = class SessionState {
   }
 
   _updateBitfield (bitfield, flushed) {
+    if (!bitfield) return
+
     const p = this._pendingBitfield
+    const b = bitfield
 
-    if (p === null) {
-      if (bitfield) this._pendingBitfield = bitfield
+    if (b.drop) {
+      if (p === null) {
+        this._pendingBitfield = { truncated: b.start, start: b.start, length: 0, drop: false }
+        return
+      }
+
+      if (p.drop) {
+        if (p.truncated !== b.start + b.length) throw INVALID_OPERATION('Atomic truncations must be contiguous')
+        p.truncated = b.start
+        return
+      }
+
+      if (b.start < p.start) throw INVALID_OPERATION('Atomic truncations must be contiguous')
+      p.length = b.start - p.start
+
+      if (p.length === 0) this._pendingBitfield = null
       return
     }
 
-    if (p.drop) {
-      const from = bitfield.start + bitfield.length
-      if (!bitfield.drop || p.start !== from) throw INVALID_OPERATION('Atomic truncations must be contiguous')
+    if (p === null) {
+      this._pendingBitfield = { truncated: -1, start: b.start, length: b.length, drop: false }
+      return
+    }
 
-      p.length += bitfield.length
-      p.start = bitfield.start
-    } else {
-      p.length = bitfield.start + bitfield.length - p.start
+    if (b.start !== p.start + p.length) {
+      throw INVALID_OPERATION('Atomic operations must be contiguous')
     }
+
+    p.length += b.length
   }
 
   async _overwrite (source, fork, length, treeLength, signature, isDependent, shallow) {
@@ -670,7 +697,7 @@ module.exports = class SessionState {
       await state.mutex.lock()
       srcLocked = true
 
-      await this.core._validateCommit(state, treeLength)
+      if (!(await this.core._validateCommit(state, treeLength))) return null
 
       if (this.length < length && !signature) {
         if (!keyPair) keyPair = this.core.header.keyPair
@@ -729,6 +756,8 @@ module.exports = class SessionState {
     head.fork = this.fork
     head.rootHash = rootHash
 
+    if (length === this.length) head.signature = this.signature
+
     return head
   }
 
@@ -739,6 +768,10 @@ module.exports = class SessionState {
     this.core = core
     this.index = this.core.sessionStates.push(this) - 1
 
+    // storage was updated
+    const deps = this.storage.dependencies
+    this.dependencyLength = deps[deps.length - 1].length
+
     for (let i = this.sessions.length - 1; i >= 0; i--) this.sessions[i].transferSession(this.core)
   }
 
@@ -831,7 +864,8 @@ module.exports = class SessionState {
       fork: this.fork,
       roots: length === this.length ? this.roots.slice() : await tree.getRoots(length),
       length,
-      prologue: this.prologue
+      prologue: this.prologue,
+      signature: length === this.length ? this.signature : null
     }
 
     const state = new SessionState(

package/package.json

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