corestore 6.0.1-alpha.15 → 6.0.1-alpha.18

package/index.js

@@ -153,10 +153,10 @@ module.exports = class Corestore extends EventEmitter {
     while (this.cores.has(id)) {
       const existing = this.cores.get(id)
       if (existing.opened && !existing.closing) return { from: existing, keyPair, auth }
-      if (!existing.opened) {
-        await existing.ready().catch(safetyCatch)
-      } else if (existing.closing) {
+      if (existing.closing) {
         await existing.close()
+      } else {
+        await existing.ready().catch(safetyCatch)
       }
     }
 
@@ -202,7 +202,7 @@ module.exports = class Corestore extends EventEmitter {
     return { from: core, keyPair, auth }
   }
 
-  async createKeyPair (name) {
+  async createKeyPair (name, namespace = this._namespace) {
     if (!this.primaryKey) await this._opening
 
     const keyPair = {
@@ -211,12 +211,12 @@ module.exports = class Corestore extends EventEmitter {
       auth: {
         sign: (msg) => sign(keyPair, msg),
         verify: (signable, signature) => {
-          return sodium.crypto_sign_detached(signature, signable, keyPair.publicKey)
+          return crypto.verify(signable, signature, keyPair.publicKey)
         }
       }
     }
 
-    const seed = deriveSeed(this.primaryKey, this._namespace, name)
+    const seed = deriveSeed(this.primaryKey, namespace, name)
     sodium.crypto_sign_seed_keypair(keyPair.publicKey, keyPair.secretKey, seed)
 
     return keyPair
@@ -321,9 +321,7 @@ module.exports = class Corestore extends EventEmitter {
 
 function sign (keyPair, message) {
   if (!keyPair.secretKey) throw new Error('Invalid key pair')
-  const signature = b4a.allocUnsafe(sodium.crypto_sign_BYTES)
-  sodium.crypto_sign_detached(signature, message, keyPair.secretKey)
-  return signature
+  return crypto.sign(message, keyPair.secretKey)
 }
 
 function validateGetOptions (opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corestore",
-  "version": "6.0.1-alpha.15",
+  "version": "6.0.1-alpha.18",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "scripts": {

package/test/all.js

@@ -168,6 +168,30 @@ test('writable core loaded from name userData', async function (t) {
   t.alike(await core.get(1), Buffer.from('world'))
 })
 
+test('writable core loaded from name and namespace userData', async function (t) {
+  const dir = tmpdir()
+
+  let store = new Corestore(dir)
+  let core = store.namespace('ns1').get({ name: 'main' })
+  await core.ready()
+  const key = core.key
+
+  t.ok(core.writable)
+  await core.append('hello')
+  t.is(core.length, 1)
+
+  await store.close()
+  store = new Corestore(dir)
+  core = store.get(key)
+  await core.ready()
+
+  t.ok(core.writable)
+  await core.append('world')
+  t.is(core.length, 2)
+  t.alike(await core.get(0), Buffer.from('hello'))
+  t.alike(await core.get(1), Buffer.from('world'))
+})
+
 test('storage locking', async function (t) {
   const dir = tmpdir()
 
@@ -263,6 +287,44 @@ test('different primary keys yield different keypairs', async function (t) {
   t.unlike(kp1.publicKey, kp2.publicKey)
 })
 
+test('keypair auth sign', async function (t) {
+  const store = new Corestore(ram)
+  const keyPair = await store.createKeyPair('foo')
+  const message = b4a.from('hello world')
+
+  const sig = keyPair.auth.sign(message)
+
+  t.is(sig.length, 64)
+  t.ok(crypto.verify(message, sig, keyPair.publicKey))
+  t.absent(crypto.verify(message, b4a.alloc(64), keyPair.publicKey))
+})
+
+test('keypair auth verify', async function (t) {
+  const store = new Corestore(ram)
+  const keyPair = await store.createKeyPair('foo')
+  const message = b4a.from('hello world')
+
+  const sig = crypto.sign(message, keyPair.secretKey)
+
+  t.is(sig.length, 64)
+  t.ok(keyPair.auth.verify(message, sig))
+  t.absent(keyPair.auth.verify(message, b4a.alloc(64)))
+})
+
+test('core caching after reopen regression', async function (t) {
+  const store = new Corestore(ram)
+  const core = store.get({ name: 'test-core' })
+  await core.ready()
+
+  core.close()
+  await core.opening
+
+  const core2 = store.get({ name: 'test-core' })
+  await core2.ready()
+
+  t.pass('did not infinite loop')
+})
+
 function tmpdir () {
   return path.join(os.tmpdir(), 'corestore-' + Math.random().toString(16).slice(2))
 }