libp2r2p 0.8.0 → 0.9.0

package/event/index.js

@@ -0,0 +1,116 @@
+import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js'
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { bytesToBase16, base16ToBytes } from '../base16/index.js'
+import { ValidationError } from '../error/index.js'
+import {
+  isAddressableKind,
+  isEphemeralKind,
+  isRegularKind,
+  isReplaceableKind
+} from '../kind/index.js'
+import {
+  assertSerializableEvent,
+  isSerializableEvent,
+  serializeEvent,
+  serializableEventError
+} from './helpers/serialize.js'
+
+const HEX_32 = /^[0-9a-f]{64}$/
+const HEX_64 = /^[0-9a-f]{128}$/
+const textEncoder = new TextEncoder()
+
+function copyTags (tags) {
+  return Array.isArray(tags) ? tags.map(tag => Array.isArray(tag) ? tag.slice() : tag) : tags
+}
+
+export { assertSerializableEvent, isSerializableEvent }
+
+export function getEventHash (event) {
+  return bytesToBase16(sha256(textEncoder.encode(serializeEvent(event))))
+}
+
+export function finalizeEvent (template, secretKey) {
+  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32 || !secp256k1.utils.isValidSecretKey(secretKey)) {
+    throw new ValidationError('INVALID_SECRET_KEY')
+  }
+  const pubkey = bytesToBase16(schnorr.getPublicKey(secretKey))
+  const event = { ...template, tags: copyTags(template?.tags), pubkey }
+  const id = getEventHash(event)
+  return { ...event, id, sig: bytesToBase16(schnorr.sign(base16ToBytes(id), secretKey)) }
+}
+
+function eventValidationError (event) {
+  const structureError = serializableEventError(event)
+  if (structureError) return structureError
+  if (typeof event.id !== 'string' || !HEX_32.test(event.id)) return 'INVALID_EVENT_ID'
+  if (typeof event.sig !== 'string' || !HEX_64.test(event.sig)) return 'INVALID_EVENT_SIGNATURE'
+  try {
+    const id = getEventHash(event)
+    if (id !== event.id) return 'EVENT_ID_MISMATCH'
+    if (!schnorr.verify(base16ToBytes(event.sig), base16ToBytes(id), base16ToBytes(event.pubkey))) {
+      return 'INVALID_EVENT_SIGNATURE'
+    }
+  } catch {
+    return 'INVALID_EVENT_SIGNATURE'
+  }
+  return null
+}
+
+export function isValidEvent (event) {
+  return eventValidationError(event) === null
+}
+
+export function assertValidEvent (event) {
+  const code = eventValidationError(event)
+  if (code) throw new ValidationError(code)
+  return event
+}
+
+function hasTagDefinedClassification (event, classification) {
+  if (!event || typeof event !== 'object' || !Array.isArray(event.tags)) return false
+
+  if (classification === 'ephemeral') {
+    if (!Number.isSafeInteger(event.created_at) || event.created_at < 0) return false
+    const timestamp = String(event.created_at)
+    return event.tags.some(tag => Array.isArray(tag) && tag[0] === 'expiration' && tag[1] === timestamp)
+  }
+
+  const dTag = event.tags.find(tag => Array.isArray(tag) && tag[0] === 'd')
+  if (typeof dTag?.[1] !== 'string') return false
+  if (classification === 'replaceable') return dTag[1] === ''
+  if (classification === 'addressable') return dTag[1] !== ''
+  return false
+}
+
+export function classifyEvent (event, { includeLegacyKindRanges = true } = {}) {
+  if (!event || typeof event !== 'object') return []
+  const options = { includeLegacyKindRanges }
+  return [
+    ['regular', isRegularEvent],
+    ['replaceable', isReplaceableEvent],
+    ['ephemeral', isEphemeralEvent],
+    ['addressable', isAddressableEvent]
+  ].filter(([, predicate]) => predicate(event, options)).map(([classification]) => classification)
+}
+
+export function isRegularEvent (event, options) {
+  if (!event || typeof event !== 'object') return false
+  return (options?.includeLegacyKindRanges !== false && isRegularKind(event.kind)) ||
+    (!isReplaceableEvent(event, options) && !isAddressableEvent(event, options))
+}
+
+export function isReplaceableEvent (event, options) {
+  return (options?.includeLegacyKindRanges !== false && isReplaceableKind(event?.kind)) ||
+    hasTagDefinedClassification(event, 'replaceable')
+}
+
+export function isEphemeralEvent (event, options) {
+  return (options?.includeLegacyKindRanges !== false && isEphemeralKind(event?.kind)) ||
+    hasTagDefinedClassification(event, 'ephemeral')
+}
+
+export function isAddressableEvent (event, options) {
+  return (options?.includeLegacyKindRanges !== false && isAddressableKind(event?.kind)) ||
+    hasTagDefinedClassification(event, 'addressable')
+}

package/i18n/index.js

@@ -1,9 +1,11 @@
+import { ValidationError } from '../error/index.js'
+
 const DEFAULT_LOCALE = 'en'
 const INTERPOLATION_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g
 
 function assertLocales (locales) {
   if (!locales || typeof locales !== 'object' || Array.isArray(locales)) {
-    throw new TypeError('locales should be an object')
+    throw new ValidationError('INVALID_LOCALES', { message: 'locales should be an object' })
   }
 }
 
@@ -17,21 +19,21 @@ function placeholderSignature (value) {
 function validateTranslationValue (key, locale, value, expectedPlaceholders) {
   if (typeof value === 'string') {
     if (placeholderSignature(value) !== expectedPlaceholders) {
-      throw new Error(`placeholder mismatch for "${key}" (${locale})`)
+      throw new ValidationError('I18N_PLACEHOLDER_MISMATCH', { message: `placeholder mismatch for "${key}" (${locale})` })
     }
     return
   }
 
   if (!value || typeof value !== 'object' || Array.isArray(value) || typeof value.other !== 'string') {
-    throw new TypeError(`translation for "${key}" (${locale}) should be a string or plural object with an other form`)
+    throw new ValidationError('INVALID_TRANSLATION', { message: `translation for "${key}" (${locale}) should be a string or plural object with an other form` })
   }
 
   for (const form of Object.values(value)) {
     if (typeof form !== 'string') {
-      throw new TypeError(`plural forms for "${key}" (${locale}) should be strings`)
+      throw new ValidationError('INVALID_PLURAL_TRANSLATION', { message: `plural forms for "${key}" (${locale}) should be strings` })
     }
     if (placeholderSignature(form) !== expectedPlaceholders) {
-      throw new Error(`placeholder mismatch for "${key}" (${locale})`)
+      throw new ValidationError('I18N_PLACEHOLDER_MISMATCH', { message: `placeholder mismatch for "${key}" (${locale})` })
     }
   }
 }
@@ -39,7 +41,7 @@ function validateTranslationValue (key, locale, value, expectedPlaceholders) {
 export function validateLocales (locales, options = {}) {
   assertLocales(locales)
   if (!options || typeof options !== 'object' || Array.isArray(options)) {
-    throw new TypeError('validation options should be an object')
+    throw new ValidationError('INVALID_I18N_VALIDATION_OPTIONS', { message: 'validation options should be an object' })
   }
   const {
     requiredLocales = [],
@@ -47,20 +49,20 @@ export function validateLocales (locales, options = {}) {
     requireReferenceKey = false
   } = options
   if (!Array.isArray(requiredLocales) || requiredLocales.some(locale => typeof locale !== 'string' || !locale)) {
-    throw new TypeError('requiredLocales should be an array of non-empty strings')
+    throw new ValidationError('INVALID_REQUIRED_LOCALES', { message: 'requiredLocales should be an array of non-empty strings' })
   }
   if (typeof referenceLocale !== 'string' || !referenceLocale) {
-    throw new TypeError('referenceLocale should be a non-empty string')
+    throw new ValidationError('INVALID_REFERENCE_LOCALE', { message: 'referenceLocale should be a non-empty string' })
   }
 
   for (const [key, translations] of Object.entries(locales)) {
     if (!translations || typeof translations !== 'object' || Array.isArray(translations)) {
-      throw new TypeError(`translations for "${key}" should be an object`)
+      throw new ValidationError('INVALID_TRANSLATIONS', { message: `translations for "${key}" should be an object` })
     }
 
     for (const locale of requiredLocales) {
       if (!Object.prototype.hasOwnProperty.call(translations, locale)) {
-        throw new Error(`missing translation for "${key}" (${locale})`)
+        throw new ValidationError('MISSING_TRANSLATION', { message: `missing translation for "${key}" (${locale})` })
       }
     }
 
@@ -71,12 +73,12 @@ export function validateLocales (locales, options = {}) {
 
     if (requireReferenceKey) {
       if (!Object.prototype.hasOwnProperty.call(translations, referenceLocale)) {
-        throw new Error(`missing reference translation for "${key}" (${referenceLocale})`)
+        throw new ValidationError('MISSING_REFERENCE_TRANSLATION', { message: `missing reference translation for "${key}" (${referenceLocale})` })
       }
       const reference = translations[referenceLocale]
       const referenceValue = typeof reference === 'string' ? reference : reference.other
       if (referenceValue !== key) {
-        throw new Error(`reference translation should match key "${key}" (${referenceLocale})`)
+        throw new ValidationError('REFERENCE_TRANSLATION_MISMATCH', { message: `reference translation should match key "${key}" (${referenceLocale})` })
       }
     }
   }
@@ -227,7 +229,7 @@ export function getT (locales, {
   const canonicalFallback = canonicalizeLocale(fallbackLocale) ?? DEFAULT_LOCALE
 
   return function t (key, values) {
-    if (typeof key !== 'string') throw new TypeError('translation key should be a string')
+    if (typeof key !== 'string') throw new ValidationError('INVALID_TRANSLATION_KEY', { message: 'translation key should be a string' })
     const translations = Object.prototype.hasOwnProperty.call(locales, key) ? locales[key] : null
     const template = selectTemplate(translations, requestedLocale, canonicalFallback, values) ?? key
     return interpolate(template, values)

package/idb/index.js

@@ -1,3 +1,5 @@
+import { ValidationError } from '../error/index.js'
+
 const READ_METHODS = new Set([
   'count',
   'get',
@@ -29,15 +31,15 @@ export async function run (method, args = [], storeName, indexName, {
   storeOrIndex
 } = {}) {
   if (!tx) {
-    if (!db) throw new Error('IDB_DATABASE_REQUIRED')
-    if (!storeName) throw new Error('IDB_STORE_REQUIRED')
+    if (!db) throw new ValidationError('IDB_DATABASE_REQUIRED')
+    if (!storeName) throw new ValidationError('IDB_STORE_REQUIRED')
     // Caller may pre-select it if it wants to use many different methods in a row
     txMode ??= READ_METHODS.has(method) ? 'readonly' : 'readwrite'
     tx = db.transaction([storeName], txMode)
   }
 
   if (!storeOrIndex) {
-    if (!storeName) throw new Error('IDB_STORE_REQUIRED')
+    if (!storeName) throw new ValidationError('IDB_STORE_REQUIRED')
     const store = tx.objectStore(storeName)
     storeOrIndex = indexName ? store.index(indexName) : store
   }

package/idb-queue/index.js

@@ -1,4 +1,5 @@
 import { run } from '../idb/index.js'
+import { ValidationError } from '../error/index.js'
 
 const encoder = new TextEncoder()
 const ITEMS_STORE = 'items'
@@ -56,7 +57,7 @@ function normalizeEvictionPolicy (policy) {
   if (policy === 'opposite-end' || policy === undefined || policy === null) return 'opposite-end'
   if (policy === 'fifo' || policy === 'head') return 'head'
   if (policy === 'lifo' || policy === 'tail') return 'tail'
-  throw new Error('QUEUE_INVALID_EVICTION_POLICY')
+  throw new ValidationError('QUEUE_INVALID_EVICTION_POLICY')
 }
 
 function normalizeState (value) {
@@ -67,17 +68,17 @@ function normalizeState (value) {
 }
 
 function normalizeIndexes (indexes = {}) {
-  if (!indexes || typeof indexes !== 'object' || Array.isArray(indexes)) throw new Error('QUEUE_INDEXES_INVALID')
+  if (!indexes || typeof indexes !== 'object' || Array.isArray(indexes)) throw new ValidationError('QUEUE_INDEXES_INVALID')
 
   return Object.entries(indexes).map(([name, definition]) => {
     const options = typeof definition === 'string' || Array.isArray(definition)
       ? { keyPath: definition }
       : definition
     const keyPath = options?.keyPath
-    if (!name || (!Array.isArray(keyPath) && typeof keyPath !== 'string')) throw new Error('QUEUE_INDEX_INVALID')
-    if (Array.isArray(keyPath) && keyPath.some(path => typeof path !== 'string' || !path)) throw new Error('QUEUE_INDEX_INVALID')
-    if (typeof keyPath === 'string' && !keyPath) throw new Error('QUEUE_INDEX_INVALID')
-    if (options.multiEntry && Array.isArray(keyPath)) throw new Error('QUEUE_INDEX_MULTI_ENTRY_COMPOUND')
+    if (!name || (!Array.isArray(keyPath) && typeof keyPath !== 'string')) throw new ValidationError('QUEUE_INDEX_INVALID')
+    if (Array.isArray(keyPath) && keyPath.some(path => typeof path !== 'string' || !path)) throw new ValidationError('QUEUE_INDEX_INVALID')
+    if (typeof keyPath === 'string' && !keyPath) throw new ValidationError('QUEUE_INDEX_INVALID')
+    if (options.multiEntry && Array.isArray(keyPath)) throw new ValidationError('QUEUE_INDEX_MULTI_ENTRY_COMPOUND')
     return {
       name,
       keyPath,
@@ -90,7 +91,7 @@ function normalizeIndexes (indexes = {}) {
   })
 }
 
-function keyPathEqual (a, b) {
+function areKeyPathsEqual (a, b) {
   return JSON.stringify(a) === JSON.stringify(b)
 }
 
@@ -129,12 +130,12 @@ function ensureSchema (db, tx, indexDefinitions) {
     items = db.createObjectStore(ITEMS_STORE, { keyPath: 'position' })
   } else {
     items = tx.objectStore(ITEMS_STORE)
-    if (!keyPathEqual(items.keyPath, 'position')) throw new Error('QUEUE_SCHEMA_MISMATCH')
+    if (!areKeyPathsEqual(items.keyPath, 'position')) throw new Error('QUEUE_SCHEMA_MISMATCH')
   }
 
   if (!db.objectStoreNames.contains(STATE_STORE)) {
     db.createObjectStore(STATE_STORE, { keyPath: 'key' })
-  } else if (!keyPathEqual(tx.objectStore(STATE_STORE).keyPath, 'key')) {
+  } else if (!areKeyPathsEqual(tx.objectStore(STATE_STORE).keyPath, 'key')) {
     throw new Error('QUEUE_SCHEMA_MISMATCH')
   }
 
@@ -148,7 +149,7 @@ function ensureSchema (db, tx, indexDefinitions) {
     }
     const existing = items.index(definition.name)
     if (
-      !keyPathEqual(existing.keyPath, definition.storedKeyPath) ||
+      !areKeyPathsEqual(existing.keyPath, definition.storedKeyPath) ||
       existing.unique !== definition.unique ||
       existing.multiEntry !== definition.multiEntry
     ) {
@@ -165,7 +166,7 @@ async function inspectSchema (db, indexDefinitions) {
   const done = transactionDone(tx)
   const items = tx.objectStore(ITEMS_STORE)
   const state = tx.objectStore(STATE_STORE)
-  if (!keyPathEqual(items.keyPath, 'position') || !keyPathEqual(state.keyPath, 'key')) {
+  if (!areKeyPathsEqual(items.keyPath, 'position') || !areKeyPathsEqual(state.keyPath, 'key')) {
     await done
     return { missing: false, incompatible: true }
   }
@@ -178,7 +179,7 @@ async function inspectSchema (db, indexDefinitions) {
     }
     const existing = items.index(definition.name)
     if (
-      !keyPathEqual(existing.keyPath, definition.storedKeyPath) ||
+      !areKeyPathsEqual(existing.keyPath, definition.storedKeyPath) ||
       existing.unique !== definition.unique ||
       existing.multiEntry !== definition.multiEntry
     ) {
@@ -241,13 +242,13 @@ function itemForStorage (position, item) {
 
 function assertIndex (index, length, { allowEnd = false } = {}) {
   const max = allowEnd ? length : length - 1
-  if (!Number.isSafeInteger(index) || index < 0 || index > max) throw new Error('QUEUE_INDEX_OUT_OF_RANGE')
+  if (!Number.isSafeInteger(index) || index < 0 || index > max) throw new ValidationError('QUEUE_INDEX_OUT_OF_RANGE')
 }
 
-function validDirection (direction) {
+function normalizeDirection (direction) {
   if (direction === undefined || direction === 'next') return 'next'
   if (direction === 'prev') return 'prev'
-  throw new Error('QUEUE_INVALID_DIRECTION')
+  throw new ValidationError('QUEUE_INVALID_DIRECTION')
 }
 
 function isQuotaExceeded (err) {
@@ -265,7 +266,7 @@ export async function createQueue ({
   evictionPolicy = 'opposite-end',
   indexedDB = globalThis.indexedDB
 } = {}) {
-  if (!prefix) throw new Error('QUEUE_PREFIX_REQUIRED')
+  if (!prefix) throw new ValidationError('QUEUE_PREFIX_REQUIRED')
 
   const indexDefinitions = normalizeIndexes(indexes)
   const db = await openQueueDatabase(indexedDB, prefix, indexDefinitions)
@@ -663,7 +664,7 @@ export async function createQueue ({
   }
 
   async function insertWhere (predicate, item, { appendIfMissing = false } = {}) {
-    if (typeof predicate !== 'function') throw new Error('QUEUE_PREDICATE_REQUIRED')
+    if (typeof predicate !== 'function') throw new ValidationError('QUEUE_PREDICATE_REQUIRED')
     const requiredBytes = itemForStorage(0, item).byteSize
     return mutate(async (tx, state) => {
       const records = await recordsForState(tx, state)
@@ -683,7 +684,7 @@ export async function createQueue ({
   }
 
   async function removeWhere (predicate) {
-    if (typeof predicate !== 'function') throw new Error('QUEUE_PREDICATE_REQUIRED')
+    if (typeof predicate !== 'function') throw new ValidationError('QUEUE_PREDICATE_REQUIRED')
     return mutate(async (tx, state) => {
       const records = await recordsForState(tx, state)
       const removed = new Set()
@@ -699,7 +700,7 @@ export async function createQueue ({
   }
 
   async function some (predicate) {
-    if (typeof predicate !== 'function') throw new Error('QUEUE_PREDICATE_REQUIRED')
+    if (typeof predicate !== 'function') throw new ValidationError('QUEUE_PREDICATE_REQUIRED')
     return snapshot(async tx => {
       const state = await readState(tx)
       const records = await recordsForState(tx, state)
@@ -797,7 +798,7 @@ export async function createQueue ({
   }
 
   async function * storedItemsBy (indexName, query, { direction = 'next' } = {}) {
-    direction = validDirection(direction)
+    direction = normalizeDirection(direction)
     const records = await snapshot(async tx => {
       const { result } = await run('getAll', [query], ITEMS_STORE, indexName, { tx })
       return result

package/index.js

@@ -8,18 +8,28 @@ export * as contentKey from './content-key/index.js'
 export * as contentKeyEvent from './content-key/event/index.js'
 export * as doubleDh from './double-dh/index.js'
 export * as ecdh from './ecdh/index.js'
+export * as error from './error/index.js'
+export * as event from './event/index.js'
 export * as idb from './idb/index.js'
 export * as idbQueue from './idb-queue/index.js'
 export * as i18n from './i18n/index.js'
 export * as key from './key/index.js'
+export * as kind from './kind/index.js'
 export * as network from './network/index.js'
+export * as nip04 from './nip04/index.js'
+export * as nip05 from './nip05/index.js'
 export * as nip19 from './nip19/index.js'
+export * as nip44 from './nip44/index.js'
 export * as nip44v3 from './nip44-v3/index.js'
 export * as nip46 from './nip46/index.js'
+export * as nip96 from './nip96/index.js'
+export * as nip98 from './nip98/index.js'
+export * as nwt from './nwt/index.js'
 export * as privateChannel from './private-channel/index.js'
 export * as privateMessage from './private-message/index.js'
 export * as privateMessenger from './private-messenger/index.js'
 export * as privateMessengerRecovery from './private-messenger/recovery/index.js'
 export * as relay from './relay/index.js'
 export * as temporaryStorage from './temporary-storage/index.js'
+export * as url from './url/index.js'
 export * as webStorageQueue from './web-storage-queue/index.js'

package/key/index.js

@@ -1,14 +1,23 @@
-import {
-  generateSecretKey,
-  getPublicKey,
-  finalizeEvent,
-  nip19
-} from 'nostr-tools'
+import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js'
 
 import { bytesToHex, hexToBytes } from '../base16/index.js'
+import { ValidationError } from '../error/index.js'
+import { finalizeEvent } from '../event/index.js'
+import { nsecDecode, nsecEncode, npubDecode, npubEncode } from '../nip19/index.js'
 
 const HEX_SECKEY_REGEX = /^[0-9a-f]{64}$/i
 
+export function generateSecretKey () {
+  return schnorr.utils.randomSecretKey()
+}
+
+export function getPublicKey (secretKey) {
+  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32 || !secp256k1.utils.isValidSecretKey(secretKey)) {
+    throw new ValidationError('INVALID_SECRET_KEY')
+  }
+  return bytesToHex(schnorr.getPublicKey(secretKey))
+}
+
 export function generateKeypair () {
   const secretKey = generateSecretKey()
   const pubkey = getPublicKey(secretKey)
@@ -16,8 +25,8 @@ export function generateKeypair () {
     secretKey,
     seckey: bytesToHex(secretKey),
     pubkey,
-    nsec: nip19.nsecEncode(secretKey),
-    npub: nip19.npubEncode(pubkey)
+    nsec: nsecEncode(bytesToHex(secretKey)),
+    npub: npubEncode(pubkey)
   }
 }
 
@@ -29,17 +38,19 @@ export function keypairFromSeckey (raw) {
   if (HEX_SECKEY_REGEX.test(raw)) {
     secretKey = hexToBytes(raw.toLowerCase())
   } else {
-    const decoded = nip19.decode(raw)
-    if (decoded.type !== 'nsec') throw new Error('NOT_A_SECRET_KEY')
-    secretKey = decoded.data
+    try {
+      secretKey = hexToBytes(nsecDecode(raw))
+    } catch (cause) {
+      throw new ValidationError('NOT_A_SECRET_KEY', { cause })
+    }
   }
   const pubkey = getPublicKey(secretKey)
   return {
     secretKey,
     seckey: bytesToHex(secretKey),
     pubkey,
-    nsec: nip19.nsecEncode(secretKey),
-    npub: nip19.npubEncode(pubkey)
+    nsec: nsecEncode(bytesToHex(secretKey)),
+    npub: npubEncode(pubkey)
   }
 }
 
@@ -47,17 +58,19 @@ export function keypairFromSeckey (raw) {
 // bech32 includes a checksum that protects against user-typo imports of a
 // pubkey they cannot sign for.
 export function pubkeyFromNpub (npub) {
-  const decoded = nip19.decode(npub)
-  if (decoded.type !== 'npub') throw new Error('NOT_AN_NPUB')
-  return decoded.data
+  try {
+    return npubDecode(npub)
+  } catch (cause) {
+    throw new ValidationError('NOT_AN_NPUB', { cause })
+  }
 }
 
 export function nsecFromHex (hex) {
-  return nip19.nsecEncode(hexToBytes(hex))
+  return nsecEncode(hex)
 }
 
 export function npubFromPubkey (pubkey) {
-  return nip19.npubEncode(pubkey)
+  return npubEncode(pubkey)
 }
 
 function cleanProfileValue (value) {