hypercore 11.26.0 → 11.27.0

package/index.js

@@ -1057,22 +1057,27 @@ class Hypercore extends EventEmitter {
   async recoverFromRemoteProof(remoteProof) {
     this.core.replicator.setPushOnly(true)
     this.core._repairMode = true
+
     await this.core.state.mutex.lock()
-    const p = await verify(this.core.db, remoteProof)
-    if (!p) return false
 
-    const tx = this.core.storage.write()
-    for (const node of p.proof.upgrade.nodes) {
-      tx.putTreeNode(node)
-    }
-    await tx.flush()
+    try {
+      const p = await verify(this.core.db, remoteProof)
+      if (!p) return false
 
-    this.core.state.mutex.unlock()
-    const succeed = p.proof.upgrade.nodes.length !== 0
-    if (succeed) {
-      this.core.replicator.setPushOnly(false)
+      const tx = this.core.storage.write()
+      for (const node of p.proof.upgrade.nodes) {
+        tx.putTreeNode(node)
+      }
+      await tx.flush()
+
+      const succeed = p.proof.upgrade.nodes.length !== 0
+      if (succeed) {
+        this.core.replicator.setPushOnly(false)
+      }
+      return succeed
+    } finally {
+      this.core.state.mutex.unlock()
     }
-    return succeed
   }
 
   recoverTreeNodeFromPeers() {

package/lib/core.js

@@ -204,7 +204,8 @@ module.exports = class Core {
         hints: {
           reorgs: [],
           contiguousLength: 0,
-          remoteContiguousLength: 0
+          remoteContiguousLength: 0,
+          recovering: 0
         }
       }
 
@@ -553,7 +554,8 @@ module.exports = class Core {
 
     tx.setHints({
       contiguousLength: this.header.hints.contiguousLength,
-      remoteContiguousLength: this.header.hints.remoteContiguousLength
+      remoteContiguousLength: this.header.hints.remoteContiguousLength,
+      recovering: this.header.hints.recovering
     })
 
     await tx.flush()
@@ -963,7 +965,8 @@ function parseHeader(info) {
     hints: {
       reorgs: [],
       contiguousLength: info.hints ? info.hints.contiguousLength : 0,
-      remoteContiguousLength: info.hints ? info.hints.remoteContiguousLength : 0
+      remoteContiguousLength: info.hints ? info.hints.remoteContiguousLength : 0,
+      recovering: info.recovering || 0
     }
   }
 }

package/lib/replicator.js

@@ -987,6 +987,7 @@ class Peer {
   async push(index) {
     if (!this.remoteAllowPush) return
     if (!this.remoteDownloading) return
+    if (this.core.state.length <= index) return
     if (this.core.state.fork !== this.remoteFork) return
     if (this.remoteBitfield.get(index)) return
 

package/lib/session-state.js

@@ -4,7 +4,13 @@ const assert = require('nanoassert')
 const flat = require('flat-tree')
 const quickbit = require('quickbit-universal')
 
-const { INVALID_OPERATION, INVALID_SIGNATURE, ASSERTION } = require('hypercore-errors')
+const {
+  INVALID_OPERATION,
+  INVALID_SIGNATURE,
+  ASSERTION,
+  SESSION_CLOSED,
+  SESSION_NOT_WRITABLE
+} = require('hypercore-errors')
 
 const Mutex = require('./mutex')
 const Bitfield = require('./bitfield')
@@ -562,9 +568,47 @@ module.exports = class SessionState {
     }
   }
 
+  // simple tool to wait for other peers to catch us up
+  async _waitForRecovery() {
+    const length = this.length
+    const replicator = this.core.replicator
+
+    while (!this.closing) {
+      if (replicator.peers.length < 1) {
+        await new Promise((resolve) => setTimeout(resolve, 5000))
+        continue
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 5000))
+
+      const peers = replicator.peers
+
+      if (peers.length < 1 || this.closing) continue
+      if (peers[0].remoteLength > this.length) continue
+
+      if (this.length !== length) {
+        throw SESSION_NOT_WRITABLE('core recovered during append')
+      }
+
+      this.core.header.hints.recovering = 0
+
+      await this.mutex.lock()
+      try {
+        await this.core.flushHints()
+        return
+      } finally {
+        this.mutex.unlock()
+      }
+    }
+
+    throw SESSION_CLOSED('Cannot recover a closed session', this.discoveryKey)
+  }
+
   async append(values, { signature, keyPair, preappend, postappend, maxLength = -1 } = {}) {
     if (!keyPair && this.isDefault()) keyPair = this.core.header.keyPair
 
+    if (this.isDefault() && this.core.header.hints.recovering) await this._waitForRecovery()
+
     await this.mutex.lock()
 
     try {
@@ -921,6 +965,8 @@ module.exports = class SessionState {
       throw ASSERTION('Cannot commit while repair mode is on')
     }
 
+    if (this.core.header.hints.recovering) await this._waitForRecovery()
+
     let srcLocked = false
     await this.mutex.lock()
 

package/package.json

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