blind-peer 2.8.2 → 2.8.3

package/README.md

@@ -71,18 +71,16 @@ blind.addAutobaseBackground(autobase1)
 
 // Add another core
 blind.addCore(core1, autobase1.wakeupCapability.key)
-
 ```
 
 Related services:
 
- https://github.com/holepunchto/autobase-discovery
- https://github.com/HDegroote/dht-prometheus
-
+https://github.com/holepunchto/autobase-discovery
+https://github.com/HDegroote/dht-prometheus
 
 ## Programmatic Usage
 
-``` js
+```js
 const BlindPeer = require('blind-peer')
 ```
 

package/bin.js

@@ -16,20 +16,50 @@ const BlindPeer = require('.')
 const SERVICE_NAME = 'blind-peer'
 const DEFAULT_STORAGE_LIMIT_MB = 100_000
 
-const cmd = command('blind-peer',
+const cmd = command(
+  'blind-peer',
   flag('--storage|-s [path]', 'Storage path, defaults to ./blind-peer'),
-  flag('--port|-p [int]', 'DHT Port to try to bind to. Only relevant when that port is not firewalled. (defaults to a random port)'),
-  flag('--trusted-peer|-t [trusted-peer]', 'Public key of a trusted peer (allowed to set announce: true). Can be more than 1.').multiple(),
+  flag(
+    '--port|-p [int]',
+    'DHT Port to try to bind to. Only relevant when that port is not firewalled. (defaults to a random port)'
+  ),
+  flag(
+    '--trusted-peer|-t [trusted-peer]',
+    'Public key of a trusted peer (allowed to set announce: true). Can be more than 1.'
+  ).multiple(),
   flag('--debug|-d', 'Enable debug mode (more logs)'),
-  flag(`--max-storage|-m [int]', 'Max storage usage, in Mb (defaults to ${DEFAULT_STORAGE_LIMIT_MB})`),
-  flag('--autodiscovery-rpc-key [autodiscovery-rpc-key]', 'Public key where the autodiscovery service is listening. When set, the autodiscovery-seed must also be set. Can be hex or z32.'),
-  flag('--autodiscovery-seed [autodiscovery-seed]', '64-byte seed used to authenticate to the autodiscovery service.  Can be hex or z32.'),
-  flag('--autodiscovery-service-name [autodiscovery-service-name]', `Name under which to register the service (default ${SERVICE_NAME})`),
-  flag('--scraper-public-key [scraper-public-key]', 'Public key of a dht-prometheus scraper.  Can be hex or z32.'),
-  flag('--scraper-secret [scraper-secret]', 'Secret of the dht-prometheus scraper.  Can be hex or z32.'),
+  flag(
+    `--max-storage|-m [int]', 'Max storage usage, in Mb (defaults to ${DEFAULT_STORAGE_LIMIT_MB})`
+  ),
+  flag(
+    '--autodiscovery-rpc-key [autodiscovery-rpc-key]',
+    'Public key where the autodiscovery service is listening. When set, the autodiscovery-seed must also be set. Can be hex or z32.'
+  ),
+  flag(
+    '--autodiscovery-seed [autodiscovery-seed]',
+    '64-byte seed used to authenticate to the autodiscovery service.  Can be hex or z32.'
+  ),
+  flag(
+    '--autodiscovery-service-name [autodiscovery-service-name]',
+    `Name under which to register the service (default ${SERVICE_NAME})`
+  ),
+  flag(
+    '--scraper-public-key [scraper-public-key]',
+    'Public key of a dht-prometheus scraper.  Can be hex or z32.'
+  ),
+  flag(
+    '--scraper-secret [scraper-secret]',
+    'Secret of the dht-prometheus scraper.  Can be hex or z32.'
+  ),
   flag('--scraper-alias [scraper-alias]', '(optional) Alias with which to register to the scraper'),
-  flag('--log-streams', '(Temporary, Advanced): enable debug logs on the UDX streams managed by the dht'),
-  flag('--repl [repl]', 'Expose a repl-swarm at the passed-in seed (32 bytes in hex or z32 notation). Use for debugging only.'),
+  flag(
+    '--log-streams',
+    '(Temporary, Advanced): enable debug logs on the UDX streams managed by the dht'
+  ),
+  flag(
+    '--repl [repl]',
+    'Expose a repl-swarm at the passed-in seed (32 bytes in hex or z32 notation). Use for debugging only.'
+  ),
   async function ({ flags }) {
     const debug = flags.debug
     const logger = pino({
@@ -44,55 +74,75 @@ const cmd = command('blind-peer',
     const port = flags.port ? parseInt(flags.port) : null
 
     const maxBytes = 1_000_000 * parseInt(flags.maxStorage || DEFAULT_STORAGE_LIMIT_MB)
-    const trustedPubKeys = (flags.trustedPeer || []).map(k => idEnc.decode(k))
+    const trustedPubKeys = (flags.trustedPeer || []).map((k) => idEnc.decode(k))
 
     const blindPeer = new BlindPeer(storage, { trustedPubKeys, maxBytes, port })
 
-    blindPeer.on('flush-error', e => {
+    blindPeer.on('flush-error', (e) => {
       logger.warn(`Error while flushing the db: ${e.stack}`)
     })
 
-    blindPeer.on('add-core', (record, _, stream) => {
+    blindPeer.on('add-new-core', (record, _, stream) => {
       try {
-        logger.info(`add-core request received from peer ${streamToStr(stream)} for record ${recordToStr(record)}`)
+        if (record.announce) {
+          logger.info(
+            `add-core request received from peer ${streamToStr(stream)} for record ${recordToStr(record)}`
+          )
+        } else {
+          logger.debug(
+            `add-core request received from peer ${streamToStr(stream)} for record ${recordToStr(record)}`
+          )
+        }
       } catch (e) {
         logger.info(`Invalid add-core request received: ${e.stack}`)
         logger.info(record)
       }
     })
     blindPeer.on('delete-blocked', (stream, { key }) => {
-      logger.info(`Blocked delete-core request from untrusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}`)
+      logger.info(
+        `Blocked delete-core request from untrusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}`
+      )
     })
     blindPeer.on('delete-core', (stream, { key, existing }) => {
-      logger.info(`Received delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Existing: ${existing}`)
+      logger.info(
+        `Received delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Existing: ${existing}`
+      )
     })
     blindPeer.on('delete-core-end', (stream, { key, announced }) => {
-      logger.info(`Completed delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Was announced: ${announced}`)
+      logger.info(
+        `Completed delete-core request from trusted peer ${streamToStr(stream)} for core ${idEnc.normalize(key)}. Was announced: ${announced}`
+      )
     })
 
     blindPeer.on('downgrade-announce', ({ record, remotePublicKey }) => {
       try {
-        logger.info(`Downgraded announce for peer ${idEnc.normalize(remotePublicKey)} because the peer is not trusted (Original: ${recordToStr(record)})`)
+        logger.info(
+          `Downgraded announce for peer ${idEnc.normalize(remotePublicKey)} because the peer is not trusted (Original: ${recordToStr(record)})`
+        )
       } catch (e) {
         logger.error(`Unexpected error while logging downgrade-announce: ${e.stack}`)
       }
     })
 
-    blindPeer.on('announce-core', core => {
+    blindPeer.on('announce-core', (core) => {
       logger.info(`Started announcing core ${coreToInfo(core, true)}`)
     })
-    blindPeer.on('core-downloaded', core => {
+    blindPeer.on('core-downloaded', (core) => {
       logger.info(`Announced core fully downloaded: ${coreToInfo(core, true)}`)
     })
-    blindPeer.on('core-append', core => {
+    blindPeer.on('core-append', (core) => {
       logger.info(`Detected announced-core length update: ${coreToInfo(core, true)}`)
     })
 
     blindPeer.on('gc-start', ({ bytesToClear }) => {
-      logger.info(`Starting GC, trying to clear ${byteSize(bytesToClear)} (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`)
+      logger.info(
+        `Starting GC, trying to clear ${byteSize(bytesToClear)} (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`
+      )
     })
     blindPeer.on('gc-done', ({ bytesCleared }) => {
-      logger.info(`Completed GC, cleared ${byteSize(bytesCleared)} bytes (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`)
+      logger.info(
+        `Completed GC, cleared ${byteSize(bytesCleared)} bytes (bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)})`
+      )
     })
     if (debug) {
       blindPeer.on('core-activity', (core) => {
@@ -104,12 +154,16 @@ const cmd = command('blind-peer',
       const address = `${from.stream?.rawStream?.remoteHost}:${from.stream?.rawStream?.remotePort}`
       const remotePubKey = idEnc.normalize(from.stream.remotePublicKey)
       const key = idEnc.normalize(core.key)
-      logger.warn(`Received invalid request for core ${key} from peer ${remotePubKey} at ${address} (${err.stack})`)
+      logger.warn(
+        `Received invalid request for core ${key} from peer ${remotePubKey} at ${address} (${err.stack})`
+      )
     })
 
     logger.info(`Using storage '${storage}'`)
     if (trustedPubKeys.length > 0) {
-      logger.info(`Trusted public keys:\n  -${[...blindPeer.trustedPubKeys].map(idEnc.normalize).join('\n  -')}`)
+      logger.info(
+        `Trusted public keys:\n  -${[...blindPeer.trustedPubKeys].map(idEnc.normalize).join('\n  -')}`
+      )
     }
 
     let instrumentation = null
@@ -158,11 +212,16 @@ const cmd = command('blind-peer',
             const pendingWrites = stream._wreqs.length - stream._wfree.length
             if (pendingWrites >= 100) {
               nrBigStreams++
-              logger.warn(`Stream ${stream.id} (remote id: ${stream.remoteId}) has ${pendingWrites} pending writes:\nStream JSON: ${JSON.stringify(stream.toJSON(), null, 1)}\nSocket json: ${stream.socket ? JSON.stringify(stream.socket.toJSON(), null, 1) : 'none'}\nhex streamhandle: ${b4a.toString(stream._handle, 'hex')}\nhex socket handle: ${stream.socket ? b4a.toString(stream.socket._handle, 'hex') : 'none'}`)
+              logger.warn(
+                `Stream ${stream.id} (remote id: ${stream.remoteId}) has ${pendingWrites} pending writes:\nStream JSON: ${JSON.stringify(stream.toJSON(), null, 1)}\nSocket json: ${stream.socket ? JSON.stringify(stream.socket.toJSON(), null, 1) : 'none'}\nhex streamhandle: ${b4a.toString(stream._handle, 'hex')}\nhex socket handle: ${stream.socket ? b4a.toString(stream.socket._handle, 'hex') : 'none'}`
+              )
             }
           }
-          if (nrBigStreams > 0) logger.warn(`Total streams with many pending writes: ${nrBigStreams}`)
-        } catch (e) { // we don't want to crash the process with our debugging
+          if (nrBigStreams > 0) {
+            logger.warn(`Total streams with many pending writes: ${nrBigStreams}`)
+          }
+        } catch (e) {
+          // we don't want to crash the process with our debugging
           logger.warn(`logStreams errored unexpectedly: ${e.stack}`)
         }
       }, 30_000)
@@ -170,8 +229,12 @@ const cmd = command('blind-peer',
 
     await blindPeer.listen()
 
-    logger.info(`Blind peer listening, local address is ${blindPeer.swarm.dht.localAddress().host}:${blindPeer.swarm.dht.localAddress().port}`)
-    logger.info(`Bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)}`)
+    logger.info(
+      `Blind peer listening, local address is ${blindPeer.swarm.dht.localAddress().host}:${blindPeer.swarm.dht.localAddress().port}`
+    )
+    logger.info(
+      `Bytes allocated: ${byteSize(blindPeer.digest.bytesAllocated)} of ${byteSize(blindPeer.maxBytes)}`
+    )
 
     if (flags.autodiscoveryRpcKey) {
       const autodiscoveryRpcKey = idEnc.decode(flags.autodiscoveryRpcKey)
@@ -180,11 +243,20 @@ const cmd = command('blind-peer',
       const registerClient = new RegisterClient(autodiscoveryRpcKey, blindPeer.swarm.dht, seed)
 
       // No need to block on this, so we run it in the background
-      logger.info(`Registering own RPC key rpc key ${idEnc.normalize(blindPeer.publicKey)} with service '${serviceName}' at autodiscovery service ${idEnc.normalize(autodiscoveryRpcKey)} (using public key ${idEnc.normalize(registerClient.keyPair.publicKey)})`)
-      registerClient.putService(blindPeer.publicKey, serviceName)
-        .then(() => { logger.info('Successfully requested to be added to the autodiscovery service') })
-        .catch(e => { logger.warn(`Failed to register to the autodiscovery service: ${e.stack}`) })
-        .finally(() => { registerClient.close().catch(safetyCatch) })
+      logger.info(
+        `Registering own RPC key rpc key ${idEnc.normalize(blindPeer.publicKey)} with service '${serviceName}' at autodiscovery service ${idEnc.normalize(autodiscoveryRpcKey)} (using public key ${idEnc.normalize(registerClient.keyPair.publicKey)})`
+      )
+      registerClient
+        .putService(blindPeer.publicKey, serviceName)
+        .then(() => {
+          logger.info('Successfully requested to be added to the autodiscovery service')
+        })
+        .catch((e) => {
+          logger.warn(`Failed to register to the autodiscovery service: ${e.stack}`)
+        })
+        .finally(() => {
+          registerClient.close().catch(safetyCatch)
+        })
     }
 
     if (flags.scraperPublicKey) {
@@ -195,7 +267,9 @@ const cmd = command('blind-peer',
       const scraperSecret = idEnc.decode(flags.scraperSecret)
 
       let prometheusAlias = flags.scraperAlias
-      if (prometheusAlias && prometheusAlias.length > 99) throw new Error('The Prometheus alias must have length less than 100')
+      if (prometheusAlias && prometheusAlias.length > 99) {
+        throw new Error('The Prometheus alias must have length less than 100')
+      }
       if (!prometheusAlias) {
         prometheusAlias = `blind-peer-${idEnc.normalize(swarm.keyPair.publicKey)}`.slice(0, 99)
       }
@@ -219,17 +293,17 @@ const cmd = command('blind-peer',
   }
 )
 
-function recordToStr (record) {
+function recordToStr(record) {
   const discKey = hypCrypto.discoveryKey(record.key)
   return `DB Record for discovery key ${idEnc.normalize(discKey)} with priority: ${record.priority}. Announcing? ${record.announce}`
 }
 
-function streamToStr (stream) {
+function streamToStr(stream) {
   const pubKey = idEnc.normalize(stream.remotePublicKey)
   return `${pubKey}`
 }
 
-function coreToInfo (core, includePublicKey = false) {
+function coreToInfo(core, includePublicKey = false) {
   const discKey = hypCrypto.discoveryKey(core.key)
   let res = `Discovery key ${idEnc.normalize(discKey)} (${core.contiguousLength} / ${core.length}, ${core.peers.length} peers)`
   if (includePublicKey) res += `. Public key: ${idEnc.normalize(core.key)}`

package/index.js

@@ -18,7 +18,7 @@ const { AddCoreEncoding } = require('blind-peer-encodings')
 const { DeleteCoreEncoding } = require('blind-peer-encodings')
 
 class CoreTracker {
-  constructor (blindPeer, core) {
+  constructor(blindPeer, core) {
     this.blindPeer = blindPeer
     this.core = core
     this.destroyed = false
@@ -40,7 +40,7 @@ class CoreTracker {
     this.core.on('append', onupdate)
   }
 
-  _onupdate () {
+  _onupdate() {
     this.updated = true
     if (!this.record) return
 
@@ -50,7 +50,7 @@ class CoreTracker {
     this.blindPeer.flush().then(this.announceToReferrerBound, safetyCatch)
   }
 
-  _onactive () {
+  _onactive() {
     this.activated = true
 
     if (this.record) {
@@ -60,7 +60,8 @@ class CoreTracker {
     this.blindPeer.emit('core-activity', this.core, this.record)
   }
 
-  gc () { // TODO: support gc-ing till less than last block (required hypercore to support getting byteLength at arbitrary versions)
+  gc() {
+    // TODO: support gc-ing till less than last block (required hypercore to support getting byteLength at arbitrary versions)
     const bytesCleared = this.core.byteLength
     const blocksCleared = this.core.length
     this.record.bytesAllocated = this.core.byteLength - bytesCleared
@@ -76,7 +77,7 @@ class CoreTracker {
     return bytesCleared
   }
 
-  async refresh () {
+  async refresh() {
     await this.core.ready()
     if (this.destroyed) return
 
@@ -93,11 +94,14 @@ class CoreTracker {
     if (this.activated) this._onactive()
   }
 
-  announceToReferrer () {
+  announceToReferrer() {
     if (!this.record || !this.record.referrer) return
-    if (!this.referrerDiscoveryKey) this.referrerDiscoveryKey = crypto.discoveryKey(this.record.referrer)
+    if (!this.referrerDiscoveryKey)
+      this.referrerDiscoveryKey = crypto.discoveryKey(this.record.referrer)
 
-    const sessions = this.blindPeer.wakeup.getSessions(null, { discoveryKey: this.referrerDiscoveryKey })
+    const sessions = this.blindPeer.wakeup.getSessions(null, {
+      discoveryKey: this.referrerDiscoveryKey
+    })
     if (sessions.length === 0) return
 
     const wakeup = [{ key: this.core.key, length: this.core.length }]
@@ -116,21 +120,21 @@ class CoreTracker {
     }
   }
 
-  destroy () {
+  destroy() {
     if (this.destroyed) return
     this.destroyed = true
   }
 }
 
 class WakeupHandler {
-  constructor (db, key, discoveryKey) {
+  constructor(db, key, discoveryKey) {
     this.db = db
     this.key = key
     this.discoveryKey = discoveryKey
     this.active = false
   }
 
-  async onpeeractive (peer, session) {
+  async onpeeractive(peer, session) {
     const referrer = this.key
     const query = {
       gte: { referrer },
@@ -150,7 +154,10 @@ class WakeupHandler {
 }
 
 class BlindPeer extends ReadyResource {
-  constructor (rocks, { swarm, store, wakeup, maxBytes = 100_000_000_000, enableGc = true, trustedPubKeys, port } = {}) {
+  constructor(
+    rocks,
+    { swarm, store, wakeup, maxBytes = 100_000_000_000, enableGc = true, trustedPubKeys, port } = {}
+  ) {
     super()
 
     this.rocks = typeof rocks === 'string' ? new RocksDB(rocks) : rocks
@@ -181,36 +188,39 @@ class BlindPeer extends ReadyResource {
     }
   }
 
-  get encryptionPublicKey () {
+  get encryptionPublicKey() {
     return this.db.encryptionKeyPair.publicKey
   }
 
-  get publicKey () {
+  get publicKey() {
     return this.swarm.keyPair.publicKey
   }
 
-  get digest () {
+  get digest() {
     return this.db.digest
   }
 
-  get nrAnnouncedCores () {
+  get nrAnnouncedCores() {
     return this.announcedCores.size
   }
 
-  addTrustedPubKey (key) {
+  addTrustedPubKey(key) {
     this.trustedPubKeys.add(IdEnc.normalize(key))
   }
 
-  _isTrustedPeer (key) {
+  _isTrustedPeer(key) {
     return this.trustedPubKeys.has(IdEnc.normalize(key))
   }
 
-  async _open () {
+  async _open() {
     await this.store.ready()
 
     // legacy, we can remove once current ones are upgraded
     const { secretKey } = await this.store.createKeyPair('blind-mirror-swarm')
-    this.db = new BlindPeerDB(this.rocks.session(), { swarming: secretKey.subarray(0, 32), encryption: null })
+    this.db = new BlindPeerDB(this.rocks.session(), {
+      swarming: secretKey.subarray(0, 32),
+      encryption: null
+    })
     await this.db.ready()
 
     // We don't need to track our own db, so we set this handler after the db core opened
@@ -218,7 +228,8 @@ class BlindPeer extends ReadyResource {
 
     if (this.swarm === null) {
       const swarmOpts = { keyPair: this.db.swarmingKeyPair }
-      if (this._port) swarmOpts.port = typeof this._port === 'number' ? [this._port, this._port + 64] : this._port
+      if (this._port)
+        swarmOpts.port = typeof this._port === 'number' ? [this._port, this._port + 64] : this._port
       this.swarm = new Hyperswarm(swarmOpts)
     }
     this.swarm.on('connection', this._onconnection.bind(this))
@@ -232,7 +243,7 @@ class BlindPeer extends ReadyResource {
     this.flushInterval = setInterval(this.flush.bind(this), 10_000)
   }
 
-  async _onwakeup (discoveryKey, muxer) {
+  async _onwakeup(discoveryKey, muxer) {
     this.stats.wakeups++
 
     const auth = await this.store.storage.getAuth(discoveryKey)
@@ -256,16 +267,17 @@ class BlindPeer extends ReadyResource {
     stream.once('close', () => w.destroy())
   }
 
-  async listen () {
+  async listen() {
     if (!this.opened) await this.ready()
     return this.swarm.listen()
   }
 
-  needsGc () {
+  needsGc() {
     return this.digest.bytesAllocated >= this.maxBytes
   }
 
-  async _gc () { // Do not call directly (assumes lock)
+  async _gc() {
+    // Do not call directly (assumes lock)
     if (!this.needsGc()) return
 
     const bytesToClear = this.digest.bytesAllocated - this.maxBytes
@@ -302,7 +314,7 @@ class BlindPeer extends ReadyResource {
     this.emit('gc-done', { bytesCleared })
   }
 
-  _onreferrerupdates (updates) {
+  _onreferrerupdates(updates) {
     const pending = new Set()
 
     for (const u of updates) {
@@ -319,7 +331,7 @@ class BlindPeer extends ReadyResource {
     }
   }
 
-  _oncoreopen (core) {
+  _oncoreopen(core) {
     const session = new Hypercore({ core, weak: true })
     const id = b4a.toString(core.discoveryKey, 'hex')
     const tracker = new CoreTracker(this, session)
@@ -338,7 +350,8 @@ class BlindPeer extends ReadyResource {
     })
   }
 
-  async flush () { // not allowed to throw
+  async flush() {
+    // not allowed to throw
     if (!(await this.lock.lock())) return
     try {
       if (this.enableGc && this.needsGc()) await this._gc()
@@ -351,7 +364,7 @@ class BlindPeer extends ReadyResource {
     }
   }
 
-  _onconnection (conn) {
+  _onconnection(conn) {
     if (this.closing) {
       conn.destroy()
       return
@@ -369,7 +382,7 @@ class BlindPeer extends ReadyResource {
     rpc.respond('delete-core', DeleteCoreEncoding, this._ondeletecore.bind(this, conn))
   }
 
-  async _activateCore (stream, record) {
+  async _activateCore(stream, record) {
     this.stats.activations++
 
     const core = this.store.get({ key: record.key })
@@ -391,7 +404,7 @@ class BlindPeer extends ReadyResource {
     stream.on('close', () => core.close().catch(safetyCatch))
   }
 
-  async _announceCore (key) {
+  async _announceCore(key) {
     const coreId = IdEnc.normalize(key)
     if (this.announcedCores.has(coreId)) return
 
@@ -417,7 +430,7 @@ class BlindPeer extends ReadyResource {
     this.emit('announce-core', core)
   }
 
-  async _onaddcore (stream, record) {
+  async _onaddcore(stream, record) {
     if (!this.opened) await this.ready()
 
     record.priority = Math.min(record.priority, 1) // 2 is reserved for trusted peers
@@ -433,6 +446,7 @@ class BlindPeer extends ReadyResource {
     if (!existing || upgradeToAnnounce) {
       this.db.addCore(record)
       await this.flush() // flush now as important data
+      this.emit('add-new-core', record, true, stream)
     }
 
     if (record.referrer) {
@@ -457,13 +471,13 @@ class BlindPeer extends ReadyResource {
     return coreRecord
   }
 
-  async _ondeletecore (stream, { key }) {
+  async _ondeletecore(stream, { key }) {
     if (!this._isTrustedPeer(stream.remotePublicKey)) {
       this.emit('delete-blocked', stream, { key })
       throw new Error('Only trusted peers can delete cores')
     }
 
-    const existing = await this.db.getCoreRecord(key) !== null
+    const existing = (await this.db.getCoreRecord(key)) !== null
     this.emit('delete-core', stream, { key, existing })
     if (!existing) return false
 
@@ -502,7 +516,7 @@ class BlindPeer extends ReadyResource {
     return true
   }
 
-  async _close () {
+  async _close() {
     clearInterval(this.flushInterval)
     if (this.ownsWakeup) this.wakeup.destroy()
     if (this.ownsSwarm) await this.swarm.destroy()
@@ -512,68 +526,76 @@ class BlindPeer extends ReadyResource {
     await this.rocks.close()
   }
 
-  registerMetrics (promClient) {
+  registerMetrics(promClient) {
     const self = this
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_bytes_allocated',
       help: 'The amount of bytes allocated by the hyperdb (as reported in its digest)',
-      collect () {
+      collect() {
         this.set(self.digest.bytesAllocated)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_cores',
       help: 'The amount of cores (as reported in its digest)',
-      collect () {
+      collect() {
         this.set(self.digest.cores)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_cores_added',
       help: 'The total amount of add-core RPC requests that have been processed',
-      collect () {
+      collect() {
         this.set(self.stats.coresAdded)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_bytes_gcd',
       help: 'The total amount of bytes garbage collected since the process started',
-      collect () {
+      collect() {
         this.set(self.stats.bytesGcd)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_core_activations',
       help: 'The total amount of hypercore activations since the process started',
-      collect () {
+      collect() {
         this.set(self.stats.activations)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_wakeups',
       help: 'The total amount of hypercore wakeups since the process started',
-      collect () {
+      collect() {
         this.set(self.stats.wakeups)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_db_flushes',
       help: 'The total amount of database flushes since the process started',
-      collect () {
+      collect() {
         this.set(self.db.stats.flushes)
       }
     })
 
-    new promClient.Gauge({ // eslint-disable-line no-new
+    new promClient.Gauge({
+      // eslint-disable-line no-new
       name: 'blind_peer_announced_cores',
       help: 'The amount of announced cores',
-      collect () {
+      collect() {
         this.set(self.nrAnnouncedCores)
       }
     })

package/lib/db.js

@@ -8,7 +8,7 @@ const { definition: spec } = require('blind-peer-encodings')
 const MAX_PRIO = 2
 
 module.exports = class BlindPeerDB extends ReadyResource {
-  constructor (db, auth) {
+  constructor(db, auth) {
     super()
 
     this.db = HyperDB.rocks(db, spec)
@@ -29,19 +29,19 @@ module.exports = class BlindPeerDB extends ReadyResource {
     this.ready().catch(noop)
   }
 
-  find (col, q) {
+  find(col, q) {
     return this.db.find(col, q)
   }
 
-  get (col, q) {
+  get(col, q) {
     return this.db.get(col, q)
   }
 
-  getCoreRecord (key) {
+  getCoreRecord(key) {
     return this.get('@blind-peer/cores', { key })
   }
 
-  async _open () {
+  async _open() {
     await this.db.ready()
 
     const auth = await this.db.get('@blind-peer/auth')
@@ -63,7 +63,8 @@ module.exports = class BlindPeerDB extends ReadyResource {
     await this.db.flush()
   }
 
-  async flush () { // The caller is responsible for ensuring this runs in a lock
+  async flush() {
+    // The caller is responsible for ensuring this runs in a lock
     if (!this.opened) await this.ready()
 
     const coresAdding = this.coresAdding
@@ -96,9 +97,7 @@ module.exports = class BlindPeerDB extends ReadyResource {
       if (existing) {
         if (!info.announce && (info.priority || 0) <= existing.priority) continue // would be a downgrade, which we never want
 
-        existing.priority = Math.min(
-          Math.max(info.priority || 0, existing.priority)
-        )
+        existing.priority = Math.min(Math.max(info.priority || 0, existing.priority))
         existing.announce = info.announce || existing.announce
         existing.updated = time
         existing.active = time
@@ -128,7 +127,7 @@ module.exports = class BlindPeerDB extends ReadyResource {
 
       const updated = c.length !== core.length
 
-      bytesAllocated += (core.bytesAllocated - c.bytesAllocated)
+      bytesAllocated += core.bytesAllocated - c.bytesAllocated
 
       c.length = core.length
       c.bytesAllocated = core.bytesAllocated
@@ -153,38 +152,41 @@ module.exports = class BlindPeerDB extends ReadyResource {
     await tx.flush()
   }
 
-  async hasCore (key) {
+  async hasCore(key) {
     key = IdEnc.decode(key)
-    return await this.db.get('@blind-peer/cores', { key }) !== null
+    return (await this.db.get('@blind-peer/cores', { key })) !== null
   }
 
-  addCore (info) {
+  addCore(info) {
     this.coresAdding.push(info)
   }
 
-  deleteCore (key) {
+  deleteCore(key) {
     this.coresDeleting.push(key)
   }
 
-  updateCore (core, id) { // TODO: id is technically optional
+  updateCore(core, id) {
+    // TODO: id is technically optional
     this.coresUpdated.set(id, core)
   }
 
-  updated () {
-    return this.coresAdding.length > 0 || this.coresUpdated.size > 0 || this.coresDeleting.length > 0
+  updated() {
+    return (
+      this.coresAdding.length > 0 || this.coresUpdated.size > 0 || this.coresDeleting.length > 0
+    )
   }
 
-  createGcCandidateReadStream () {
+  createGcCandidateReadStream() {
     return this.db.find('@blind-peer/cores-by-activity')
   }
 
-  createAnnouncingCoresStream () {
+  createAnnouncingCoresStream() {
     return this.db.find('@blind-peer/cores-by-announce')
   }
 
-  async _close () {
+  async _close() {
     await this.db.close()
   }
 }
 
-function noop () {}
+function noop() {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blind-peer",
-  "version": "2.8.2",
+  "version": "2.8.3",
   "description": "Blind peers help keep hypercores available",
   "main": "index.js",
   "bin": {
@@ -37,8 +37,9 @@
     "brittle": "^3.7.0",
     "debounceify": "^1.1.0",
     "hyperdht": "^6.20.1",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^2.0.0",
     "prom-client": "^15.1.3",
-    "standard": "^17.1.2",
     "test-tmp": "^1.3.0"
   },
   "files": [
@@ -47,7 +48,9 @@
     "lib/"
   ],
   "scripts": {
-    "test": "standard && brittle test/*.js"
+    "format": "prettier --write .",
+    "test": "prettier --check . && brittle test/*.js",
+    "test:bare": "bare test/basic.js"
   },
   "repository": {
     "type": "git",