hyper-multisig 0.0.1 → 0.1.1

package/README.md

@@ -42,7 +42,7 @@ End users most likely want to use [hyper-multisig-cli](https://github.com/holepu
   await store.ready()
 
   const multisig = new HyperMultisig(store, swarm)
-  const { manifest, core } = await multisig.createCore(publicKeys, namespace)
+  const { manifest, core } = await multisig.createCore(publicKeys, namespace).done()
   ```
 
 - Step 3: Generate a signing request based on a normal core (non-multisig) with the manifest from the previous step.
@@ -56,7 +56,7 @@ End users most likely want to use [hyper-multisig-cli](https://github.com/holepu
   srcCore.append('hello world 3')
 
   const multisig = new HyperMultisig(store)
-  const { request } = await multisig.requestCore(publicKeys, namespace, srcCore, 3)
+  const { request } = await multisig.requestCore(publicKeys, namespace, srcCore, 3).done()
   ```
 
 - Step 4: Use [hypercore-sign](https://github.com/holepunchto/hypercore-sign) to sign the signing request to generate a signature. Later, signatures from all signers will be collected to sign the multisig core.
@@ -72,5 +72,5 @@ End users most likely want to use [hyper-multisig-cli](https://github.com/holepu
   const signatures = [signature1, signature2, ...]
 
   const multisig = new HyperMultisig(store, swarm)
-  await multisig.commitCore(publicKeys, namespace, srcCore, request, signatures)
+  await multisig.commitCore(publicKeys, namespace, srcCore, request, signatures).done()
   ```

package/index.js

@@ -20,6 +20,7 @@
  * }} CoreInfo
  */
 
+const { EventEmitter } = require('events')
 const cenc = require('compact-encoding')
 const CoreSign = require('hypercore-sign')
 const SignRequest = require('hypercore-signing-request')
@@ -66,179 +67,235 @@ class HyperMultisig {
     return { manifest, key, core, blobsManifest, blobsKey, blobsCore }
   }
 
-  async requestCore(
+  requestCore(
     publicKeys,
     namespace,
     srcCore,
     length,
     { force = false, quorum, peerUpdateTimeout } = {}
   ) {
-    await srcCore.ready()
-    this.swarm.join(srcCore.discoveryKey, { client: true, server: false })
-    await srcCore.download({ start: 0, end: length }).done()
+    return new HyperMultisigRunner(async (runner) => {
+      await srcCore.ready()
+      this.swarm.join(srcCore.discoveryKey, { client: true, server: false })
+      await srcCore.download({ start: 0, end: length }).done()
 
-    if (!force) await MultisigUtil.verifyCoreRequestable(srcCore, length, { peerUpdateTimeout })
+      if (!force) await MultisigUtil.verifyCoreRequestable(srcCore, length, { peerUpdateTimeout })
 
-    const manifest = MultisigUtil.getManifest(publicKeys, namespace, { quorum })
-    const request = await SignRequest.generate(srcCore, { manifest, length })
-    return { manifest, request }
+      const manifest = MultisigUtil.getManifest(publicKeys, namespace, { quorum })
+      const request = await SignRequest.generate(srcCore, { manifest, length })
+      return { manifest, request }
+    })
   }
 
-  async requestDrive(
+  requestDrive(
     publicKeys,
     namespace,
     srcDrive,
     length,
     { force = false, quorum, peerUpdateTimeout } = {}
   ) {
-    await srcDrive.ready()
-    this.swarm.join(srcDrive.discoveryKey, { client: true, server: false })
-    await srcDrive.getBlobs()
-    length = length || srcDrive.core.length
-
-    if (!force) {
-      await MultisigUtil.verifyCoreRequestable(srcDrive.core, length, {
-        peerUpdateTimeout,
-        coreId: 'db'
-      })
-      const contentLength = await srcDrive.getBlobsLength(length)
-      await MultisigUtil.verifyCoreRequestable(srcDrive.blobs.core, contentLength, {
-        peerUpdateTimeout,
-        coreId: 'blobs'
-      })
-    }
+    return new HyperMultisigRunner(async (runner) => {
+      await srcDrive.ready()
+      this.swarm.join(srcDrive.discoveryKey, { client: true, server: false })
+      await srcDrive.getBlobs()
+      length = length || srcDrive.core.length
 
-    const manifest = MultisigUtil.getManifest(publicKeys, namespace, { quorum })
-    const request = await SignRequest.generateDrive(srcDrive, { manifest, length })
-    return { manifest, request }
+      if (!force) {
+        await MultisigUtil.verifyCoreRequestable(srcDrive.core, length, {
+          peerUpdateTimeout,
+          coreId: 'db'
+        })
+        const contentLength = await srcDrive.getBlobsLength(length)
+        await MultisigUtil.verifyCoreRequestable(srcDrive.blobs.core, contentLength, {
+          peerUpdateTimeout,
+          coreId: 'blobs'
+        })
+      }
+
+      const manifest = MultisigUtil.getManifest(publicKeys, namespace, { quorum })
+      const request = await SignRequest.generateDrive(srcDrive, { manifest, length })
+      return { manifest, request }
+    })
   }
 
-  async commitCore(
+  commitCore(
     publicKeys,
     namespace,
     srcCore,
     request,
     responses,
-    { force = false, dryRun, quorum, skipTargetChecks = false, peerUpdateTimeout } = {}
+    {
+      quorum,
+      dryRun,
+      force = false,
+      skipTargetChecks = false,
+      peerUpdateTimeout,
+      minFullCopies = 2
+    } = {}
   ) {
-    await srcCore.ready()
-    this.swarm.join(srcCore.discoveryKey, { client: true, server: false })
+    return new HyperMultisigRunner(async (runner) => {
+      await srcCore.ready()
+      this.swarm.join(srcCore.discoveryKey, { client: true, server: false })
+
+      const { manifest, core } = await this.createCore(publicKeys, namespace, { quorum })
+      this.swarm.join(core.discoveryKey)
 
-    const { manifest, core } = await this.createCore(publicKeys, namespace, { quorum })
-    this.swarm.join(core.discoveryKey)
+      const { length } = SignRequest.decode(z32.decode(request))
 
-    const { length } = SignRequest.decode(z32.decode(request))
+      if (!force) {
+        runner.emit('verify-committable-start')
+        await MultisigUtil.verifyCoreCommittable(srcCore, core, length, {
+          skipTargetChecks,
+          peerUpdateTimeout
+        })
+      }
 
-    if (!force) {
-      await MultisigUtil.verifyCoreCommittable(srcCore, core, length, {
-        skipTargetChecks,
-        peerUpdateTimeout
+      const signResponses = []
+      for (const response of responses) {
+        const res = cenc.decode(CoreSign.messages.Response, z32.decode(response))
+        await CoreSign.verify(response, request, z32.encode(res.publicKey))
+        const publicKeyHex = res.publicKey.toString('hex')
+        signResponses[publicKeyHex] = res
+      }
+      const obtainedQuorum = Object.keys(signResponses).length
+      if (!dryRun && obtainedQuorum < manifest.quorum) {
+        throw new Error(`Insufficient quorum: ${obtainedQuorum} / ${manifest.quorum}`)
+      }
+
+      // NOTE: the ordering is important here, must map to signers ordering
+      const signatures = manifest.signers.map((signer) => {
+        const publicKeyHex = signer.publicKey.toString('hex')
+        return signResponses[publicKeyHex]?.signatures[0]
       })
-    }
-
-    const signResponses = []
-    for (const response of responses) {
-      const res = cenc.decode(CoreSign.messages.Response, z32.decode(response))
-      await CoreSign.verify(response, request, z32.encode(res.publicKey))
-      const publicKeyHex = res.publicKey.toString('hex')
-      signResponses[publicKeyHex] = res
-    }
-    const obtainedQuorum = Object.keys(signResponses).length
-    if (!dryRun && obtainedQuorum < manifest.quorum) {
-      throw new Error(`Insufficient quorum: ${obtainedQuorum} / ${manifest.quorum}`)
-    }
-
-    // NOTE: the ordering is important here, must map to signers ordering
-    const signatures = manifest.signers.map((signer) => {
-      const publicKeyHex = signer.publicKey.toString('hex')
-      return signResponses[publicKeyHex]?.signatures[0]
-    })
 
-    const batch = await MultisigUtil.signCore(core, srcCore, signatures, {
-      end: length,
-      commit: !dryRun
+      runner.emit('commit-start')
+      const batch = await MultisigUtil.signCore(core, srcCore, signatures, {
+        end: length,
+        commit: !dryRun
+      })
+
+      if (!force && !dryRun) {
+        runner.emit('verify-committed-start', core.key)
+        await MultisigUtil.verifyCoreCommitted(core, { minPeers: minFullCopies })
+      }
+
+      const result = {
+        destCore: await MultisigUtil.getCoreInfo(core),
+        srcCore: await MultisigUtil.getCoreInfo(srcCore),
+        batch
+      }
+
+      return { manifest, core, quorum: obtainedQuorum, result }
     })
-    const result = {
-      destCore: await MultisigUtil.getCoreInfo(core),
-      srcCore: await MultisigUtil.getCoreInfo(srcCore),
-      batch
-    }
-    return { manifest, quorum: obtainedQuorum, result }
   }
 
-  async commitDrive(
+  commitDrive(
     publicKeys,
     namespace,
     srcDrive,
     request,
     responses,
-    { dryRun, quorum, force = false, skipTargetChecks = false, peerUpdateTimeout } = {}
+    { quorum, dryRun, force = false, skipTargetChecks = false, peerUpdateTimeout } = {}
   ) {
-    await srcDrive.ready()
-    this.swarm.join(srcDrive.discoveryKey, { client: true, server: false })
-    await srcDrive.getBlobs()
+    return new HyperMultisigRunner(async (runner) => {
+      await srcDrive.ready()
+      this.swarm.join(srcDrive.discoveryKey, { client: true, server: false })
+      await srcDrive.getBlobs()
 
-    const { manifest, core, blobsCore } = await this.createDrive(publicKeys, namespace, { quorum })
-    this.swarm.join(core.discoveryKey)
+      const { manifest, core, blobsCore } = await this.createDrive(publicKeys, namespace, {
+        quorum
+      })
+      this.swarm.join(core.discoveryKey)
 
-    const { length, content } = SignRequest.decode(z32.decode(request))
-    const blobsLength = content.length
+      const { length, content } = SignRequest.decode(z32.decode(request))
+      const blobsLength = content.length
 
-    if (!force) {
-      await MultisigUtil.verifyCoreCommittable(srcDrive.db.core, core, length, {
-        skipTargetChecks,
-        peerUpdateTimeout,
-        coreId: 'db'
-      })
-      await MultisigUtil.verifyCoreCommittable(srcDrive.blobs.core, blobsCore, blobsLength, {
-        skipTargetChecks,
-        peerUpdateTimeout,
-        coreId: 'blobs'
+      if (!force) {
+        runner.emit('verify-committable-start')
+        await MultisigUtil.verifyCoreCommittable(srcDrive.db.core, core, length, {
+          skipTargetChecks,
+          peerUpdateTimeout,
+          coreId: 'db'
+        })
+        await MultisigUtil.verifyCoreCommittable(srcDrive.blobs.core, blobsCore, blobsLength, {
+          skipTargetChecks,
+          peerUpdateTimeout,
+          coreId: 'blobs'
+        })
+      }
+
+      const signResponses = []
+      for (const response of responses) {
+        const res = cenc.decode(CoreSign.messages.Response, z32.decode(response))
+        await CoreSign.verify(response, request, z32.encode(res.publicKey))
+        const publicKeyHex = res.publicKey.toString('hex')
+        signResponses[publicKeyHex] = res
+      }
+      const obtainedQuorum = Object.keys(signResponses).length
+      if (!dryRun && obtainedQuorum < manifest.quorum) {
+        throw new Error(`Insufficient quorum: ${obtainedQuorum} / ${manifest.quorum}`)
+      }
+
+      const allSignatures = manifest.signers.map((signer) => {
+        const publicKeyHex = signer.publicKey.toString('hex')
+        return signResponses[publicKeyHex]?.signatures
       })
-    }
-
-    const signResponses = []
-    for (const response of responses) {
-      const res = cenc.decode(CoreSign.messages.Response, z32.decode(response))
-      await CoreSign.verify(response, request, z32.encode(res.publicKey))
-      const publicKeyHex = res.publicKey.toString('hex')
-      signResponses[publicKeyHex] = res
-    }
-    const obtainedQuorum = Object.keys(signResponses).length
-    if (!dryRun && obtainedQuorum < manifest.quorum) {
-      throw new Error(`Insufficient quorum: ${obtainedQuorum} / ${manifest.quorum}`)
-    }
-
-    const allSignatures = manifest.signers.map((signer) => {
-      const publicKeyHex = signer.publicKey.toString('hex')
-      return signResponses[publicKeyHex]?.signatures
-    })
-    // NOTE: the ordering is important here, must map to signers ordering
-    const signatures = allSignatures.map((item) => item?.[0])
-    const blobsSignatures = allSignatures.map((item) => item?.[1])
-
-    const { batch, blobsBatch } = await MultisigUtil.signDrive(
-      core,
-      srcDrive.core,
-      signatures,
-      blobsCore,
-      srcDrive.blobs.core,
-      blobsSignatures,
-      { end: length, blobsEnd: blobsLength, commit: !dryRun }
-    )
-    const result = {
-      db: {
-        destCore: await MultisigUtil.getCoreInfo(core),
-        srcCore: await MultisigUtil.getCoreInfo(srcDrive.core),
-        batch
-      },
-      blobs: {
-        destCore: await MultisigUtil.getCoreInfo(blobsCore),
-        srcCore: await MultisigUtil.getCoreInfo(srcDrive.blobs.core),
-        batch: blobsBatch
+      // NOTE: the ordering is important here, must map to signers ordering
+      const signatures = allSignatures.map((item) => item?.[0])
+      const blobsSignatures = allSignatures.map((item) => item?.[1])
+
+      runner.emit('commit-start')
+      const { batch, blobsBatch } = await MultisigUtil.signDrive(
+        core,
+        srcDrive.core,
+        signatures,
+        blobsCore,
+        srcDrive.blobs.core,
+        blobsSignatures,
+        { end: length, blobsEnd: blobsLength, commit: !dryRun }
+      )
+
+      if (!force && !dryRun) {
+        runner.emit('verify-committed-start', core.key)
+        await MultisigUtil.verifyCoreCommitted(core)
+        await MultisigUtil.verifyCoreCommitted(blobsCore)
       }
-    }
-    return { manifest, quorum: obtainedQuorum, result }
+
+      const result = {
+        db: {
+          destCore: await MultisigUtil.getCoreInfo(core),
+          srcCore: await MultisigUtil.getCoreInfo(srcDrive.core),
+          batch
+        },
+        blobs: {
+          destCore: await MultisigUtil.getCoreInfo(blobsCore),
+          srcCore: await MultisigUtil.getCoreInfo(srcDrive.blobs.core),
+          batch: blobsBatch
+        }
+      }
+      return { manifest, core, blobsCore, quorum: obtainedQuorum, result }
+    })
+  }
+}
+
+class HyperMultisigRunner extends EventEmitter {
+  constructor(handler) {
+    super()
+    this.handler = handler
+
+    this._running = this._run()
+    // This will always be awaited, but to avoid uncaughts in case it's not awaited in the same tick
+    this._running.catch(() => {})
+  }
+
+  async _run() {
+    // Tick so the user can register event listeners
+    await new Promise((resolve) => queueMicrotask(resolve))
+    return await this.handler(this)
+  }
+
+  async done() {
+    return await this._running
   }
 }
 

package/lib/util.js

@@ -272,11 +272,15 @@ async function verifyCoreCommittable(
     return
   }
 
+  await waitUntilSufficientPeers(tgtCore, { minPeers, timeout: peerUpdateTimeout })
+
   const tgtPeers = tgtCore.peers.length
   if (tgtPeers < minPeers) {
     throw MultisigError.TARGET_CORE_INSUFFICIENT_PEERS(tgtPeers, minPeers, { coreId })
   }
 
+  await waitUntilFullySeeded(tgtCore, { minPeers, timeout: peerUpdateTimeout })
+
   let tgtFullCopies = 0
   for (const p of tgtCore.peers) {
     if (p.remoteContiguousLength === tgtCore.length) tgtFullCopies++
@@ -290,6 +294,17 @@ async function verifyCoreCommittable(
   }
 }
 
+async function verifyCoreCommitted(tgtCore, { minPeers = 2 } = {}) {
+  let tgtFullCopies = 0
+  for (const p of tgtCore.peers) {
+    if (p.remoteContiguousLength === tgtCore.length) tgtFullCopies++
+  }
+  if (tgtFullCopies < minPeers) {
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    await verifyCoreCommitted(tgtCore, { minPeers })
+  }
+}
+
 async function waitUntilCoreLength(core, length, { timeout = 5000 } = {}) {
   return await waitUntil(() => core.length >= length, { timeout })
 }
@@ -324,6 +339,7 @@ module.exports = {
   getCoreInfo,
   verifyCoreRequestable,
   verifyCoreCommittable,
+  verifyCoreCommitted,
   waitUntilCoreLength,
   waitUntilSufficientPeers,
   waitUntilFullySeeded

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyper-multisig",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "Multisig hypercore and hyperdrive",
   "main": "index.js",
   "files": [
@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "b4a": "^1.7.4",
+    "bare-events": "^2.8.2",
     "compact-encoding": "^2.18.0",
     "hypercore": "^11.24.0",
     "hypercore-crypto": "^3.6.1",
@@ -43,5 +44,11 @@
   "bugs": {
     "url": "https://github.com/holepunchto/hyper-multisig/issues"
   },
-  "homepage": "https://github.com/holepunchto/hyper-multisig#readme"
+  "homepage": "https://github.com/holepunchto/hyper-multisig#readme",
+  "imports": {
+    "events": {
+      "bare": "bare-events",
+      "default": "events"
+    }
+  }
 }