Support rocksdb backed Hypercore

lib/messages.js

@@ -131,26 +131,42 @@ const Wakeup = {
 
 const Views = c.array(c.string)
 
+const V0BootRecord = {
+  preencode () {
+    throw new Error('version 0 records cannot be encoded')
+  },
+  encode () {
+    throw new Error('version 0 records cannot be encoded')
+  },
+  decode (state) {
+    const indexed = Checkout.decode(state)
+    const heads = Clock.decode(state)
+    const views = Views.decode(state)
+
+    return { version: 0, indexed, heads, views }
+  }
+}
+
 const BootRecord = {
   preencode (state, m) {
-    c.uint.preencode(state, 0) // version
-    Checkout.preencode(state, m.indexed)
-    Clock.preencode(state, m.heads)
+    c.uint.preencode(state, 1) // version
+    c.fixed32.preencode(state, m.key)
     Views.preencode(state, m.views)
   },
   encode (state, m) {
-    c.uint.encode(state, 0) // version
-    Checkout.encode(state, m.indexed)
-    Clock.encode(state, m.heads)
+    c.uint.encode(state, 1) // version
+    c.fixed32.encode(state, m.key)
     Views.encode(state, m.views)
   },
   decode (state) {
     const v = c.uint.decode(state)
-    assert(v === 0, 'Unsupported version: ' + v)
+    if (v === 0) return V0BootRecord.decode(state)
+
+    assert(v === 1, 'Unsupported version: ' + v)
 
     return {
-      indexed: Checkout.decode(state),
-      heads: Clock.decode(state),
+      version: 1,
+      key: c.fixed32.decode(state),
       views: Views.decode(state)
     }
   }
@@ -508,6 +524,53 @@ const Member = {
   }
 }
 
+const View = {
+  preencode (state, v) {
+    c.int.preencode(state, v.core)
+    c.uint.preencode(state, v.appending)
+  },
+  encode (state, v) {
+    c.int.encode(state, v.core)
+    c.uint.encode(state, v.appending)
+  },
+  decode (state) {
+    return {
+      core: c.int.decode(state),
+      appending: c.uint.decode(state)
+    }
+  }
+}
+
+const ViewArray = c.array(View)
+
+const Update = {
+  preencode (state, u) {
+    c.uint.preencode(state, u.batch)
+    c.bool.preencode(state, u.indexers)
+    ViewArray.preencode(state, u.views)
+    c.uint.preencode(state, u.version)
+    c.uint.preencode(state, u.systemLength)
+  },
+  encode (state, u) {
+    c.uint.encode(state, u.batch)
+    c.bool.encode(state, u.indexers)
+    ViewArray.encode(state, u.views)
+    c.uint.encode(state, u.version)
+    c.uint.encode(state, u.systemLength)
+  },
+  decode (state) {
+    return {
+      batch: c.uint.decode(state),
+      indexers: c.bool.decode(state),
+      views: ViewArray.decode(state),
+      version: c.uint.decode(state),
+      systemLength: c.uint.decode(state)
+    }
+  }
+}
+
+const UpdateArray = c.array(Update)
+
 module.exports = {
   Wakeup,
   Clock,
@@ -517,5 +580,6 @@ module.exports = {
   OplogMessage,
   Checkpoint,
   Info,
-  Member
+  Member,
+  UpdateArray
 }

lib/signer.js

@@ -1,4 +1,5 @@
 const b4a = require('b4a')
+const crypto = require('hypercore-crypto')
 const { partialSignature } = require('hypercore/lib/multisig.js')
 
 module.exports = class Signer {
@@ -9,27 +10,29 @@ module.exports = class Signer {
     this.opened = false
     this.checkpoints = new Map()
 
-    this.open()
+    this.open(core.originalCore.length)
   }
 
-  async sign (indexers, length) {
-    const signatures = await this.getSignatures(indexers, length)
-    const tree = this.core.core.createTreeBatch()
+  async sign (indexers, length, pendingIndexedLength) {
+    const signatures = await this.getSignatures(indexers, length, pendingIndexedLength)
+    const tree = this.core.core.state.tree
     const p = await Promise.all(signatures.map(s => partialSignature(tree, s.signer, length, s.length, s.signature)))
-    return this.core.core.session.core.verifier.assemble(p)
+    return this.core.core.core.verifier.assemble(p)
   }
 
   async _verify (length, signature, key) {
     if (!this.core.core || length > this.core.core.length) return false
     if (length < this.core.core.indexedLength) return true
     const batch = await this.core.core.restoreBatch(length)
+    // against the main fork
+    batch.fork = this.core.core.core.tree.fork
     const { publicKey } = this.base.getNamespace(key, this.core)
-    return batch.tree.crypto.verify(batch.signable(this.core.key), signature, publicKey)
+    return crypto.verify(batch.signable(this.core.key), signature, publicKey)
   }
 
-  open () {
+  open (length) {
     if (this.opened) return true
-    if (!this.core.pendingIndexedLength) return false
+    if (!length) return false
 
     for (const idx of this.base.linearizer.indexers) {
       for (const checkpoint of idx.flushCheckpoints(this.core.systemIndex)) {
@@ -55,13 +58,13 @@ module.exports = class Signer {
     checkpoints.push(checkpoint)
   }
 
-  bestCheckpoint (idx, gc = false) {
+  bestCheckpoint (idx, length, gc = false) {
     const hex = b4a.toString(idx.core.key, 'hex')
 
     const checkpoints = this.checkpoints.get(hex)
     if (!checkpoints) return null
 
-    const i = findBestCheckpoint(checkpoints, this.core.pendingIndexedLength)
+    const i = findBestCheckpoint(checkpoints, length)
     if (i === -1) return null
 
     const checkpoint = checkpoints[i]
@@ -73,15 +76,16 @@ module.exports = class Signer {
     return checkpoint
   }
 
-  async getSignableLength (indexers) {
-    if (!this.open()) return 0
+  async getSignableLength (indexers, length) {
+    if (!this.open(length)) return 0
 
     const signed = []
     const thres = (indexers.length >> 1) + 1
 
     for (const idx of indexers) {
-      const checkpoint = this.bestCheckpoint(idx)
-      if (!checkpoint) continue
+      const checkpoint = this.bestCheckpoint(idx, length)
+
+      if (!checkpoint || checkpoint.length <= this.core.core.signedLength) continue
 
       // signature is invalid
       if (!(await this._verify(checkpoint.length, checkpoint.signature, idx.core.key))) {
@@ -94,13 +98,13 @@ module.exports = class Signer {
     return signed.length < thres ? 0 : signed.sort(descendingOrder)[thres - 1]
   }
 
-  async getSignatures (indexers, length) {
+  async getSignatures (indexers, length, pendingIndexedLength) {
     const signatures = []
     const thres = (indexers.length >> 1) + 1
 
     for (let signer = 0; signer < indexers.length; signer++) {
       const idx = indexers[signer]
-      const checkpoint = this.bestCheckpoint(idx, true)
+      const checkpoint = this.bestCheckpoint(idx, pendingIndexedLength, true)
       if (!checkpoint) continue
 
       // signature is invalid