libp2r2p 0.0.2 → 0.2.0

package/base93/index.js

@@ -0,0 +1,193 @@
+// Derived from https://github.com/ticlo/arrow-code/blob/master/src/base93.ts
+// Apache-2.0. JSON-safe alphabet: space is included; double quote and
+// backslash are intentionally excluded.
+
+export const BASE93_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&'()*+,-./:;<=>?@[]^_`{|}~ "
+
+const ENCODING_TABLE = (() => {
+  const out = new Uint16Array(93)
+  for (let i = 0; i < out.length; i++) out[i] = BASE93_ALPHABET.charCodeAt(i)
+  return out
+})()
+
+const DECODING_TABLE = (() => {
+  const out = new Int16Array(128)
+  out.fill(-1)
+  for (let i = 0; i < BASE93_ALPHABET.length; i++) out[BASE93_ALPHABET.charCodeAt(i)] = i
+  return out
+})()
+
+function codesToString (codes, length) {
+  const chunkLength = 16384
+  let result = ''
+  for (let i = 0; i < length; i += chunkLength) {
+    result += String.fromCharCode.apply(
+      null,
+      Array.prototype.slice.call(codes, i, Math.min(i + chunkLength, length))
+    )
+  }
+  return result
+}
+
+function asBytes (bytes) {
+  if (bytes instanceof Uint8Array) return bytes
+  if (ArrayBuffer.isView(bytes)) return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  if (bytes instanceof ArrayBuffer) return new Uint8Array(bytes)
+  return Uint8Array.from(bytes)
+}
+
+export class Base93Encoder {
+  constructor (prefix = '') {
+    this.queuedBits = 0
+    this.bitCount = 0
+    this.parts = prefix ? [String(prefix)] : []
+    this.finished = false
+  }
+
+  update (bytes) {
+    if (this.finished) throw new Error('Base93 encoder is already finalized.')
+    const source = asBytes(bytes)
+    const output = new Uint16Array(Math.ceil(source.length * 8 / 6.5) + 4)
+    let position = 0
+    let queuedBits = this.queuedBits
+    let bitCount = this.bitCount
+
+    for (let i = 0; i < source.length; i++) {
+      queuedBits |= source[i] << bitCount
+      bitCount += 8
+      if (bitCount > 13) {
+        let value = queuedBits & 0x1fff
+        if (value > 456) {
+          queuedBits >>>= 13
+          bitCount -= 13
+        } else {
+          value = queuedBits & 0x3fff
+          queuedBits >>>= 14
+          bitCount -= 14
+        }
+        output[position++] = ENCODING_TABLE[value % 93]
+        output[position++] = ENCODING_TABLE[Math.floor(value / 93)]
+      }
+    }
+
+    this.queuedBits = queuedBits
+    this.bitCount = bitCount
+    if (position > 0) this.parts.push(codesToString(output, position))
+    return this
+  }
+
+  getEncoded () {
+    if (!this.finished) {
+      if (this.bitCount > 0) {
+        const output = new Uint16Array(2)
+        let position = 0
+        output[position++] = ENCODING_TABLE[this.queuedBits % 93]
+        if (this.bitCount > 7 || this.queuedBits > 92) {
+          output[position++] = ENCODING_TABLE[Math.floor(this.queuedBits / 93)]
+        }
+        this.parts.push(codesToString(output, position))
+      }
+      this.finished = true
+      this.queuedBits = 0
+      this.bitCount = 0
+    }
+    return this.parts.join('')
+  }
+}
+
+export function encode (bytes) {
+  return new Base93Encoder().update(bytes).getEncoded()
+}
+
+function decodeUnchecked (value) {
+  const output = new Uint8Array(Math.ceil(value.length * 7 / 8))
+  let queuedBits = 0
+  let bitCount = 0
+  let first = -1
+  let position = 0
+
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i)
+    if (code >= DECODING_TABLE.length || DECODING_TABLE[code] < 0) {
+      throw new Error(`Invalid Base93 character at offset ${i}.`)
+    }
+    const decoded = DECODING_TABLE[code]
+    if (first === -1) {
+      first = decoded
+      continue
+    }
+
+    const pair = first + decoded * 93
+    first = -1
+    queuedBits |= pair << bitCount
+    bitCount += (pair & 0x1fff) > 456 ? 13 : 14
+    while (bitCount > 7) {
+      output[position++] = queuedBits & 0xff
+      queuedBits >>>= 8
+      bitCount -= 8
+    }
+  }
+
+  if (first !== -1) output[position++] = (queuedBits | (first << bitCount)) & 0xff
+  return output.slice(0, position)
+}
+
+export function decode (text, offset = 0, length = -1) {
+  if (typeof text !== 'string') throw new TypeError('Base93 input must be a string.')
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > text.length) throw new RangeError('Invalid Base93 offset.')
+  if (!Number.isSafeInteger(length) || length < -1) throw new RangeError('Invalid Base93 length.')
+
+  const end = length < 0 ? text.length : Math.min(text.length, offset + length)
+  const encoded = text.slice(offset, end)
+  const bytes = decodeUnchecked(encoded)
+  if (encode(bytes) !== encoded) throw new Error('Non-canonical or truncated Base93 input.')
+  return bytes
+}
+
+function normalizeSource (source) {
+  if (typeof source === 'function') source = source()
+  if (typeof source === 'string') return [source]
+  if (source?.[Symbol.asyncIterator] || source?.[Symbol.iterator]) return source
+  throw new TypeError('Base93 stream source must be iterable.')
+}
+
+export class Base93Decoder {
+  constructor (source, { mimeType = '', preferTextStreamDecoding = false } = {}) {
+    this.source = normalizeSource(source)
+    this.asText = preferTextStreamDecoding && mimeType.startsWith('text/')
+  }
+
+  async * decodedValues () {
+    const textDecoder = this.asText ? new TextDecoder() : null
+    for await (const encoded of this.source) {
+      const bytes = decode(encoded)
+      const value = textDecoder ? textDecoder.decode(bytes, { stream: true }) : bytes
+      if (value.length > 0) yield value
+    }
+    if (textDecoder) {
+      const tail = textDecoder.decode()
+      if (tail.length > 0) yield tail
+    }
+  }
+
+  getDecoded () {
+    const iterator = this.decodedValues()[Symbol.asyncIterator]()
+    return new ReadableStream({
+      async pull (controller) {
+        try {
+          const { value, done } = await iterator.next()
+          if (done) controller.close()
+          else controller.enqueue(value)
+        } catch (error) {
+          controller.error(error)
+        }
+      },
+      async cancel () {
+        await iterator.return?.()
+      }
+    })
+  }
+}
+
+export default Base93Decoder

package/index.js

@@ -10,6 +10,7 @@ export * as idb from './idb/index.js'
 export * as idbQueue from './idb-queue/index.js'
 export * as key from './key/index.js'
 export * as network from './network/index.js'
+export * as nip19 from './nip19/index.js'
 export * as nip44v3 from './nip44-v3/index.js'
 export * as nip46 from './nip46/index.js'
 export * as privateChannel from './private-channel/index.js'

package/nip19/index.js

@@ -0,0 +1,305 @@
+import { bech32 } from '@scure/base'
+
+const MAX_ENTITY_SIZE = 5000
+const MAX_TLV_VALUE_SIZE = 255
+const NOSTR_APP_D_TAG_MAX_LENGTH = 260
+const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+const BASE62_BASE = BigInt(BASE62_ALPHABET.length)
+const BASE62_LEADER = BASE62_ALPHABET[0]
+const BASE62_CHAR_MAP = new Map(
+  [...BASE62_ALPHABET].map((character, index) => [character, BigInt(index)])
+)
+
+export const NAPP_ENTITY_REGEX = new RegExp(
+  `^\\+{1,3}[${BASE62_ALPHABET}]{48,${MAX_ENTITY_SIZE}}$`
+)
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+const fatalTextDecoder = new TextDecoder('utf-8', { fatal: true })
+
+const kindByChannel = {
+  main: 35128,
+  next: 35129,
+  draft: 35130
+}
+const channelByKind = Object.fromEntries(
+  Object.entries(kindByChannel).map(([channel, kind]) => [kind, channel])
+)
+const prefixByChannel = {
+  main: '+',
+  next: '++',
+  draft: '+++'
+}
+const channelByPrefix = Object.fromEntries(
+  Object.entries(prefixByChannel).map(([channel, prefix]) => [prefix, channel])
+)
+
+function bytesToHex (bytes) {
+  let result = ''
+  for (const byte of bytes) result += byte.toString(16).padStart(2, '0')
+  return result
+}
+
+function hexToBytes (hex, fieldName = 'hex value') {
+  if (typeof hex !== 'string' || !/^[0-9a-f]+$/i.test(hex) || hex.length % 2 !== 0) {
+    throw new Error(`Invalid ${fieldName}`)
+  }
+  const result = new Uint8Array(hex.length / 2)
+  for (let index = 0; index < result.length; index++) {
+    result[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)
+  }
+  return result
+}
+
+function fixedHexToBytes (hex, byteLength, fieldName) {
+  const bytes = hexToBytes(hex, fieldName)
+  if (bytes.length !== byteLength) throw new Error(`${fieldName} should be ${byteLength} bytes`)
+  return bytes
+}
+
+function concatBytes (arrays) {
+  const size = arrays.reduce((total, array) => total + array.length, 0)
+  const result = new Uint8Array(size)
+  let offset = 0
+  for (const array of arrays) {
+    result.set(array, offset)
+    offset += array.length
+  }
+  return result
+}
+
+function encodeText (value, fieldName) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${fieldName} should be a non-empty string`)
+  }
+  const bytes = textEncoder.encode(value)
+  if (bytes.length > MAX_TLV_VALUE_SIZE) throw new Error(`${fieldName} is too big`)
+  // TextEncoder replaces lone surrogates. Reject them instead of silently changing
+  // the signed/canonical entity value.
+  if (fatalTextDecoder.decode(bytes) !== value) throw new Error(`Invalid ${fieldName} UTF-8`)
+  return bytes
+}
+
+function decodeText (bytes, fieldName) {
+  if (bytes.length === 0 || bytes.length > MAX_TLV_VALUE_SIZE) {
+    throw new Error(`Invalid ${fieldName} length`)
+  }
+  try {
+    return fatalTextDecoder.decode(bytes)
+  } catch {
+    throw new Error(`Invalid ${fieldName} UTF-8`)
+  }
+}
+
+function encodeTlvEntries (entries) {
+  return concatBytes(entries.map(([type, value]) => {
+    if (!Number.isInteger(type) || type < 0 || type > 255) throw new Error('Invalid TLV type')
+    if (!(value instanceof Uint8Array)) throw new TypeError('TLV value should be a Uint8Array')
+    if (value.length > MAX_TLV_VALUE_SIZE) throw new Error('TLV value is too big')
+    const entry = new Uint8Array(value.length + 2)
+    entry[0] = type
+    entry[1] = value.length
+    entry.set(value, 2)
+    return entry
+  }))
+}
+
+function decodeTlvEntries (bytes) {
+  const entries = []
+  let offset = 0
+  while (offset < bytes.length) {
+    if (bytes.length - offset < 2) throw new Error('Truncated TLV header')
+    const type = bytes[offset]
+    const length = bytes[offset + 1]
+    offset += 2
+    if (bytes.length - offset < length) throw new Error(`Truncated TLV value for type ${type}`)
+    entries.push([type, bytes.slice(offset, offset + length)])
+    offset += length
+  }
+  return entries
+}
+
+function onlyValue (values, fieldName) {
+  if (values.length > 1) throw new Error(`Duplicate ${fieldName}`)
+  return values[0]
+}
+
+export function nfileEncode ({ root, relays = [], author, mime, filename }) {
+  if (!Array.isArray(relays)) throw new TypeError('relays should be an array')
+  const entries = [[0, fixedHexToBytes(root, 32, 'MMR root')]]
+  for (const relay of relays) entries.push([1, encodeText(relay, 'relay hint')])
+  if (author !== undefined) entries.push([2, fixedHexToBytes(author, 32, 'author hint')])
+  if (mime !== undefined) entries.push([3, encodeText(mime, 'MIME')])
+  if (filename !== undefined) entries.push([4, encodeText(filename, 'filename')])
+
+  const words = bech32.toWords(encodeTlvEntries(entries))
+  return bech32.encode('nfile', words, MAX_ENTITY_SIZE)
+}
+
+export function nfileDecode (entity) {
+  if (typeof entity !== 'string' || entity !== entity.toLowerCase()) {
+    throw new Error('nfile should use canonical lowercase Bech32')
+  }
+  let decoded
+  try {
+    decoded = bech32.decode(entity, MAX_ENTITY_SIZE)
+  } catch (error) {
+    throw new Error(`Invalid nfile: ${error.message}`)
+  }
+  if (decoded.prefix !== 'nfile') throw new Error('Invalid nfile prefix')
+
+  let bytes
+  try {
+    bytes = new Uint8Array(bech32.fromWords(decoded.words))
+  } catch (error) {
+    throw new Error(`Invalid nfile data: ${error.message}`)
+  }
+
+  const known = new Map([[0, []], [1, []], [2, []], [3, []], [4, []]])
+  for (const [type, value] of decodeTlvEntries(bytes)) known.get(type)?.push(value)
+
+  const rootBytes = onlyValue(known.get(0), 'MMR root')
+  if (!rootBytes) throw new Error('Missing MMR root')
+  if (rootBytes.length !== 32) throw new Error('MMR root should be 32 bytes')
+
+  const authorBytes = onlyValue(known.get(2), 'author hint')
+  if (authorBytes && authorBytes.length !== 32) throw new Error('Author hint should be 32 bytes')
+  const mimeBytes = onlyValue(known.get(3), 'MIME')
+  const filenameBytes = onlyValue(known.get(4), 'filename')
+
+  const result = {
+    root: bytesToHex(rootBytes),
+    relays: known.get(1).map(value => decodeText(value, 'relay hint'))
+  }
+  if (authorBytes) result.author = bytesToHex(authorBytes)
+  if (mimeBytes) result.mime = decodeText(mimeBytes, 'MIME')
+  if (filenameBytes) result.filename = decodeText(filenameBytes, 'filename')
+  return result
+}
+
+function bytesToBase62 (bytes) {
+  if (bytes.length === 0) return ''
+  let number = 0n
+  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
+
+  let result = ''
+  if (number === 0n) return BASE62_LEADER
+  while (number > 0n) {
+    result = BASE62_ALPHABET[Number(number % BASE62_BASE)] + result
+    number /= BASE62_BASE
+  }
+  for (const byte of bytes) {
+    if (byte !== 0) break
+    result = BASE62_LEADER + result
+  }
+  return result
+}
+
+function base62ToBytes (value) {
+  if (typeof value !== 'string') throw new TypeError('Base62 value should be a string')
+  let leadingZeros = 0
+  while (value[leadingZeros] === BASE62_LEADER) leadingZeros++
+
+  let number = 0n
+  for (const character of value) {
+    const digit = BASE62_CHAR_MAP.get(character)
+    if (digit === undefined) throw new Error(`Invalid Base62 character: ${character}`)
+    number = number * BASE62_BASE + digit
+  }
+  const suffix = []
+  while (number > 0n) {
+    suffix.unshift(Number(number & 0xffn))
+    number >>= 8n
+  }
+  const result = new Uint8Array(leadingZeros + suffix.length)
+  result.set(suffix, leadingZeros)
+  return result
+}
+
+function isNostrAppDTagSafe (value) {
+  return typeof value === 'string' && value.length <= NOSTR_APP_D_TAG_MAX_LENGTH
+}
+
+export function appEncode (ref) {
+  if (!isNostrAppDTagSafe(ref.dTag)) throw new Error('Invalid deduplication tag')
+  const channel = ref.channel ? (prefixByChannel[ref.channel] && ref.channel) : channelByKind[ref.kind]
+  if (!channel) throw new Error('Wrong channel')
+
+  // Keep the established app-entity byte ordering exactly for compatibility.
+  const groups = [
+    [textEncoder.encode(ref.dTag)],
+    (ref.relays || []).map(relay => textEncoder.encode(relay)),
+    [fixedHexToBytes(ref.pubkey, 32, 'author pubkey')]
+  ]
+  const entries = []
+  groups
+    .map((values, type) => [type, values])
+    .reverse()
+    .forEach(([type, values]) => {
+      for (const value of values) entries.push([type, value])
+    })
+  const entity = `${prefixByChannel[channel]}${bytesToBase62(encodeTlvEntries(entries))}`
+  if (entity.length > MAX_ENTITY_SIZE) throw new Error('App entity is too big')
+  return entity
+}
+
+export function appDecode (entity) {
+  if (typeof entity !== 'string' || entity.length > MAX_ENTITY_SIZE) throw new Error('Invalid app entity')
+  const prefix = entity.match(/^\+*/)?.[0]
+  const channel = channelByPrefix[prefix]
+  if (!channel) throw new Error('Invalid channel')
+
+  const values = new Map()
+  for (const [type, value] of decodeTlvEntries(base62ToBytes(entity.slice(prefix.length)))) {
+    const list = values.get(type) || []
+    list.push(value)
+    values.set(type, list)
+  }
+  const dTagBytes = values.get(0)?.[0]
+  const pubkeyBytes = values.get(2)?.[0]
+  if (!dTagBytes) throw new Error('Missing deduplication tag')
+  if (!pubkeyBytes) throw new Error('Missing author pubkey')
+  if (pubkeyBytes.length !== 32) throw new Error('Author pubkey should be 32 bytes')
+  const dTag = textDecoder.decode(dTagBytes)
+  if (!isNostrAppDTagSafe(dTag)) throw new Error('Invalid deduplication tag')
+
+  return {
+    dTag,
+    pubkey: bytesToHex(pubkeyBytes),
+    kind: kindByChannel[channel],
+    channel,
+    relays: (values.get(1) || []).map(value => textDecoder.decode(value))
+  }
+}
+
+export function npubEncode (hex) {
+  return bech32.encode('npub', bech32.toWords(fixedHexToBytes(hex, 32, 'pubkey')))
+}
+
+export function npubDecode (entity) {
+  return decodeSimpleEntity(entity, 'npub', 'pubkey')
+}
+
+export function nsecEncode (hex) {
+  return bech32.encode('nsec', bech32.toWords(fixedHexToBytes(hex, 32, 'secret key')))
+}
+
+export function nsecDecode (entity) {
+  return decodeSimpleEntity(entity, 'nsec', 'secret key')
+}
+
+function decodeSimpleEntity (entity, prefix, fieldName) {
+  if (typeof entity !== 'string' || !entity.startsWith(`${prefix}1`)) {
+    throw new Error(`Invalid ${prefix} format`)
+  }
+  try {
+    const decoded = bech32.decode(entity)
+    if (decoded.prefix !== prefix) throw new Error(`Invalid ${prefix} prefix`)
+    const bytes = new Uint8Array(bech32.fromWords(decoded.words))
+    if (bytes.length !== 32) throw new Error(`Invalid ${fieldName} length`)
+    return bytesToHex(bytes)
+  } catch (error) {
+    throw new Error(`Failed to decode ${prefix}: ${error.message}`)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -11,6 +11,28 @@
   "author": "arthurfranca",
   "type": "module",
   "sideEffects": false,
+  "files": [
+    "base16",
+    "base64",
+    "base93",
+    "content-key",
+    "double-dh",
+    "ecdh",
+    "idb",
+    "idb-queue",
+    "index.js",
+    "key",
+    "network",
+    "nip19",
+    "nip44-v3",
+    "nip46",
+    "private-channel",
+    "private-message",
+    "private-messenger",
+    "relay",
+    "temporary-storage",
+    "web-storage-queue"
+  ],
   "scripts": {
     "test": "node --test --experimental-test-module-mocks 'tests/**/*.test.js'",
     "test:only": "node --test --test-only --experimental-test-module-mocks 'tests/**/*.test.js'"
@@ -19,6 +41,7 @@
     ".": "./index.js",
     "./base16": "./base16/index.js",
     "./base64": "./base64/index.js",
+    "./base93": "./base93/index.js",
     "./content-key": "./content-key/index.js",
     "./content-key/event": "./content-key/event/index.js",
     "./double-dh": "./double-dh/index.js",
@@ -27,6 +50,7 @@
     "./idb-queue": "./idb-queue/index.js",
     "./key": "./key/index.js",
     "./network": "./network/index.js",
+    "./nip19": "./nip19/index.js",
     "./nip44-v3": "./nip44-v3/index.js",
     "./nip46": "./nip46/index.js",
     "./private-channel": "./private-channel/index.js",
@@ -41,6 +65,7 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
+    "@scure/base": "2.0.0",
     "nostr-tools": "2.23.5"
   },
   "devDependencies": {

package/AGENTS.md

@@ -1,20 +0,0 @@
-# AGENTS.md
-
-## Project Shape
-
-libp2r2p is an ESM package with no build step. Public package exports should
-come from their own folders, each with an `index.js` entry point. Prefer
-singular public subpaths, such as `libp2r2p/key` and `libp2r2p/relay`.
-
-Public export folders may organize implementation details with `constants/`,
-`helpers/`, and `services/` subfolders. Additional custom public subfolders
-are fine when they are part of the API, such as `private-messenger/recovery`
-or `content-key/event`, and those should also expose an `index.js`.
-
-Root-level `constants/`, `helpers/`, and `services/` folders are reserved
-for shared internal code that is not itself a public export. Do not expose
-internal files directly through `package.json`; add or adjust an export-folder
-`index.js` instead.
-
-Keep the `exports` object in `package.json` sorted, with `.` first.
-Do not keep backwards-compatible alias exports unless explicitly requested.

package/tests/base16.test.js

@@ -1,19 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  base16ToBytes,
-  bytesToBase16,
-  bytesToHex,
-  hexToBytes
-} from '../base16/index.js'
-
-test('base16 helpers encode bytes and expose hex aliases', () => {
-  const bytes = new Uint8Array([0, 1, 15, 16, 254, 255])
-  const encoded = '00010f10feff'
-
-  assert.equal(bytesToBase16(bytes), encoded)
-  assert.deepEqual(base16ToBytes(encoded), bytes)
-  assert.equal(bytesToHex, bytesToBase16)
-  assert.equal(hexToBytes, base16ToBytes)
-})

package/tests/base64.test.js

@@ -1,18 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  base64ToBytes,
-  base64UrlToBytes,
-  bytesToBase64,
-  bytesToBase64Url
-} from '../base64/index.js'
-
-test('base64 helpers encode bytes with plain and URL-safe alphabets', () => {
-  const bytes = new Uint8Array([0, 1, 2, 251, 252, 253, 254, 255])
-
-  assert.equal(bytesToBase64(bytes), 'AAEC+/z9/v8=')
-  assert.deepEqual(base64ToBytes('AAEC+/z9/v8='), bytes)
-  assert.equal(bytesToBase64Url(bytes), 'AAEC-_z9_v8')
-  assert.deepEqual(base64UrlToBytes('AAEC-_z9_v8'), bytes)
-})

package/tests/content-key-event.test.js

@@ -1,48 +0,0 @@
-import { afterEach, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { generateSecretKey, verifyEvent } from 'nostr-tools'
-
-import TestSigner from './helpers/test-signer.js'
-import { bytesToHex } from '../base16/index.js'
-import {
-  CONTENT_KEY_KIND,
-  makeContentKeyEvent,
-  parseContentKeyEvent,
-  verifyContentKeyProof,
-  verifyIykcProof
-} from '../content-key/event/index.js'
-
-afterEach(() => {
-  TestSigner.releaseAll()
-})
-
-function signer () {
-  return TestSigner.getOrCreate(bytesToHex(generateSecretKey()))
-}
-
-test('makeContentKeyEvent publishes a signed content pubkey proof', async () => {
-  const user = signer()
-  const contentKey = signer()
-  const userPubkey = await user.getPublicKey()
-  const contentPubkey = await contentKey.getPublicKey()
-  const event = await makeContentKeyEvent({ userSigner: user, contentKeySigner: contentKey, createdAt: 7 })
-  const parsed = parseContentKeyEvent(event)
-
-  assert.equal(event.kind, CONTENT_KEY_KIND)
-  assert.equal(event.pubkey, userPubkey)
-  assert.deepEqual(event.tags, [['cp', contentPubkey]])
-  assert.equal(parsed.iykcPubkey, contentPubkey)
-  assert.equal(parsed.iykcProof, `${event.created_at}:${event.sig}`)
-  assert.equal(verifyIykcProof({ receiverPubkey: userPubkey, iykcPubkey: contentPubkey, iykcProof: parsed.iykcProof }), true)
-  assert.equal(verifyContentKeyProof({ ownerPubkey: userPubkey, contentPubkey, proof: parsed.iykcProof }), true)
-  assert.equal(verifyEvent(event), true)
-})
-
-test('parseContentKeyEvent rejects malformed content-key events', async () => {
-  const event = await makeContentKeyEvent({ userSigner: signer(), contentKeySigner: signer(), createdAt: 7 })
-
-  assert.equal(parseContentKeyEvent({ ...event, tags: event.tags.concat([['x', 'nope']]) }), null)
-  assert.equal(parseContentKeyEvent({ ...event, tags: [['cp', event.tags[0][1], 'extra']] }), null)
-  assert.equal(parseContentKeyEvent({ ...event, content: 'nope' }), null)
-  assert.equal(parseContentKeyEvent({ ...event, tags: [['cp', 'f'.repeat(64)]] }), null)
-})