hypercore 11.0.31 → 11.0.33

package/index.js

@@ -1029,7 +1029,7 @@ class Hypercore extends EventEmitter {
 
   _updateEncryption () {
     const e = this.encryption
-    this.encryption = new BlockEncryption(e.key, this.key, { compat: this.core.compat, block: e.block })
+    this.encryption = new BlockEncryption(e.key, this.key, { compat: this.core.compat, block: b4a.equals(e.blockKey, e.key) })
     if (e === this.core.encryption) this.core.encryption = this.encryption
   }
 }

package/lib/core.js

@@ -532,7 +532,21 @@ module.exports = class Core {
   async verifyReorg (proof) {
     const batch = new ReorgBatch(this.state)
     await MerkleTree.reorg(this.state, proof, batch)
-    this._verifyBatchUpgrade(batch, proof.manifest)
+    const manifest = this._verifyBatchUpgrade(batch, proof.manifest)
+
+    if (manifest && !this.header.manifest) {
+      await this.state.mutex.lock()
+      try {
+        if (manifest && this.header.manifest === null) {
+          const tx = this.state.createWriteBatch()
+          this._setManifest(tx, Verifier.createManifest(manifest), null)
+          await this.state.flush()
+        }
+      } finally {
+        this.state._unlock()
+      }
+    }
+
     return batch
   }
 

package/lib/session-state.js

@@ -359,15 +359,15 @@ module.exports = class SessionState {
   }
 
   async truncate (length, fork, { signature, keyPair } = {}) {
-    if (this.prologue && length < this.prologue.length) {
-      throw INVALID_OPERATION('Truncation breaks prologue')
-    }
-
     if (!keyPair && this.isDefault()) keyPair = this.core.header.keyPair
 
     await this.mutex.lock()
 
     try {
+      if (this.prologue && length < this.prologue.length) {
+        throw INVALID_OPERATION('Truncation breaks prologue')
+      }
+
       const batch = this.createTreeBatch()
       await MerkleTree.truncate(this, length, batch, fork)
 
@@ -630,8 +630,6 @@ module.exports = class SessionState {
     await this.mutex.lock()
 
     try {
-      if (length < this.length) throw INVALID_OPERATION('Can not catchup back in time')
-
       const origLength = this.length
 
       let sharedLength = 0
@@ -754,36 +752,39 @@ module.exports = class SessionState {
     }
 
     for (let i = 0; i < blocks.length; i++) {
+      assert(blocks[i] !== null, 'has block')
       tx.putBlock(i + treeLength, blocks[i])
     }
 
     const totalLength = Math.max(length, this.length)
 
-    const firstPage = getBitfieldPage(treeLength)
-    const lastPage = getBitfieldPage(totalLength)
+    if (totalLength > treeLength) {
+      const firstPage = getBitfieldPage(treeLength)
+      const lastPage = getBitfieldPage(totalLength - 1)
 
-    const srx = this.storage.read()
-    const bitfieldPagePromise = srx.getBitfieldPage(firstPage)
-    srx.tryFlush()
+      const srx = this.storage.read()
+      const bitfieldPagePromise = srx.getBitfieldPage(firstPage)
+      srx.tryFlush()
 
-    const bitfieldPage = await bitfieldPagePromise
+      const bitfieldPage = await bitfieldPagePromise
 
-    let index = treeLength
+      let index = treeLength
 
-    for (let i = firstPage; i <= lastPage; i++) {
-      const page = b4a.alloc(Bitfield.BYTES_PER_PAGE)
-      tx.putBitfieldPage(i, page)
+      for (let i = firstPage; i <= lastPage; i++) {
+        const page = b4a.alloc(Bitfield.BYTES_PER_PAGE)
+        tx.putBitfieldPage(i, page)
 
-      // copy existing bits in
-      if (i === firstPage && bitfieldPage) page.set(bitfieldPage)
+        // copy existing bits in
+        if (i === firstPage && bitfieldPage) page.set(bitfieldPage)
 
-      if (index < length) {
-        index = fillBitfieldPage(page, index, length, i, true)
-        if (index < length) continue
-      }
+        if (index < length) {
+          index = fillBitfieldPage(page, index, length, i, true)
+          if (index < length) continue
+        }
 
-      if (index < this.length) {
-        index = fillBitfieldPage(page, index, this.length, i, false)
+        if (index < this.length) {
+          index = fillBitfieldPage(page, index, this.length, i, false)
+        }
       }
     }
 
@@ -1027,16 +1028,14 @@ function getBitfieldPage (index) {
   return Math.floor(index / Bitfield.BITS_PER_PAGE)
 }
 
-function getBitfieldOffset (index) {
-  return index & (Bitfield.BITS_PER_PAGE - 1)
-}
-
 function fillBitfieldPage (page, start, end, pageIndex, value) {
-  const last = ((pageIndex + 1) * Bitfield.BITS_PER_PAGE) - 1
-  const from = getBitfieldOffset(start)
+  const offset = pageIndex * Bitfield.BITS_PER_PAGE
+  const max = offset + Bitfield.BITS_PER_PAGE
 
-  const index = last < end ? last : end
-  const to = getBitfieldOffset(index)
+  const index = max < end ? max : end
+
+  const from = start - offset
+  const to = index - offset
 
   quickbit.fill(page, value, from, to)
 
@@ -1044,8 +1043,10 @@ function fillBitfieldPage (page, start, end, pageIndex, value) {
 }
 
 async function storeBitfieldRange (storage, tx, from, to, value) {
+  if (from >= to) return
+
   const firstPage = getBitfieldPage(from)
-  const lastPage = getBitfieldPage(to)
+  const lastPage = getBitfieldPage(to - 1)
 
   let index = from
 
@@ -1057,9 +1058,11 @@ async function storeBitfieldRange (storage, tx, from, to, value) {
   }
 
   rx.tryFlush()
+
   const pages = await Promise.all(promises)
+  const cnt = lastPage - firstPage + 1
 
-  for (let i = 0; i <= lastPage - firstPage; i++) {
+  for (let i = 0; i < cnt; i++) {
     const pageIndex = i + firstPage
     if (!pages[i]) pages[i] = b4a.alloc(Bitfield.BYTES_PER_PAGE)
 

package/package.json

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