corestore 6.0.1-alpha.11 → 6.0.1-alpha.14

package/.github/workflows/test-node.yml

@@ -1,23 +1,22 @@
-name: Test on Node.js
-
+name: Build Status
 on:
   push:
     branches:
-      - main
+      - master
   pull_request:
     branches:
-      - main
+      - master
 jobs:
   build:
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [lts/*]
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v2
       with:
         node-version: ${{ matrix.node-version }}
     - run: npm install

package/index.js

@@ -25,12 +25,43 @@ module.exports = class Corestore extends EventEmitter {
     this._namespace = opts._namespace || DEFAULT_NAMESPACE
     this._replicationStreams = opts._streams || []
     this._streamSessions = opts._streamSessions || new Map()
+    this._sessions = new Set() // sessions for THIS namespace
+
+    this._findingPeersCount = 0
+    this._findingPeers = []
 
     this._opening = opts._opening ? opts._opening.then(() => this._open()) : this._open()
     this._opening.catch(safetyCatch)
     this.ready = () => this._opening
   }
 
+  findingPeers () {
+    let done = false
+    this._incFindingPeers()
+
+    return () => {
+      if (done) return
+      done = true
+      this._decFindingPeers()
+    }
+  }
+
+  _incFindingPeers () {
+    if (++this._findingPeersCount !== 1) return
+
+    for (const core of this._sessions) {
+      this._findingPeers.push(core.findingPeers())
+    }
+  }
+
+  _decFindingPeers () {
+    if (--this._findingPeersCount !== 0) return
+
+    while (this._findingPeers.length > 0) {
+      this._findingPeers.pop()()
+    }
+  }
+
   async _open () {
     if (this.keys) {
       this.keys = await this.keys // opts.keys can be a Promise that resolves to a KeyManager
@@ -43,7 +74,7 @@ module.exports = class Corestore extends EventEmitter {
     if (opts._discoveryKey) {
       return {
         keyPair: null,
-        sign: null,
+        auth: null,
         discoveryKey: opts._discoveryKey
       }
     }
@@ -54,16 +85,17 @@ module.exports = class Corestore extends EventEmitter {
           secretKey: opts.secretKey
         },
         sign: opts.sign,
+        auth: opts.auth,
         discoveryKey: crypto.discoveryKey(opts.publicKey)
       }
     }
-    const { publicKey, sign } = await this.keys.createHypercoreKeyPair(opts.name, this._namespace)
+    const { publicKey, auth } = await this.keys.createHypercoreKeyPair(opts.name, this._namespace)
     return {
       keyPair: {
         publicKey,
         secretKey: null
       },
-      sign,
+      auth,
       discoveryKey: crypto.discoveryKey(publicKey)
     }
   }
@@ -80,11 +112,11 @@ module.exports = class Corestore extends EventEmitter {
     if (!name) return
 
     const namespace = this._getPrereadyUserData(core, USERDATA_NAMESPACE_KEY)
-    const { publicKey, sign } = await this.keys.createHypercoreKeyPair(b4a.toString(name), namespace)
+    const { publicKey, auth } = await this.keys.createHypercoreKeyPair(b4a.toString(name), namespace)
     if (!b4a.equals(publicKey, core.key)) throw new Error('Stored core key does not match the provided name')
 
-    // TODO: Should Hypercore expose a helper for this, or should preready return keypair/sign?
-    core.sign = sign
+    // TODO: Should Hypercore expose a helper for this, or should preready return keypair/auth?
+    core.auth = auth
     core.key = publicKey
     core.writable = true
   }
@@ -92,12 +124,12 @@ module.exports = class Corestore extends EventEmitter {
   async _preload (opts) {
     await this.ready()
 
-    const { discoveryKey, keyPair, sign } = await this._generateKeys(opts)
+    const { discoveryKey, keyPair, auth } = await this._generateKeys(opts)
     const id = b4a.toString(discoveryKey, 'hex')
 
     while (this.cores.has(id)) {
       const existing = this.cores.get(id)
-      if (existing.opened && !existing.closing) return { from: existing, keyPair, sign }
+      if (existing.opened && !existing.closing) return { from: existing, keyPair, auth }
       if (!existing.opened) {
         await existing.ready().catch(safetyCatch)
       } else if (existing.closing) {
@@ -119,7 +151,7 @@ module.exports = class Corestore extends EventEmitter {
       autoClose: true,
       encryptionKey: opts.encryptionKey || null,
       userData,
-      sign: null,
+      auth,
       createIfMissing: !opts._discoveryKey,
       keyPair: keyPair && keyPair.publicKey
         ? {
@@ -144,7 +176,7 @@ module.exports = class Corestore extends EventEmitter {
       this.cores.delete(id)
     })
 
-    return { from: core, keyPair, sign }
+    return { from: core, keyPair, auth }
   }
 
   get (opts = {}) {
@@ -154,6 +186,19 @@ module.exports = class Corestore extends EventEmitter {
       name: null,
       preload: () => this._preload(opts)
     })
+
+    this._sessions.add(core)
+    if (this._findingPeersCount > 0) {
+      this._findingPeers.push(core.findingPeers())
+    }
+
+    core.once('close', () => {
+      // technically better to also clear _findingPeers if we added it,
+      // but the lifecycle for those are pretty short so prob not worth the complexity
+      // as _decFindingPeers clear them all.
+      this._sessions.delete(core)
+    })
+
     return core
   }
 
@@ -201,7 +246,7 @@ module.exports = class Corestore extends EventEmitter {
 
   async _close () {
     await this._opening
-    if (!this._namespace.equals(DEFAULT_NAMESPACE)) return // namespaces should not release resources on close
+    if (!b4a.equals(this._namespace, DEFAULT_NAMESPACE)) return // namespaces should not release resources on close
     const closePromises = []
     for (const core of this.cores.values()) {
       closePromises.push(core.close())

package/lib/keys.js

@@ -28,7 +28,12 @@ module.exports = class KeyManager {
     const keyPair = {
       publicKey: b4a.allocUnsafe(sodium.crypto_sign_PUBLICKEYBYTES),
       _secretKey: b4a.alloc(sodium.crypto_sign_SECRETKEYBYTES),
-      sign: (msg) => this._sign(keyPair, msg)
+      auth: {
+        sign: (msg) => this._sign(keyPair, msg),
+        verify: (signable, signature) => {
+          return sodium.crypto_sign_detached(signature, signable, keyPair.publicKey)
+        }
+      }
     }
 
     sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair._secretKey, this.createSecret(name, token))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corestore",
-  "version": "6.0.1-alpha.11",
+  "version": "6.0.1-alpha.14",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "scripts": {
@@ -22,9 +22,8 @@
   "devDependencies": {
     "brittle": "^1.6.0",
     "random-access-file": "^2.2.0",
-    "random-access-memory": "^3.1.2",
-    "standardx": "^7.0.0",
-    "tmp-promise": "^3.0.2"
+    "random-access-memory": "^4.0.0",
+    "standardx": "^7.0.0"
   },
   "dependencies": {
     "b4a": "^1.3.1",

package/test/all.js

@@ -1,7 +1,8 @@
 const { test, configure } = require('brittle')
 const crypto = require('hypercore-crypto')
 const ram = require('random-access-memory')
-const tmp = require('tmp-promise')
+const os = require('os')
+const path = require('path')
 
 const Corestore = require('..')
 
@@ -99,8 +100,8 @@ test('replicating cores created after replication begins', async function (t) {
 })
 
 test('replicating cores using discovery key hook', async function (t) {
-  const dir = await tmp.dir({ unsafeCleanup: true })
-  let store1 = new Corestore(dir.path)
+  const dir = tmpdir()
+  let store1 = new Corestore(dir)
   const store2 = new Corestore(ram)
 
   const core = store1.get({ name: 'main' })
@@ -108,15 +109,13 @@ test('replicating cores using discovery key hook', async function (t) {
   const key = core.key
 
   await store1.close()
-  store1 = new Corestore(dir.path)
+  store1 = new Corestore(dir)
 
   const s = store1.replicate(true, { live: true })
   s.pipe(store2.replicate(false, { live: true })).pipe(s)
 
   const core2 = store2.get(key)
   t.alike(await core2.get(0), Buffer.from('hello'))
-
-  await dir.cleanup()
 })
 
 test('nested namespaces', async function (t) {
@@ -144,9 +143,9 @@ test('core uncached when all sessions close', async function (t) {
 })
 
 test('writable core loaded from name userData', async function (t) {
-  const dir = await tmp.dir({ unsafeCleanup: true })
+  const dir = tmpdir()
 
-  let store = new Corestore(dir.path)
+  let store = new Corestore(dir)
   let core = store.get({ name: 'main' })
   await core.ready()
   const key = core.key
@@ -156,7 +155,7 @@ test('writable core loaded from name userData', async function (t) {
   t.is(core.length, 1)
 
   await store.close()
-  store = new Corestore(dir.path)
+  store = new Corestore(dir)
   core = store.get(key)
   await core.ready()
 
@@ -165,25 +164,21 @@ test('writable core loaded from name userData', async function (t) {
   t.is(core.length, 2)
   t.alike(await core.get(0), Buffer.from('hello'))
   t.alike(await core.get(1), Buffer.from('world'))
-
-  await dir.cleanup()
 })
 
 test('storage locking', async function (t) {
-  const dir = await tmp.dir({ unsafeCleanup: true })
+  const dir = tmpdir()
 
-  const store1 = new Corestore(dir.path)
+  const store1 = new Corestore(dir)
   await store1.ready()
 
-  const store2 = new Corestore(dir.path)
+  const store2 = new Corestore(dir)
   try {
     await store2.ready()
     t.fail('dir should have been locked')
   } catch {
     t.pass('dir was locked')
   }
-
-  await dir.cleanup()
 })
 
 test('closing a namespace does not close cores', async function (t) {
@@ -205,3 +200,53 @@ test('closing a namespace does not close cores', async function (t) {
   t.ok(core1.closed)
   t.ok(core2.closed)
 })
+
+test('findingPeers', async function (t) {
+  t.plan(6)
+
+  const store = new Corestore(ram)
+
+  const ns1 = store.namespace('ns1')
+  const ns2 = store.namespace('ns2')
+
+  const a = ns1.get(Buffer.alloc(32).fill('a'))
+  const b = ns2.get(Buffer.alloc(32).fill('b'))
+
+  const done = ns1.findingPeers()
+
+  let aUpdated = false
+  let bUpdated = false
+  let cUpdated = false
+
+  const c = ns1.get(Buffer.alloc(32).fill('c'))
+
+  a.update().then(function (bool) {
+    aUpdated = true
+  })
+
+  b.update().then(function (bool) {
+    bUpdated = true
+  })
+
+  c.update().then(function (bool) {
+    cUpdated = true
+  })
+
+  await new Promise(resolve => setImmediate(resolve))
+
+  t.is(aUpdated, false)
+  t.is(bUpdated, true)
+  t.is(cUpdated, false)
+
+  done()
+
+  await new Promise(resolve => setImmediate(resolve))
+
+  t.is(aUpdated, true)
+  t.is(bUpdated, true)
+  t.is(cUpdated, true)
+})
+
+function tmpdir () {
+  return path.join(os.tmpdir(), 'corestore-' + Math.random().toString(16).slice(2))
+}

package/test/keys.js

@@ -41,7 +41,7 @@ test('short user-provided token will throw', async t => {
 })
 
 test('persistent storage regenerates keys correctly', async t => {
-  const testPath = p.resolve(__dirname, 'test-data')
+  const testPath = p.join(__dirname, 'test-data')
 
   const keys1 = await KeyManager.fromStorage((name) => raf(testPath, { directory: testPath }))
   const kp1 = await keys1.createHypercoreKeyPair('core1')
@@ -51,6 +51,9 @@ test('persistent storage regenerates keys correctly', async t => {
 
   t.alike(kp1.publicKey, kp2.publicKey)
 
+  await keys1.close()
+  await keys2.close()
+
   await fs.promises.rm(testPath, { recursive: true })
 })