autobee 2.0.0-rc.9 → 2.0.1

package/lib/apply-calls.js

@@ -1,5 +1,4 @@
 const ID = require('hypercore-id-encoding')
-const b4a = require('b4a')
 
 class ApplyCalls {
   constructor(auto) {
@@ -35,15 +34,15 @@ class ApplyCalls {
     if (typeof key === 'string') key = ID.decode(key)
     // no witness needed for genesis
     const isGenesis = !this.applying
-    return this.auto.system.addWriter(key, { weight, isGenesis })
+    const coord = this.applying
+      ? { key: this.applying[0].key, length: this.applying[0].length }
+      : null
+    const carrier = this.applying ? this.applying[0].weight : -1
+    return this.auto.system.addWriter(key, { weight, isGenesis, coord, carrier })
   }
 
   ackWriter(key) {
     if (typeof key === 'string') key = ID.decode(key)
-    // acking an optimistic node means we owe it a linking node
-    if (this.applying && this.applying[0].optimistic && !b4a.equals(key, this.auto.local.key)) {
-      this.auto._ackRequired = true
-    }
     return this.auto.system.ackWriter(key)
   }
 

package/lib/apply-view.js

@@ -0,0 +1,25 @@
+module.exports = class ApplyView {
+  constructor(bee, auto) {
+    this.bee = bee
+    this.auto = auto
+    this.view = ApplyView.open(bee, auto)
+  }
+
+  static open(bee, auto) {
+    return auto._handlers.open ? auto._handlers.open(bee, auto) : bee
+  }
+
+  static close(view, auto) {
+    if (!auto._handlers.close) return Promise.resolve()
+    return auto._handlers.close(view)
+  }
+
+  apply(userBatch) {
+    return this.auto._handlers.apply(userBatch, this.view, this.auto._host)
+  }
+
+  async close() {
+    await ApplyView.close(this.view, this.auto)
+    await this.bee.close()
+  }
+}

package/lib/boot.js

@@ -1,20 +1,6 @@
-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 encoding = require('./encoding.js')
-const { assert, bail } = require('./asserts.js')
-
-const { getEncoding } = require('../encoding/spec/autobee')
-
-const SystemInfoV1 = getEncoding('@autobase-compat/info-v1')
-const SystemInfoV2 = getEncoding('@autobase-compat/info-v2')
-
-const EMPTY = b4a.alloc(0)
-const INDEX_VERSION = 1
-const [NS_SIGNER_NAMESPACE] = crypto.namespace('autobase', 1)
+const { checkAutobaseMigration } = require('./migrations.js')
 
 module.exports = async function boot(
   corestore,
@@ -109,7 +95,7 @@ module.exports = async function boot(
     await result.bootstrap.setUserData('autobee/local', result.local.key)
     await result.local.setUserData('referrer', result.key)
 
-    result.migration = await checkAutobaseMigration(
+    result.migration = await migrateWithFallback(
       corestore,
       result.local,
       result.bootstrap,
@@ -153,59 +139,20 @@ module.exports = async function boot(
   return result
 }
 
-async function checkAutobaseMigration(store, local, bootstrap, legacyViews) {
-  const bootRecord = await local.getUserData('autobase/boot')
-  if (!bootRecord) return null
-
-  const { key } = encoding.decodeAutobaseBootRecord(bootRecord)
-  const core = store.get({ key: key, encryption: null })
-  await core.ready()
-
-  const system = { key, length: core.length }
-
-  // setup encryption
-  const encryptionKey = await local.getUserData('autobase/encryption')
-  await AutobeeEncryption.setSystemEncryption(bootstrap.key, encryptionKey, core)
-
-  const catchup = await getCatchupHeads(core)
-  const nodes = await Promise.all(
-    catchup.map((n) => getWriterBatch(store, n, bootstrap.key, encryptionKey))
-  )
+// the bootstrap pointer names the rotated-to writer, whose legacy boot record
+// can be unusable. the namespace local still carries the pre-rotation record,
+// which points at the last system core that was actually signed
+async function migrateWithFallback(corestore, local, bootstrap, legacyViews) {
+  try {
+    return await checkAutobaseMigration(corestore, local, bootstrap, legacyViews)
+  } catch (err) {
+    const prev = corestore.get({ name: 'local', active: false })
+    await prev.ready()
 
-  // Decode hyperbee block using hyperbee2 compat
-  const node = decodeBlock(await core.get(core.length - 1))
-  assert(node.keys.length > 0, 'bad system block')
+    if (b4a.equals(prev.key, local.key)) throw err
+    if (!(await prev.getUserData('autobase/boot'))) throw err
 
-  // Decode system info from hyperbee block using autobee compat
-  const info = decodeLegacySystemInfo(node.keys[0].value)
-
-  const indexerManifests = await Promise.all(
-    info.indexers.map((idx) => getCoreManifest(store, idx.key))
-  )
-  const views = await Promise.all(info.views.map((v) => getPersistedView(store, v)))
-  const entropy =
-    info.version > 1 && info.entropy ? info.entropy : indexerManifests[0].signers[0].namespace
-
-  const mappedViews = new Map()
-  for (const name of legacyViews) {
-    const v = await findViewByName(
-      store,
-      bootstrap.key,
-      encryptionKey,
-      indexerManifests,
-      views,
-      entropy,
-      name
-    )
-
-    mappedViews.set(name, v)
-  }
-
-  return {
-    encryptionKey,
-    system,
-    views: mappedViews,
-    catchup: nodes
+    return checkAutobaseMigration(corestore, prev, bootstrap, legacyViews)
   }
 }
 
@@ -218,118 +165,3 @@ async function getLocalKey(bootstrap) {
   if (current) return current
   return legacy
 }
-
-async function getPersistedView(store, view) {
-  const core = store.get(view.key)
-  await core.ready()
-
-  const length = core.length
-  await core.close()
-
-  return { key: view.key, length }
-}
-
-async function getCatchupHeads(core) {
-  const session = core.session({ name: 'batch' })
-  await session.ready()
-
-  const nodes = []
-  for (let i = core.length; i < session.length; i++) {
-    const node = await session.get(i, { wait: false })
-    if (!node) throw new Error('Expect nodes to exist locally')
-
-    const entry = decodeBlock(node).keys[0]
-    if (entry.key[0] !== 0x01) continue
-
-    const { key, length } = encoding.decodeSystemWriter(entry.key, entry.value)
-    nodes.push({ key, length })
-  }
-
-  return nodes
-}
-
-async function getWriterBatch(store, head, key, encryptionKey, nodes = []) {
-  const batch = []
-
-  const core = store.get(head.key)
-  await core.ready()
-
-  await core.setEncryption(AutobeeEncryption.getWriterEncryption(key, encryptionKey))
-
-  let seq = head.length - 1
-  const block = await core.get(seq--, { wait: false })
-  if (!block) throw new Error('Expect writer node to exist locally')
-
-  const node = encoding.decodeOplog(block)
-
-  batch.unshift({ ...head, ...node, from: core })
-
-  while (seq >= 0) {
-    const block = await core.get(seq--, { wait: false })
-    if (!block) break
-
-    const node = encoding.decodeOplog(block)
-    if (!node.batch.end) break
-
-    batch.unshift({ key: head.key, length: seq + 2, from: core, ...node })
-  }
-
-  return batch
-}
-
-async function getCoreManifest(store, key) {
-  const core = store.get(key)
-  await core.ready()
-
-  const manifest = core.manifest
-  await core.close()
-
-  return manifest
-}
-
-function decodeLegacySystemInfo(buffer) {
-  const state = { start: 0, end: buffer.length, buffer }
-  const version = c.uint.decode(state)
-
-  state.start--
-
-  switch (version) {
-    case 1:
-      return SystemInfoV1.decode(state)
-    case 2:
-      return SystemInfoV2.decode(state)
-    default:
-      bail('Expected legacy system info')
-  }
-}
-
-function deriveNamespace(name, bootstrap, entropy, encryptionKey) {
-  const encryptionId = crypto.hash(encryptionKey || EMPTY)
-  const version = c.encode(c.uint, INDEX_VERSION)
-
-  return crypto.hash([
-    NS_SIGNER_NAMESPACE,
-    version,
-    bootstrap,
-    encryptionId,
-    entropy,
-    b4a.from(name)
-  ])
-}
-
-async function findViewByName(store, key, encryptionKey, indexerManifests, views, entropy, name) {
-  if (indexerManifests.length === 0) return null
-
-  const namespace = deriveNamespace(name, key, entropy, encryptionKey)
-
-  for (const v of views) {
-    const manifest = await getCoreManifest(store, v.key)
-    if (manifest.signers.length === 0) continue
-
-    const signer = manifest.signers[0]
-
-    if (b4a.equals(signer.namespace, namespace)) return v
-  }
-
-  return null
-}

package/lib/constants.js

@@ -1,16 +1,13 @@
-const crypto = require('hypercore-crypto')
-
 const LEGACY_OPLOG_VERSION = 2
-const OPLOG_VERSION = 3
+const OPLOG_VERSION = 4
 const LEGACY_AUTOBASE_VERSION = 2
 const AUTOBEE_VERSION = 3
-
-const [NS_WITNESS] = crypto.namespace('autobee-witness', 1)
+const DEFAULT_OP_TIMEOUT = 5000
 
 module.exports = {
   LEGACY_OPLOG_VERSION,
   OPLOG_VERSION,
   LEGACY_AUTOBASE_VERSION,
   AUTOBEE_VERSION,
-  NS_WITNESS
+  DEFAULT_OP_TIMEOUT
 }

package/lib/encoding.js

@@ -12,6 +12,7 @@ const SystemInfo = getEncoding('@autobee/system-info')
 const SystemWriter = getEncoding('@autobee/system-writer')
 const ManifestData = getEncoding('@autobee/manifest-data')
 const AutobaseBootRecord = getEncoding('@autobase-compat/boot-record')
+const MigratedHead = getEncoding('@autobee/migrated-head')
 
 exports.OPLOG_VERSION = OPLOG_VERSION
 
@@ -21,13 +22,23 @@ exports.ManifestData = ManifestData
 exports.encodeBootRecord = encodeBootRecord
 exports.decodeBootRecord = decodeBootRecord
 
+exports.encodeMigratedHead = encodeMigratedHead
+exports.decodeMigratedHead = decodeMigratedHead
+
 exports.encodePreviousDrain = encodePreviousDrain
 exports.decodePreviousDrain = decodePreviousDrain
 
 exports.decodeAutobaseBootRecord = decodeAutobaseBootRecord
 
+exports.encodeSystemGrantKey = encodeSystemGrantKey
+exports.encodeSystemGrantHint = encodeSystemGrantHint
+exports.decodeSystemGrantHint = decodeSystemGrantHint
+exports.encodeSystemPendingKey = encodeSystemPendingKey
+exports.decodeSystemPendingKey = decodeSystemPendingKey
+exports.encodeSystemPendingRange = encodeSystemPendingRange
+exports.encodeSystemPending = encodeSystemPending
+exports.decodeSystemPending = decodeSystemPending
 exports.encodeSystemWriterKey = encodeSystemWriterKey
-exports.encodeSystemIndexerKey = encodeSystemIndexerKey
 exports.encodeSystemWriter = encodeSystemWriter
 exports.decodeSystemWriter = decodeSystemWriter
 
@@ -39,6 +50,14 @@ function decodeBootRecord(value) {
   return c.decode(Link, value)
 }
 
+function encodeMigratedHead(m) {
+  return c.encode(MigratedHead, m)
+}
+
+function decodeMigratedHead(value) {
+  return c.decode(MigratedHead, value)
+}
+
 function encodePreviousDrain(d) {
   return c.encode(c.uint, d)
 }
@@ -59,13 +78,57 @@ function encodeSystemWriterKey(key) {
   return buf
 }
 
-function encodeSystemIndexerKey(key) {
+function encodeSystemPendingKey(key) {
+  const buf = b4a.allocUnsafe(33)
+  buf[0] = 5
+  buf.set(key, 1)
+  return buf
+}
+
+function decodeSystemPendingKey(buf) {
+  return buf.subarray(1, 33)
+}
+
+function encodeSystemPendingRange() {
+  return { gte: b4a.from([5]), lt: b4a.from([6]) }
+}
+
+function encodeSystemPending(entry) {
+  return c.encode(c.uint, entry.weight)
+}
+
+function decodeSystemPending(value) {
+  return { weight: c.decode(c.uint, value) }
+}
+
+function encodeSystemGrantKey(key) {
   const buf = b4a.allocUnsafe(33)
-  buf[0] = 2
+  buf[0] = 4
   buf.set(key, 1)
   return buf
 }
 
+function encodeSystemGrantHint(hint) {
+  const state = { start: 0, end: 0, buffer: null }
+  c.fixed32.preencode(state, hint.key)
+  c.uint.preencode(state, hint.length)
+  c.uint.preencode(state, hint.weight)
+  state.buffer = b4a.alloc(state.end)
+  c.fixed32.encode(state, hint.key)
+  c.uint.encode(state, hint.length)
+  c.uint.encode(state, hint.weight)
+  return state.buffer
+}
+
+function decodeSystemGrantHint(value) {
+  const state = { start: 0, end: value.byteLength, buffer: value }
+  return {
+    key: c.fixed32.decode(state),
+    length: c.uint.decode(state),
+    weight: c.uint.decode(state)
+  }
+}
+
 function encodeSystemWriter(m) {
   return c.encode(SystemWriter, m)
 }
@@ -107,6 +170,9 @@ function decodeOplog(buf) {
       links: m.node.heads,
       batch: { start: 0, end: m.node.batch - 1 },
       views: null,
+      trusted: null,
+      witness: null,
+      approvals: null,
       optimistic: !!m.optimistic,
       value: m.node.value
     }
@@ -153,6 +219,9 @@ function createValue(value, opts = {}) {
     links,
     batch: null,
     views,
+    trusted: null,
+    witness: null,
+    approvals: null,
     optimistic,
     value
   }