autobee 2.10.1 → 2.11.1

package/index.js

@@ -5,15 +5,17 @@ const safetyCatch = require('safety-catch')
 const Hyperbee = require('hyperbee2')
 const ID = require('hypercore-id-encoding')
 const rrp = require('resolve-reject-promise')
-const { AutobeeEncryption, WriterEncryption, ViewEncryption } = require('autobee-encryption')
+const Signal = require('signal-promise')
 const AutobeeWakeup = require('autobee-wakeup')
 const Hypercore = require('hypercore')
 const crypto = require('hypercore-crypto')
 const c = require('compact-encoding')
 const asserts = require('./lib/asserts.js')
 const boot = require('./lib/boot.js')
+const { DEFAULT_MANIFEST_VERSION } = require('./lib/constants.js')
 const { resolveWeight, currentWeight } = require('./lib/witness.js')
 const encoding = require('./lib/encoding.js')
+const { AutobeeEncryption, WriterEncryption, ViewEncryption } = require('./lib/encryption.js')
 const FastForward = require('./lib/fast-forward.js')
 const System = require('./lib/system.js')
 const ApplyCalls = require('./lib/apply-calls.js')
@@ -26,6 +28,7 @@ const migrations = require('./lib/migrations.js')
 
 const EMPTY_HEAD = { length: 0, key: null }
 const DEFAULT_ACK_THRESHOLD = 32
+const BOOT_NETWORK_TIMEOUT = 5000
 const INTERRUPT = new Error('Apply interrupted')
 
 module.exports = class Autobee extends ReadyResource {
@@ -116,6 +119,9 @@ module.exports = class Autobee extends ReadyResource {
     this.fastForwardTo = null
     this._ffCandidates = new Map()
     this._ffSearching = null
+    this._bumpSignal = new Signal()
+    this._networkBooted = false
+    this._networkBooting = false
 
     this._workingBee = bee
     this._workingView = new ApplyView(this._workingBee, this)
@@ -143,6 +149,7 @@ module.exports = class Autobee extends ReadyResource {
     this._now = handlers.now || Date.now // overridable for clock-drift tests
     this._preapply = handlers.preapply || null
     this._preApplied = false
+    this._reindexed = false
     this._warmup = handlers.warmup || null
     this._hasApply = !!handlers.apply
     this._hasUpdate = !!handlers.update
@@ -205,7 +212,8 @@ module.exports = class Autobee extends ReadyResource {
     await 1
     const result = await this._prebooting
     return {
-      name: 'autobee/' + result.local.id + '/' + name,
+      name: 'autobee/' + result.local.id + '/view/' + name,
+      manifestVersion: DEFAULT_MANIFEST_VERSION,
       encryption: name === 'system' ? this.getSystemEncryption() : this.getViewEncryption(),
       inflightRange: [256, 512]
     }
@@ -380,6 +388,7 @@ module.exports = class Autobee extends ReadyResource {
 
   async _close() {
     this._interrupting = true
+    this._bumpSignal.notify()
 
     // the local core holds the exclusive lock but the local writer closes it
     // early in the teardown, so hand the lock to a detached session that
@@ -583,6 +592,11 @@ module.exports = class Autobee extends ReadyResource {
     this._localFlushes = this.system.flushes
   }
 
+  async _isReindexing() {
+    if (this._networkBooted || !this._ffEnabled || this._migrating) return false
+    return !(await this._isReindexed())
+  }
+
   async _bootOnline() {
     if (!this._bootOnlineGuard.enter()) return
 
@@ -607,6 +621,7 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   bumpSoon() {
+    this._bumpSignal.notify()
     this._bump(false).catch(safetyCatch)
   }
 
@@ -668,6 +683,61 @@ module.exports = class Autobee extends ReadyResource {
     this.emit('error', err)
   }
 
+  async compactMaybe() {
+    if (!this.writers.writable) return
+
+    if (await this._isReindexed()) return
+
+    await this._reindexBee(this._workingBee)
+    this.bee.move(this._workingBee.head())
+
+    await this._reindexBee(this.system.bee)
+
+    this._reindexed = true
+  }
+
+  async _isReindexed() {
+    const head = this.system.bee.head()
+    if (head === null) return true
+    if (await this._shouldReindex(head.key)) return false
+
+    const view = this.system.view
+    if (!view || !view.key) return true
+    return !(await this._shouldReindex(view.key))
+  }
+
+  async _reindexBee(bee) {
+    const head = bee.head()
+    const local = bee.context.local
+    if (head === null) return
+    if (await this._shouldReindex(local.key)) return
+    if (!(await this._shouldReindex(head.key))) return
+
+    // a non-empty local core is a completed reindex whose head was never stored
+    if (local.length === 0) {
+      await bee.reindex(async (change) => !(await this._shouldReindex(change.head.key)))
+    }
+
+    bee.move({ key: local.key, length: local.length })
+  }
+
+  async _shouldReindex(key, { unknown = false, length = 0, timeout = 0 } = {}) {
+    const core = this.store.get({ key, active: false })
+
+    try {
+      await core.ready()
+
+      if (core.manifest === null && length > 0) {
+        await core.get(length - 1, { raw: true, timeout }).catch(safetyCatch)
+      }
+
+      if (core.manifest === null) return unknown
+      return core.manifest.version > 1 && core.manifest.version < DEFAULT_MANIFEST_VERSION
+    } finally {
+      await core.close()
+    }
+  }
+
   // one-shot user gate: nothing applies until the host has resolved whatever
   // state apply depends on (e.g. legacy views recorded by a migration)
   async _runPreApply() {
@@ -688,6 +758,7 @@ module.exports = class Autobee extends ReadyResource {
       const { head = null, legacy = null } = this.bootFrom
 
       this.bootFrom = null
+      this._networkBooted = true
 
       if (legacy) {
         await this._bootFromSystem(legacy)
@@ -695,8 +766,14 @@ module.exports = class Autobee extends ReadyResource {
         this._wakeup.hint({ key: head.key, length: head.length || 0 })
         await this._bootFromHead(head)
       }
+    } else if (await this._isReindexing()) {
+      this._networkBooted = true
+      await this._bootFromNetwork()
     }
 
+    // preferably get a peer's compacted view during bootFrom
+    if (this.fastForwardTo === null) await this.compactMaybe()
+
     const changes = this._hasUpdate ? new UpdateChanges(this) : null
     if (changes) changes.track()
 
@@ -865,6 +942,7 @@ module.exports = class Autobee extends ReadyResource {
         const heads = await this._readCandidateHeads(hints, FastForward.DEFAULT_TIMEOUT)
 
         const ff = await FastForward.fromHeads(this, heads, {
+          skipGap: this._networkBooting,
           timeout: FastForward.DEFAULT_TIMEOUT
         })
 
@@ -1208,12 +1286,15 @@ module.exports = class Autobee extends ReadyResource {
   }
 
   async _appendAck() {
-    if (!this._acking) return false
+    if (!this._acking && !this._reindexed) return false
     if (!this.writers.writable) return false
 
     if (this.writers.localWriter.pending !== null) return false
-    if ((await this._flushesBehind()) < this._ackThreshold) return false
-    if (await this._allHeadsTrusted()) return false
+
+    if (!this._reindexed) {
+      if ((await this._flushesBehind()) < this._ackThreshold) return false
+      if (await this._allHeadsTrusted()) return false
+    }
 
     const links = this.system.getLinks(this.local.key)
     const now = this._now()
@@ -1371,6 +1452,14 @@ module.exports = class Autobee extends ReadyResource {
 
     const changed = await this.system.flush(batch, this._workingBee)
 
+    if (this._reindexed && (await this._isReindexed())) {
+      this._reindexed = false
+      await this.local.setUserData(
+        'autobee/head',
+        encoding.encodeBootRecord(this.system.bootRecord())
+      )
+    }
+
     if (this.system.promotions.changed) this._prefetchApprovals().catch(safetyCatch)
 
     if (local) {
@@ -1551,6 +1640,41 @@ module.exports = class Autobee extends ReadyResource {
     }
   }
 
+  async _bootFromNetwork() {
+    this._networkBooting = true
+
+    try {
+      await this._waitForNetworkBoot()
+    } finally {
+      this._networkBooting = false
+    }
+  }
+
+  async _waitForNetworkBoot() {
+    const deadline = Date.now() + BOOT_NETWORK_TIMEOUT
+
+    this._requestWakeup()
+
+    while (!this._interrupting && !this.closing && this.fastForwardTo === null) {
+      const hints = await this._applyWakeupHints()
+      if (hints.length) this._queueFastForward(hints)
+
+      const remaining = deadline - Date.now()
+      if (remaining <= 0 || this.fastForwardTo !== null) return
+
+      if (this._ffSearching !== null) {
+        await Promise.race([this._ffSearching, this._bumpSignal.wait(remaining)])
+        this._bumpSignal.notify()
+        if (this._ffSearching === null) return
+        continue
+      }
+
+      if (hints.length) return
+
+      await this._bumpSignal.wait(remaining)
+    }
+  }
+
   async _runFastForward(ff, { force = false } = {}) {
     if (this.fastForwardTo !== null || this.fastForwarding !== null) {
       await ff.close()

package/lib/constants.js

@@ -1,10 +1,12 @@
 const LEGACY_OPLOG_VERSION = 2
 const OPLOG_VERSION = 4
+const DEFAULT_MANIFEST_VERSION = 3
 const LEGACY_AUTOBASE_VERSION = 2
 const AUTOBEE_VERSION = 3
 const DEFAULT_OP_TIMEOUT = 5000
 
 module.exports = {
+  DEFAULT_MANIFEST_VERSION,
   LEGACY_OPLOG_VERSION,
   OPLOG_VERSION,
   LEGACY_AUTOBASE_VERSION,

package/lib/encoding.js

@@ -1,10 +1,10 @@
 const b4a = require('b4a')
 const c = require('compact-encoding')
 const crypto = require('hypercore-crypto')
-const { AutobeeEncryption, WriterEncryption } = require('autobee-encryption')
 
 const { getEncoding } = require('../encoding/spec/autobee')
-const { LEGACY_OPLOG_VERSION, OPLOG_VERSION } = require('./constants')
+const { LEGACY_OPLOG_VERSION, OPLOG_VERSION } = require('./constants.js')
+const { AutobeeEncryption, WriterEncryption } = require('./encryption.js')
 
 const Oplog = getEncoding('@autobee/oplog')
 const Link = getEncoding('@autobee/link')

package/lib/encryption.js

@@ -0,0 +1,259 @@
+const HypercoreEncryption = require('hypercore/lib/default-encryption.js')
+const sodium = require('sodium-native')
+const crypto = require('hypercore-crypto')
+const c = require('compact-encoding')
+const b4a = require('b4a')
+
+const { DEFAULT_MANIFEST_VERSION } = require('./constants.js')
+
+const ManifestData = {
+  preencode(state, m) {
+    c.uint.preencode(state, m.version)
+    state.end++ // max flag is 2 so always one byte
+
+    if (m.legacyBlocks) c.uint.preencode(state, m.legacyBlocks)
+    if (m.namespace) c.fixed32.preencode(state, m.namespace)
+  },
+  encode(state, m) {
+    const flags = (m.legacyBlocks ? 1 : 0) | (m.namespace ? 2 : 0)
+
+    c.uint.encode(state, m.version)
+    c.uint.encode(state, flags)
+
+    if (m.legacyBlocks) c.uint.encode(state, m.legacyBlocks)
+    if (m.namespace) c.fixed32.encode(state, m.namespace)
+  },
+  decode(state) {
+    const r0 = c.uint.decode(state)
+    const flags = c.uint.decode(state)
+
+    return {
+      version: r0,
+      legacyBlocks: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
+      namespace: (flags & 2) !== 0 ? c.fixed32.decode(state) : null
+    }
+  }
+}
+
+const [, NS_VIEW_BLOCK_KEY, NS_HASH_KEY] = crypto.namespace('autobase', 4)
+
+const [GENESIS_ENTROPY] = crypto.namespace('autobase/entropy', 2)
+
+const nonce = b4a.alloc(sodium.crypto_stream_NONCEBYTES)
+const hash = nonce.subarray(0, sodium.crypto_generichash_BYTES_MIN)
+
+class AutobeeEncryption {
+  static PADDING = 8
+
+  constructor(auto) {
+    this.auto = auto
+  }
+
+  padding() {
+    return AutobeeEncryption.PADDING
+  }
+
+  isCompat(ctx) {
+    return ctx.manifest.version <= 1
+  }
+
+  async getKeys(id, ctx) {
+    if (!this.auto.encryptionKey) return null
+
+    const entropy = GENESIS_ENTROPY
+    const block = this.blockKey(entropy, ctx)
+    const hash = crypto.hash([NS_HASH_KEY, block])
+
+    return {
+      id,
+      block,
+      hash
+    }
+  }
+
+  blockKey(entropy, ctx) {
+    return getBlockKey(this.auto.key, this.auto.encryptionKey, entropy, ctx.key)
+  }
+
+  compatKeys() {
+    throw new Error('Compatibility method is not specified')
+  }
+
+  async encrypt(index, block, fork, ctx) {
+    // writer cores are long lasting, but view cores should be up to date
+    if (this instanceof ViewEncryption && ctx.manifest.version < DEFAULT_MANIFEST_VERSION) {
+      throw new Error(`Unexpected manifest: version < ${DEFAULT_MANIFEST_VERSION}`)
+    }
+
+    if (this.isCompat(ctx, index)) {
+      const compat = this.compatKeys(ctx)
+      return HypercoreEncryption.encrypt(index, block, fork, compat.block, compat.blinding)
+    }
+
+    const keys = await this.getKeys(0, ctx)
+
+    encryptBlock(index, block, keys.id, keys.block, keys.hash)
+  }
+
+  async decrypt(index, block, ctx) {
+    if (this.isCompat(ctx, index)) {
+      return HypercoreEncryption.decrypt(index, block, this.compatKeys(ctx).block)
+    }
+
+    const padding = block.subarray(0, AutobeeEncryption.PADDING)
+    block = block.subarray(AutobeeEncryption.PADDING)
+
+    const type = padding[0]
+    switch (type) {
+      case 0:
+        return block // unencrypted
+
+      case 1:
+        break
+
+      default:
+        throw new Error('Unrecognised encryption type')
+    }
+
+    const id = c.uint32.decode({ start: 4, end: 8, buffer: padding })
+
+    const keys = await this.getKeys(id, ctx)
+
+    c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index)
+    nonce.set(padding, 8, 16)
+
+    // Decrypt the block using the full nonce
+    decrypt(block, nonce, keys.block)
+  }
+
+  static encryptAnchor(block, bootstrap, encryptionKey, namespace) {
+    const entropy = GENESIS_ENTROPY
+
+    const blockKey = getBlockKey(bootstrap, encryptionKey, entropy, namespace)
+    const hashKey = crypto.hash([NS_HASH_KEY, block])
+
+    encryptBlock(0, block, 0, blockKey, hashKey)
+  }
+
+  static async setSystemEncryption(bootstrap, encryptionKey, core, opts) {
+    await core.ready()
+    if (core.manifest.version === 1) {
+      const key = getCompatBlockKey(bootstrap, encryptionKey, '_system')
+      core.setEncryptionKey(key, { block: true })
+      return
+    }
+
+    const info = {
+      key: bootstrap,
+      encryptionKey
+    }
+
+    return core.setEncryption(new ViewEncryption(info, '_system'))
+  }
+
+  static getSystemEncryption(bootstrap, encryptionKey) {
+    return AutobeeEncryption.getViewEncryption(bootstrap, encryptionKey, '_system')
+  }
+
+  static getViewEncryption(bootstrap, encryptionKey, name) {
+    const info = { key: bootstrap, encryptionKey }
+    return new ViewEncryption(info, name)
+  }
+
+  static getWriterEncryption(bootstrap, encryptionKey) {
+    return new WriterEncryption({ key: bootstrap, encryptionKey })
+  }
+}
+
+class ViewEncryption extends AutobeeEncryption {
+  constructor(auto, name) {
+    super(auto)
+    this.name = name
+  }
+
+  compatKeys() {
+    const block = getCompatBlockKey(this.auto.key, this.auto.encryptionKey, this.name)
+    return {
+      block,
+      blinding: crypto.hash(block)
+    }
+  }
+
+  blockKey(entropy, ctx) {
+    // compat encryption
+    if (ctx.manifest.version < DEFAULT_MANIFEST_VERSION) {
+      return getCompatBlockKey(this.auto.key, entropy, this.name)
+    }
+
+    return getBlockKey(this.auto.key, this.auto.encryptionKey, entropy, ctx.key)
+  }
+}
+
+class WriterEncryption extends AutobeeEncryption {
+  compatKeys(ctx) {
+    return HypercoreEncryption.deriveKeys(this.auto.encryptionKey, ctx.key)
+  }
+
+  blockKey(entropy, ctx) {
+    // used for anchors
+    if (ctx.manifest.userData) {
+      const userData = c.decode(ManifestData, ctx.manifest.userData)
+      if (userData.namespace !== null) {
+        const b = getBlockKey(this.auto.key, this.auto.encryptionKey, entropy, userData.namespace)
+        return b
+      }
+    }
+
+    return getBlockKey(this.auto.key, this.auto.encryptionKey, entropy, ctx.key)
+  }
+}
+
+module.exports = {
+  AutobeeEncryption,
+  WriterEncryption,
+  ViewEncryption
+}
+
+function encrypt(block, nonce, key) {
+  sodium.crypto_stream_xor(block, block, nonce, key)
+}
+
+function decrypt(block, nonce, key) {
+  return encrypt(block, nonce, key) // symmetric
+}
+
+function getBlockKey(bootstrap, encryptionKey, entropy, hypercoreKey) {
+  return (
+    encryptionKey &&
+    crypto.hash([NS_VIEW_BLOCK_KEY, bootstrap, encryptionKey, entropy, hypercoreKey])
+  )
+}
+
+function getCompatBlockKey(bootstrap, encryptionKey, name) {
+  if (typeof name === 'string') return getCompatBlockKey(bootstrap, encryptionKey, b4a.from(name))
+  return encryptionKey && crypto.hash([NS_VIEW_BLOCK_KEY, bootstrap, encryptionKey, name])
+}
+
+function blockhash(block, padding, hashKey) {
+  sodium.crypto_generichash(hash, block, hashKey)
+  padding.set(hash.subarray(0, 8)) // copy first 8 bytes of hash
+  hash.fill(0) // clear nonce buffer
+}
+
+function encryptBlock(index, block, id, blockKey, hashKey) {
+  const padding = block.subarray(0, AutobeeEncryption.PADDING)
+  block = block.subarray(AutobeeEncryption.PADDING)
+
+  blockhash(block, padding, hashKey)
+  c.uint32.encode({ start: 4, end: 8, buffer: padding }, id)
+
+  c.uint64.encode({ start: 0, end: 8, buffer: nonce }, index)
+
+  padding[0] = 1 // version in plaintext
+
+  nonce.set(padding, 8, 16)
+
+  // The combination of index, key id, fork id and block hash is very likely
+  // to be unique for a given Hypercore and therefore our nonce is suitable
+  encrypt(block, nonce, blockKey)
+}

package/lib/fast-forward.js

@@ -7,7 +7,7 @@ const migrations = require('./migrations.js')
 const { LEGACY_AUTOBASE_VERSION, LEGACY_OPLOG_VERSION } = require('./constants.js')
 
 const DEFAULT_OP_TIMEOUT = 5_000
-const MIN_FF_GAP = 32
+const MIN_FF_GAP = 16
 
 class FastForward {
   constructor(auto, head, { timeout = DEFAULT_OP_TIMEOUT, conservative = false } = {}) {
@@ -39,7 +39,7 @@ class FastForward {
 
   static DEFAULT_TIMEOUT = DEFAULT_OP_TIMEOUT
 
-  static async fromHead(auto, head, trusted, { force = false, timeout = 0 } = {}) {
+  static async fromHead(auto, head, trusted, { force = false, skipGap = false, timeout = 0 } = {}) {
     const conservative = !force && auto._conservativeFF
 
     const oplog = await FastForward.flushHead(auto, head, { timeout })
@@ -51,7 +51,7 @@ class FastForward {
     // legacy nodes from non-indexers have no system info to fast-forward from
     if (!oplog.op.views || !verified.op.views) return null
 
-    if (!force && verified.op.views.flushes - auto.system.flushes < MIN_FF_GAP) {
+    if (!force && !skipGap && verified.op.views.flushes - auto.system.flushes < MIN_FF_GAP) {
       return null
     }
 
@@ -61,7 +61,7 @@ class FastForward {
     })
   }
 
-  static async fromHeads(auto, heads, { force = false, timeout = 0 } = {}) {
+  static async fromHeads(auto, heads, { force = false, skipGap = false, timeout = 0 } = {}) {
     const reference = auto._workingView.view
 
     const promises = []
@@ -71,14 +71,12 @@ class FastForward {
       promises.push(FastForward.flushHead(auto, head, { timeout }))
     }
 
-    const ops = await Promise.all(promises)
+    const ops = await FastForward.reindexedCandidates(auto, await Promise.all(promises), {
+      timeout: timeout || DEFAULT_OP_TIMEOUT
+    })
     if (auto.fastForwarding || auto.fastForwardTo) return null
 
-    const trust = await Promise.all(
-      ops.map((res) => {
-        return res === null ? false : auto.trusted.isTrusted(res.key, reference)
-      })
-    )
+    const trust = await Promise.all(ops.map((res) => auto.trusted.isTrusted(res.key, reference)))
     if (auto.fastForwarding || auto.fastForwardTo) return null
 
     const candidates = []
@@ -88,8 +86,7 @@ class FastForward {
 
     for (let i = 0; i < ops.length; i++) {
       const res = ops[i]
-      if (res === null || !res.op.views) continue
-      if (!force && res.op.views.flushes - auto.system.flushes < MIN_FF_GAP) continue
+      if (!force && !skipGap && res.op.views.flushes - auto.system.flushes < MIN_FF_GAP) continue
 
       if (!trust[i]) {
         candidates.push(res)
@@ -103,7 +100,7 @@ class FastForward {
     }
 
     if (bestTrusted !== null) {
-      return FastForward.fromHead(auto, bestTrusted, null, { force, timeout })
+      return FastForward.fromHead(auto, bestTrusted, null, { force, skipGap, timeout })
     }
 
     candidates.sort((a, b) => b.op.views.flushes - a.op.views.flushes)
@@ -113,13 +110,38 @@ class FastForward {
       if (trusted === null) continue
       if (auto.fastForwarding || auto.fastForwardTo) return null
 
-      const ff = await FastForward.fromHead(auto, res, trusted, { force, timeout })
+      const ff = await FastForward.fromHead(auto, res, trusted, { force, skipGap, timeout })
       if (ff !== null) return ff
     }
 
     return null
   }
 
+  static async reindexedCandidates(auto, ops, { timeout }) {
+    const withViews = ops.filter((res) => res !== null && res.op.views)
+    const reindexed = await Promise.all(
+      withViews.map((res) => FastForward.isReindexed(auto, res, timeout))
+    )
+    return withViews.filter((res, i) => reindexed[i])
+  }
+
+  static async isReindexed(auto, res, timeout) {
+    const { system, view } = res.op.views
+    const checks = [system, view]
+      .filter((v) => !!v)
+      .map((range) => {
+        const { key, length } = batchToHead(range)
+        if (length === 0) return false
+        return auto._shouldReindex(key, { unknown: true, length, timeout })
+      })
+
+    for (const shouldReindex of await Promise.all(checks)) {
+      if (shouldReindex) return false
+    }
+
+    return true
+  }
+
   static async flushHead(auto, head, opts) {
     const core = auto.openCore(head.key)
 

package/lib/migrations.js

@@ -1,9 +1,9 @@
 const c = require('compact-encoding')
 const b4a = require('b4a')
 const crypto = require('hypercore-crypto')
-const { AutobeeEncryption } = require('autobee-encryption')
 const { decodeBlock } = require('hyperbee2/lib/encoding.js')
 
+const { AutobeeEncryption } = require('./encryption.js')
 const encoding = require('./encoding.js')
 const { assert, bail } = require('./asserts.js')
 

package/lib/writers.js

@@ -3,7 +3,7 @@ const encoding = require('./encoding.js')
 const Triggers = require('./triggers.js')
 const { LEGACY_OPLOG_VERSION } = require('./constants.js')
 const { resolveWeight } = require('./witness.js')
-const { WriterEncryption } = require('autobee-encryption')
+const { WriterEncryption } = require('./encryption.js')
 const ReadWriteLock = require('read-write-mutexify')
 
 const WRITER_PREFETCH = 10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autobee",
-  "version": "2.10.1",
+  "version": "2.11.1",
   "description": "Bee based autobase",
   "license": "Apache-2.0",
   "author": "Holepunch Inc.",
@@ -23,12 +23,11 @@
     "test:generate": "brittle -r test/all.js test/*.js"
   },
   "dependencies": {
-    "autobee-encryption": "^0.1.2",
     "autobee-wakeup": "^1.1.3",
     "b4a": "^1.8.0",
-    "compact-encoding": "^3.3.0",
-    "hyperbee2": "^2.16.0",
-    "hypercore": "^11.33.2",
+    "compact-encoding": "^3.4.0",
+    "hyperbee2": "^2.17.1",
+    "hypercore": "^11.37.0",
     "hypercore-id-encoding": "^1.3.0",
     "hyperschema": "^1.26.2",
     "read-write-mutexify": "^2.1.0",
@@ -36,6 +35,7 @@
     "ready-resource": "^1.2.0",
     "resolve-reject-promise": "^1.1.0",
     "safety-catch": "^1.0.3",
+    "signal-promise": "^1.0.3",
     "sodium-native": "^5.1.0"
   },
   "devDependencies": {