hypercore 11.16.2 → 11.17.0

package/lib/verifier.js

@@ -10,7 +10,12 @@ const multisig = require('./multisig')
 const caps = require('./caps')
 
 class Signer {
-  constructor (manifestHash, version, index, { signature = 'ed25519', publicKey, namespace = caps.DEFAULT_NAMESPACE } = {}) {
+  constructor(
+    manifestHash,
+    version,
+    index,
+    { signature = 'ed25519', publicKey, namespace = caps.DEFAULT_NAMESPACE } = {}
+  ) {
     if (!publicKey) throw BAD_ARGUMENT('public key is required for a signer')
     if (signature !== 'ed25519') throw BAD_ARGUMENT('Only Ed25519 signatures are supported')
 
@@ -22,36 +27,40 @@ class Signer {
     this.namespace = namespace
   }
 
-  _ctx () {
+  _ctx() {
     return this.version === 0 ? this.namespace : this.manifestHash
   }
 
-  verify (batch, signature) {
+  verify(batch, signature) {
     return crypto.verify(batch.signable(this._ctx()), signature, this.publicKey)
   }
 
-  sign (batch, keyPair) {
+  sign(batch, keyPair) {
     return crypto.sign(batch.signable(this._ctx()), keyPair.secretKey)
   }
 }
 
 class CompatSigner extends Signer {
-  constructor (index, signer, legacy) {
+  constructor(index, signer, legacy) {
     super(null, 0, index, signer)
     this.legacy = legacy
   }
 
-  verify (batch, signature) {
+  verify(batch, signature) {
     return crypto.verify(batch.signableCompat(this.legacy), signature, this.publicKey)
   }
 
-  sign (batch, keyPair) {
+  sign(batch, keyPair) {
     return crypto.sign(batch.signableCompat(this.legacy), keyPair.secretKey)
   }
 }
 
 module.exports = class Verifier {
-  constructor (manifestHash, manifest, { compat = isCompat(manifestHash, manifest), legacy = false } = {}) {
+  constructor(
+    manifestHash,
+    manifest,
+    { compat = isCompat(manifestHash, manifest), legacy = false } = {}
+  ) {
     const self = this
 
     this.manifestHash = manifestHash
@@ -62,16 +71,16 @@ module.exports = class Verifier {
     this.quorum = this.compat ? 1 : defaultQuorum(manifest)
 
     this.signers = manifest.signers ? manifest.signers.map(createSigner) : []
-    this.prologue = this.compat ? null : (manifest.prologue || null)
+    this.prologue = this.compat ? null : manifest.prologue || null
 
-    function createSigner (signer, index) {
+    function createSigner(signer, index) {
       return self.compat
         ? new CompatSigner(index, signer, legacy)
         : new Signer(manifestHash, self.version, index, signer)
     }
   }
 
-  _verifyCompat (batch, signature) {
+  _verifyCompat(batch, signature) {
     if (!signature) return false
 
     if (this.compat || (!this.allowPatch && this.signers.length === 1)) {
@@ -81,7 +90,7 @@ module.exports = class Verifier {
     return this._verifyMulti(batch, signature)
   }
 
-  _inflate (signature) {
+  _inflate(signature) {
     if (this.version >= 1) return multisig.inflate(signature)
     const { proofs, patch } = multisig.inflatev0(signature)
 
@@ -91,7 +100,7 @@ module.exports = class Verifier {
     }
   }
 
-  _verifyMulti (batch, signature) {
+  _verifyMulti(batch, signature) {
     if (!signature || this.quorum === 0) return false
 
     const { proofs, patch } = this._inflate(signature)
@@ -109,7 +118,14 @@ module.exports = class Verifier {
         tree = batch.clone()
 
         const upgrade = generateUpgrade(nodes, batch.length, inp.patch)
-        const proof = { fork: tree.fork, block: null, hash: null, seek: null, upgrade, manifest: null }
+        const proof = {
+          fork: tree.fork,
+          block: null,
+          hash: null,
+          seek: null,
+          upgrade,
+          manifest: null
+        }
 
         try {
           if (!tree.verifyUpgrade(proof)) return false
@@ -128,7 +144,7 @@ module.exports = class Verifier {
     return true
   }
 
-  verify (batch, signature) {
+  verify(batch, signature) {
     if (this.version === 0) {
       return this._verifyCompat(batch, signature)
     }
@@ -141,7 +157,7 @@ module.exports = class Verifier {
   }
 
   // TODO: better api for this that is more ... multisig-ey
-  sign (batch, keyPair) {
+  sign(batch, keyPair) {
     if (!keyPair || !keyPair.secretKey) throw BAD_ARGUMENT('No key pair was passed')
 
     for (const s of this.signers) {
@@ -155,45 +171,47 @@ module.exports = class Verifier {
     throw BAD_ARGUMENT('Public key is not a declared signer')
   }
 
-  assemble (inputs) {
+  assemble(inputs) {
     return this.version === 0 ? multisig.assemblev0(inputs) : multisig.assemble(inputs)
   }
 
-  static manifestHash (manifest) {
+  static manifestHash(manifest) {
     return manifestHash(manifest)
   }
 
-  static encodeManifest (manifest) {
+  static encodeManifest(manifest) {
     return c.encode(m.manifest, manifest)
   }
 
-  static decodeManifest (manifest) {
+  static decodeManifest(manifest) {
     return c.decode(m.manifest, manifest)
   }
 
-  static defaultSignerManifest (publicKey) {
+  static defaultSignerManifest(publicKey) {
     return {
       version: 1,
       hash: 'blake2b',
       allowPatch: false,
       quorum: 1,
-      signers: [{
-        signature: 'ed25519',
-        namespace: caps.DEFAULT_NAMESPACE,
-        publicKey
-      }],
+      signers: [
+        {
+          signature: 'ed25519',
+          namespace: caps.DEFAULT_NAMESPACE,
+          publicKey
+        }
+      ],
       prologue: null,
       linked: null,
       userData: null
     }
   }
 
-  static fromManifest (manifest, opts) {
+  static fromManifest(manifest, opts) {
     const m = this.createManifest(manifest)
     return new this(manifestHash(m), m, opts)
   }
 
-  static createManifest (inp) {
+  static createManifest(inp) {
     if (!inp) return null
 
     const manifest = {
@@ -210,7 +228,10 @@ module.exports = class Verifier {
     if (inp.hash && inp.hash !== 'blake2b') throw BAD_ARGUMENT('Only Blake2b hashes are supported')
 
     if (inp.prologue) {
-      if (!(b4a.isBuffer(inp.prologue.hash) && inp.prologue.hash.byteLength === 32) || !(inp.prologue.length >= 0)) {
+      if (
+        !(b4a.isBuffer(inp.prologue.hash) && inp.prologue.hash.byteLength === 32) ||
+        !(inp.prologue.length >= 0)
+      ) {
         throw BAD_ARGUMENT('Invalid prologue')
       }
 
@@ -237,36 +258,40 @@ module.exports = class Verifier {
     return manifest
   }
 
-  static isValidManifest (key, manifest) {
+  static isValidManifest(key, manifest) {
     return b4a.equals(key, manifestHash(manifest))
   }
 
-  static isCompat (key, manifest) {
+  static isCompat(key, manifest) {
     return isCompat(key, manifest)
   }
 
-  static sign (manifest, batch, keyPair, opts) {
+  static sign(manifest, batch, keyPair, opts) {
     return Verifier.fromManifest(manifest, opts).sign(batch, keyPair)
   }
 }
 
-function toMap (nodes) {
+function toMap(nodes) {
   const m = new Map()
   for (const node of nodes) m.set(node.index, node)
   return m
 }
 
-function isCompat (key, manifest) {
-  return !!(manifest && manifest.signers.length === 1 && b4a.equals(key, manifest.signers[0].publicKey))
+function isCompat(key, manifest) {
+  return !!(
+    manifest &&
+    manifest.signers.length === 1 &&
+    b4a.equals(key, manifest.signers[0].publicKey)
+  )
 }
 
-function defaultQuorum (man) {
+function defaultQuorum(man) {
   if (typeof man.quorum === 'number') return man.quorum
   if (!man.signers || !man.signers.length) return 0
   return (man.signers.length >> 1) + 1
 }
 
-function generateUpgrade (patch, start, length) {
+function generateUpgrade(patch, start, length) {
   const upgrade = { start, length, nodes: null, additionalNodes: [], signature: null }
 
   const from = start * 2
@@ -300,7 +325,7 @@ function generateUpgrade (patch, start, length) {
   return upgrade
 }
 
-function parseSigner (signer) {
+function parseSigner(signer) {
   validateSigner(signer)
   return {
     signature: 'ed25519',
@@ -309,12 +334,13 @@ function parseSigner (signer) {
   }
 }
 
-function validateSigner (signer) {
+function validateSigner(signer) {
   if (!signer || !signer.publicKey) throw BAD_ARGUMENT('Signer missing public key')
-  if (signer.signature && signer.signature !== 'ed25519') throw BAD_ARGUMENT('Only Ed25519 signatures are supported')
+  if (signer.signature && signer.signature !== 'ed25519')
+    throw BAD_ARGUMENT('Only Ed25519 signatures are supported')
 }
 
-function manifestHash (manifest) {
+function manifestHash(manifest) {
   const state = { start: 0, end: 32, buffer: null }
   m.manifest.preencode(state, manifest)
   state.buffer = b4a.allocUnsafe(state.end)
@@ -323,7 +349,7 @@ function manifestHash (manifest) {
   return crypto.hash(state.buffer)
 }
 
-function proofToVersion1 (proof) {
+function proofToVersion1(proof) {
   return {
     signer: proof.signer,
     signature: proof.signature,
@@ -331,7 +357,7 @@ function proofToVersion1 (proof) {
   }
 }
 
-function getManifestVersion (inp) {
+function getManifestVersion(inp) {
   if (typeof inp.version === 'number') return inp.version
   if (inp.linked && inp.linked.length) return 2
   if (inp.userData) return 2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "hypercore",
-  "version": "11.16.2",
+  "version": "11.17.0",
   "description": "Hypercore is a secure, distributed append-only log",
   "main": "index.js",
   "scripts": {
-    "test": "standard && brittle test/all.js",
+    "format": "prettier --write .",
+    "test": "prettier --check . && brittle test/all.js",
     "test:bare": "bare test/all.js",
     "test:generate": "brittle -r test/all.js test/*.js"
   },
@@ -68,11 +69,12 @@
     "brittle": "^3.0.0",
     "debugging-stream": "^3.1.0",
     "hyperswarm": "^4.3.6",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^2.0.0",
     "rache": "^1.0.0",
     "range-parser": "^1.2.1",
     "resolve-reject-promise": "^1.1.0",
     "speedometer": "^1.1.0",
-    "standard": "^17.0.0",
     "test-tmp": "^1.0.2",
     "tiny-byte-size": "^1.1.0",
     "udx-native": "^1.6.1",