hypercore 10.19.0 → 10.20.0

package/index.js

@@ -82,6 +82,7 @@ module.exports = class Hypercore extends EventEmitter {
     this.onwait = opts.onwait || null
     this.wait = opts.wait !== false
     this.timeout = opts.timeout || 0
+    this._clone = opts.clone || null
     this._readonly = opts.writable === false
 
     this.closing = null
@@ -306,6 +307,14 @@ module.exports = class Hypercore extends EventEmitter {
         const s = this.sessions[i]
         if (s !== this) s._passCapabilities(this)
       }
+
+      // copy state over
+      if (this._clone) {
+        const { from, upgrade } = this._clone
+        await from.opening
+        await this.core.copyFrom(from.core, upgrade)
+        this._clone = null
+      }
     }
 
     if (!this.auth) this.auth = this.core.defaultAuth
@@ -458,6 +467,50 @@ module.exports = class Hypercore extends EventEmitter {
     this.emit('close', true)
   }
 
+  clone (storage, opts = {}) {
+    // TODO: current limitation is no forking
+    if ((opts.fork && opts.fork !== 0) || this.fork !== 0) {
+      throw BAD_ARGUMENT('Cannot clone a fork')
+    }
+
+    const key = opts.key === undefined ? opts.keyPair ? null : this.key : opts.key
+    const keyPair = (opts.auth || opts.keyPair === undefined) ? null : opts.keyPair
+
+    let auth = this.core.defaultAuth
+    if (opts.auth) {
+      auth = opts.auth
+    } else if (opts.sign && keyPair) {
+      auth = Core.createAuth(this.crypto, keyPair, opts)
+    } else if (opts.sign) {
+      // TODO: dangerous to just update sign?
+      auth.sign = opts.sign
+    } else if (keyPair && keyPair.secretKey) {
+      auth = Core.createAuth(this.crypto, keyPair)
+    }
+
+    const upgrade = opts.upgrade === undefined ? null : opts.upgrade
+
+    const sparse = opts.sparse === false ? false : this.sparse
+    const wait = opts.wait === false ? false : this.wait
+    const onwait = opts.onwait === undefined ? this.onwait : opts.onwait
+    const timeout = opts.timeout === undefined ? this.timeout : opts.timeout
+
+    const Clz = this.constructor
+    return new Clz(storage, key, {
+      ...opts,
+      sparse,
+      wait,
+      onwait,
+      timeout,
+      auth,
+      overwrite: true,
+      clone: {
+        from: this,
+        upgrade
+      }
+    })
+  }
+
   replicate (isInitiator, opts = {}) {
     // Only limitation here is that ondiscoverykey doesn't work atm when passing a muxer directly,
     // because it doesn't really make a lot of sense.

package/lib/core.js

@@ -13,6 +13,7 @@ module.exports = class Core {
   constructor (header, crypto, oplog, tree, blocks, bitfield, auth, legacy, onupdate, onconflict) {
     this.onupdate = onupdate
     this.onconflict = onconflict
+    this.preupdate = null
     this.header = header
     this.crypto = crypto
     this.oplog = oplog
@@ -174,6 +175,70 @@ module.exports = class Core {
     return false
   }
 
+  async copyFrom (src, signature, auth = this.defaultAuth) {
+    this._mutex.lock()
+
+    try {
+      let pos = src.bitfield.firstSet(0)
+
+      while (pos >= 0) {
+        const segmentStart = pos
+        const segmentEnd = src.bitfield.firstUnset(pos)
+
+        if (segmentStart < 0) break
+
+        const segment = []
+
+        while (pos < segmentEnd) {
+          const val = await src.blocks.get(pos++)
+          segment.push(val)
+        }
+
+        const [offset] = await src.tree.byteRange(2 * segmentStart)
+        await this.blocks.putBatch(segmentStart, segment, offset)
+
+        this.bitfield.setRange(segmentStart, segmentEnd, true)
+
+        pos = src.bitfield.firstSet(segmentEnd + 1)
+      }
+
+      // TODO: is it an issue to move the nodes directly?
+      // TODO: make flat iterator that computes needed nodes
+
+      for (let i = 0; i <= src.tree.length * 2; i++) {
+        const node = await src.tree.get(i, false)
+        if (node === null) continue
+
+        await this.tree.addNode(node)
+      }
+
+      await this.tree.flush()
+
+      this.tree.fork = src.tree.fork
+      this.tree.roots = [...src.tree.roots]
+      this.tree.length = src.tree.length
+      this.tree.byteLength = src.tree.byteLength
+      this.tree.signature = null // must provide signature
+
+      this.tree.signature = signature || auth.sign(this.tree.signable())
+
+      if (signature && !this._signed(this.tree)) {
+        // TODO: how to handle signature failure?
+        this.tree.signature = null
+        throw INVALID_SIGNATURE('Clone was provided with an invalid signature')
+      }
+
+      this.header.tree.length = this.tree.length
+      this.header.tree.rootHash = this.tree.hash()
+      this.header.tree.signature = this.tree.signature
+      this.header.userData = src.header.userData // should copy?
+
+      await this._flushOplog()
+    } finally {
+      this._mutex.unlock()
+    }
+  }
+
   async _flushOplog () {
     // TODO: the apis using this, actually do not need to wait for the bitfields, tree etc to flush
     // as their mutations are already stored in the oplog. We could potentially just run this in the
@@ -381,6 +446,7 @@ module.exports = class Core {
         bitfield
       }
 
+      if (this.preupdate !== null) await this.preupdate(batch, this.header.signer.publicKey)
       if (bitfield) await this._writeBlock(batch, bitfield.start, value)
 
       await this.oplog.append([entry], false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypercore",
-  "version": "10.19.0",
+  "version": "10.20.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {
@@ -64,8 +64,8 @@
     "range-parser": "^1.2.1",
     "speedometer": "^1.1.0",
     "standard": "^17.0.0",
+    "test-tmp": "^1.0.2",
     "tiny-byte-size": "^1.1.0",
-    "tmp-promise": "^3.0.2",
     "udx-native": "^1.6.1"
   }
 }