libp2r2p 0.0.1

package/tests/idb.test.js

@@ -0,0 +1,91 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { IDBFactory } from 'fake-indexeddb'
+import { run } from '../idb/index.js'
+
+function deferred () {
+  let resolve
+  let reject
+  const promise = new Promise((nextResolve, nextReject) => {
+    resolve = nextResolve
+    reject = nextReject
+  })
+  return { promise, resolve, reject }
+}
+
+function transactionDone (tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve()
+    tx.onabort = () => reject(tx.error || new Error('IDB_TRANSACTION_ABORTED'))
+    tx.onerror = () => reject(tx.error || new Error('IDB_TRANSACTION_FAILED'))
+  })
+}
+
+function openRowsDb () {
+  const indexedDB = new IDBFactory()
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open('idb-run-test', 1)
+    request.onerror = () => reject(request.error)
+    request.onupgradeneeded = () => {
+      const store = request.result.createObjectStore('rows', { keyPath: 'id' })
+      store.createIndex('byGroup', 'group')
+    }
+    request.onsuccess = () => resolve(request.result)
+  })
+}
+
+test('run performs store and index requests inside a shared transaction', async () => {
+  const db = await openRowsDb()
+  const tx = db.transaction(['rows'], 'readwrite')
+  const done = transactionDone(tx)
+
+  await run('put', [{ id: 'one', group: 'alpha', value: 1 }], 'rows', null, { db, tx })
+  await run('put', [{ id: 'two', group: 'beta', value: 2 }], 'rows', null, { db, tx })
+  const found = await run('get', ['alpha'], 'rows', 'byGroup', { db, tx })
+
+  assert.equal(found.result.id, 'one')
+  await done
+  db.close()
+})
+
+test('run supports the reusable deferred cursor pattern', async () => {
+  const db = await openRowsDb()
+  const setup = db.transaction(['rows'], 'readwrite')
+  const setupDone = transactionDone(setup)
+  await run('put', [{ id: 'one', group: 'alpha' }], 'rows', null, { db, tx: setup })
+  await run('put', [{ id: 'two', group: 'beta' }], 'rows', null, { db, tx: setup })
+  await setupDone
+
+  const tx = db.transaction(['rows'], 'readonly')
+  const done = transactionDone(tx)
+  const p = deferred()
+  let cursor = (await run('openCursor', [], 'rows', null, { db, tx, p })).result
+  const ids = []
+  while (cursor) {
+    ids.push(cursor.value.id)
+    Object.assign(p, deferred())
+    cursor.continue()
+    cursor = (await p.promise).result
+  }
+
+  assert.deepEqual(ids, ['one', 'two'])
+  await done
+  db.close()
+})
+
+test('run aborts a transaction when a request fails', async () => {
+  const db = await openRowsDb()
+  const tx = db.transaction(['rows'], 'readwrite')
+  const done = transactionDone(tx)
+
+  await run('add', [{ id: 'one', group: 'alpha' }], 'rows', null, { db, tx })
+  await assert.rejects(
+    run('add', [{ id: 'one', group: 'beta' }], 'rows', null, { db, tx })
+  )
+  await assert.rejects(done)
+
+  const read = db.transaction(['rows'], 'readonly')
+  const row = await run('get', ['one'], 'rows', null, { db, tx: read })
+  assert.equal(row.result, undefined)
+  db.close()
+})

package/tests/nip44-v3.test.js

@@ -0,0 +1,73 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { getPublicKey } from 'nostr-tools'
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import * as nip44v3 from '../nip44-v3/index.js'
+import { bytesToHex, hexToBytes } from '../base16/index.js'
+
+const vectors = JSON.parse(readFileSync(new URL('./fixtures/nip44v3-vectors.json', import.meta.url), 'utf8'))
+
+function pubOf (sec) {
+  return getPublicKey(hexToBytes(sec))
+}
+
+test('nip44-v3 passes the vendored upstream self-test vectors', () => {
+  const fails = []
+  const check = (section, name, cond, detail = '') => {
+    if (!cond) fails.push(`[${section}] ${name}${detail ? `: ${detail}` : ''}`)
+  }
+
+  for (const [i, v] of (vectors.encrypt_decrypt || []).entries()) {
+    const sec1 = hexToBytes(v.secret1)
+    const sec2 = hexToBytes(v.secret2)
+    const pub1 = pubOf(v.secret1)
+    const pub2 = pubOf(v.secret2)
+    const nonce = hexToBytes(v.nonce)
+    const scope = hexToBytes(v.scope_hex)
+    const plaintext = hexToBytes(v.plaintext_hex)
+    const keys = nip44v3.deriveKeys(sec1, pub2, nonce)
+    check('encrypt_decrypt', `ed[${i}] prk`, bytesToHex(keys.prk) === v.prk)
+    check('encrypt_decrypt', `ed[${i}] encryption_key`, bytesToHex(keys.encryption_key) === v.encryption_key)
+    check('encrypt_decrypt', `ed[${i}] mac_key`, bytesToHex(keys.mac_key) === v.mac_key)
+    check('encrypt_decrypt', `ed[${i}] encrypt party1`, nip44v3.encryptBytes(sec1, pub2, v.kind, scope, plaintext, nonce) === v.ciphertext)
+    check('encrypt_decrypt', `ed[${i}] encrypt party2`, nip44v3.encryptBytes(sec2, pub1, v.kind, scope, plaintext, nonce) === v.ciphertext)
+    check('encrypt_decrypt', `ed[${i}] decrypt party1`, bytesToHex(nip44v3.decryptBytes(sec1, pub2, v.kind, scope, v.ciphertext)) === v.plaintext_hex)
+    check('encrypt_decrypt', `ed[${i}] decrypt party2`, bytesToHex(nip44v3.decryptBytes(sec2, pub1, v.kind, scope, v.ciphertext)) === v.plaintext_hex)
+  }
+
+  for (const [i, v] of (vectors.decrypt_only || []).entries()) {
+    check('decrypt_only', `do[${i}]`, bytesToHex(nip44v3.decryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, hexToBytes(v.scope_hex), v.ciphertext)) === v.plaintext_hex)
+  }
+
+  for (const [i, v] of (vectors.long_encrypt_decrypt || []).entries()) {
+    const pattern = hexToBytes(v.pattern_hex)
+    const plaintext = new Uint8Array(pattern.length * v.repeat)
+    for (let r = 0; r < v.repeat; r++) plaintext.set(pattern, r * pattern.length)
+    const scope = hexToBytes(v.scope_hex)
+    const ciphertext = nip44v3.encryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, scope, plaintext, hexToBytes(v.nonce))
+    check('long_encrypt_decrypt', `long[${i}] sha256`, bytesToHex(sha256(nip44v3.toBytes(ciphertext))) === v.ciphertext_sha256)
+    check('long_encrypt_decrypt', `long[${i}] round-trip`, bytesToHex(nip44v3.decryptBytes(hexToBytes(v.secret1), pubOf(v.secret2), v.kind, scope, ciphertext)) === bytesToHex(plaintext))
+  }
+
+  for (const row of (vectors.padded_length || [])) {
+    check('padded_length', `pad[${row[0]}]`, nip44v3.targetSize(row[0]) === row[1])
+  }
+
+  for (const [i, v] of (vectors.invalid_decryption || []).entries()) {
+    assert.throws(() => nip44v3.decryptBytes(hexToBytes(v.secret), v.public, v.kind, hexToBytes(v.scope_hex), v.ciphertext), Error, `invalid vector ${i} should reject`)
+  }
+
+  assert.deepEqual(fails, [])
+})
+
+test('nip44-v3 byte payload helpers round-trip arbitrary bytes', () => {
+  const alice = hexToBytes('1'.repeat(64))
+  const bob = hexToBytes('2'.repeat(64))
+  const plaintext = nip44v3.b64encode(new Uint8Array([0, 1, 2, 127, 128, 255]))
+  const ciphertext = nip44v3.nip07Encrypt(alice, getPublicKey(bob), '30078', 'spec.nostr.land/nip44v3', plaintext)
+
+  assert.equal(nip44v3.nip07Decrypt(bob, getPublicKey(alice), 30078, 'spec.nostr.land/nip44v3', ciphertext), plaintext)
+  assert.throws(() => nip44v3.nip07Decrypt(bob, getPublicKey(alice), 1, 'spec.nostr.land/nip44v3', ciphertext), /kind mismatch/)
+})