libp2r2p 0.8.0 → 0.10.0

package/event/helpers/serialize.js

@@ -0,0 +1,31 @@
+import { ValidationError } from '../../error/index.js'
+
+const HEX_32 = /^[0-9a-f]{64}$/
+
+export function serializableEventError (event) {
+  if (!event || typeof event !== 'object' || Array.isArray(event)) return 'INVALID_EVENT'
+  if (!Number.isSafeInteger(event.kind) || event.kind < 0 || event.kind > 0xffff) return 'INVALID_EVENT_KIND'
+  if (!Number.isSafeInteger(event.created_at) || event.created_at < 0) return 'INVALID_EVENT_CREATED_AT'
+  if (typeof event.pubkey !== 'string' || !HEX_32.test(event.pubkey)) return 'INVALID_EVENT_PUBKEY'
+  if (typeof event.content !== 'string') return 'INVALID_EVENT_CONTENT'
+  if (!Array.isArray(event.tags) ||
+      !event.tags.every(tag => Array.isArray(tag) && tag.length > 0 && tag.every(value => typeof value === 'string'))) {
+    return 'INVALID_EVENT_TAGS'
+  }
+  return null
+}
+
+export function isSerializableEvent (event) {
+  return serializableEventError(event) === null
+}
+
+export function assertSerializableEvent (event) {
+  const code = serializableEventError(event)
+  if (code) throw new ValidationError(code)
+  return event
+}
+
+export function serializeEvent (event) {
+  assertSerializableEvent(event)
+  return JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content])
+}

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/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,27 @@ 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) {

package/kind/index.js

@@ -0,0 +1,244 @@
+export const METADATA = 0
+export const TEXT_NOTE = 1
+export const RECOMMEND_RELAY = 2
+export const FOLLOWS = 3
+export const ENCRYPTED_DIRECT_MESSAGE = 4
+export const DELETION = 5
+export const REPOST = 6
+export const REACTION = 7
+export const BADGE_AWARD = 8
+export const SEAL = 13
+export const PRIVATE_DIRECT_MESSAGE = 14
+export const GENERIC_REPOST = 16
+export const PICTURE = 20
+export const VIDEO = 21
+export const SHORT_VIDEO = 22
+export const CHANNEL_CREATE = 40
+export const CHANNEL_METADATA = 41
+export const CHANNEL_MESSAGE = 42
+export const CHANNEL_HIDE_MESSAGE = 43
+export const CHANNEL_MUTE_USER = 44
+export const REGULAR_CUSTOM_APP_DATA = 78
+export const PERSONAL_COPY = 1006
+export const OPEN_TIMESTAMPS = 1040
+export const GIFT_WRAP = 1059
+export const FILE_METADATA = 1063
+export const COMMENT = 1111
+export const VOICE_MESSAGE = 1222
+export const VOICE_MESSAGE_REPLY = 1244
+export const LIVE_CHAT_MESSAGE = 1311
+export const PROBLEM_TRACKER = 1971
+export const REPORT = 1984
+export const LABEL = 1985
+export const PRIVATE_CHANNEL_BROADCAST = 3560
+export const COMMUNITY_POST_APPROVAL = 4550
+export const JOB_REQUEST = 5999
+export const JOB_RESULT = 6999
+export const JOB_FEEDBACK = 7000
+export const ZAP_GOAL = 9041
+export const ZAP_REQUEST = 9734
+export const ZAP = 9735
+export const HIGHLIGHTS = 9802
+export const MUTE_LIST = 10000
+export const PINNED_NOTES = 10001
+export const READ_WRITE_RELAYS = 10002
+export const BOOKMARKS = 10003
+export const COMMUNITIES = 10004
+export const PUBLIC_CHATS = 10005
+export const BLOCKED_RELAYS = 10006
+export const SEARCH_RELAYS = 10007
+export const SIMPLE_GROUPS = 10009
+export const RELAY_FEEDS = 10012
+export const INTERESTS = 10015
+export const MEDIA_FOLLOWS = 10020
+export const EMOJIS = 10030
+export const DM_RELAYS = 10050
+export const FILE_SERVER_PREFERENCE = 10096
+export const GOOD_WIKI_AUTHORS = 10101
+export const GOOD_WIKI_RELAYS = 10102
+export const NWC_WALLET_INFO = 13194
+export const LIGHTNING_PUB_RPC = 21000
+export const AUTH = 22242
+export const NWC_WALLET_REQUEST = 23194
+export const NWC_WALLET_RESPONSE = 23195
+export const SIGNER_RPC = 24133
+export const HTTP_AUTH = 27235
+export const NWT = 27519
+export const FOLLOW_SET = 30000
+export const LIST = 30001
+export const RELAY_SET = 30002
+export const BOOKMARK_SET = 30003
+export const CURATION_SET = 30004
+export const VIDEO_CURATION_SET = 30005
+export const PICTURE_CURATION_SET = 30006
+export const KIND_MUTE_SET = 30007
+export const PROFILE_BADGES = 30008
+export const BADGE_DEFINITION = 30009
+export const INTEREST_SET = 30015
+export const CREATE_OR_UPDATE_STALL = 30017
+export const CREATE_OR_UPDATE_PRODUCT = 30018
+export const LONG_FORM_CONTENT = 30023
+export const DRAFT_LONG = 30024
+export const EMOJI_SET = 30030
+export const RELEASE_ARTIFACT_SET = 30063
+export const CUSTOM_APP_DATA = 30078
+export const APP_CURATION_SET = 30267
+export const LIVE_EVENT = 30311
+export const USER_STATUSES = 30315
+export const I_TAG_TRUSTED_ASSERTION = 30385
+export const CLASSIFIED_LISTING = 30402
+export const DRAFT_CLASSIFIED_LISTING = 30403
+export const DATE_BASED_CALENDAR_EVENT = 31922
+export const TIME_BASED_CALENDAR_EVENT = 31923
+export const CALENDAR = 31924
+export const CALENDAR_EVENT_RSVP = 31925
+export const HANDLER_RECOMMENDATION = 31989
+export const HANDLER_INFORMATION = 31990
+export const EDITABLE_VIDEO = 34235
+export const EDITABLE_SHORT_VIDEO = 34236
+export const COMMUNITY_DEFINITION = 34550
+export const BINARY_DATA_CHUNK = 34601
+export const MAIN_SITE_MANIFEST = 35128
+export const NEXT_SITE_MANIFEST = 35129
+export const DRAFT_SITE_MANIFEST = 35130
+export const STARTER_PACK = 39089
+export const MEDIA_STARTER_PACK = 39092
+
+const classifications = ['regular', 'replaceable', 'ephemeral', 'addressable']
+
+function isValidKind (kind) {
+  return Number.isInteger(kind) && kind >= 0 && kind <= 0xffff
+}
+
+export function isRegularKind (kind) {
+  return isValidKind(kind) && (
+    (kind >= 1000 && kind < 10000) ||
+    (kind >= 4 && kind < 45) ||
+    kind === 1 || kind === 2
+  )
+}
+
+export function isReplaceableKind (kind) {
+  return isValidKind(kind) && (kind === 0 || kind === 3 || (kind >= 10000 && kind < 20000))
+}
+
+export function isEphemeralKind (kind) {
+  return isValidKind(kind) && kind >= 20000 && kind < 30000
+}
+
+export function isAddressableKind (kind) {
+  return isValidKind(kind) && kind >= 30000 && kind < 40000
+}
+
+export function classifyKind (kind) {
+  const predicates = [isRegularKind, isReplaceableKind, isEphemeralKind, isAddressableKind]
+  return classifications.filter((_, index) => predicates[index](kind))
+}
+
+export const eventKinds = /* @__PURE__ */ Object.freeze({
+  METADATA,
+  TEXT_NOTE,
+  RECOMMEND_RELAY,
+  FOLLOWS,
+  ENCRYPTED_DIRECT_MESSAGE,
+  DELETION,
+  REPOST,
+  REACTION,
+  BADGE_AWARD,
+  SEAL,
+  PRIVATE_DIRECT_MESSAGE,
+  GENERIC_REPOST,
+  PICTURE,
+  VIDEO,
+  SHORT_VIDEO,
+  CHANNEL_CREATE,
+  CHANNEL_METADATA,
+  CHANNEL_MESSAGE,
+  CHANNEL_HIDE_MESSAGE,
+  CHANNEL_MUTE_USER,
+  REGULAR_CUSTOM_APP_DATA,
+  PERSONAL_COPY,
+  OPEN_TIMESTAMPS,
+  GIFT_WRAP,
+  FILE_METADATA,
+  COMMENT,
+  VOICE_MESSAGE,
+  VOICE_MESSAGE_REPLY,
+  LIVE_CHAT_MESSAGE,
+  PROBLEM_TRACKER,
+  REPORT,
+  LABEL,
+  PRIVATE_CHANNEL_BROADCAST,
+  COMMUNITY_POST_APPROVAL,
+  JOB_REQUEST,
+  JOB_RESULT,
+  JOB_FEEDBACK,
+  ZAP_GOAL,
+  ZAP_REQUEST,
+  ZAP,
+  HIGHLIGHTS,
+  MUTE_LIST,
+  PINNED_NOTES,
+  READ_WRITE_RELAYS,
+  BOOKMARKS,
+  COMMUNITIES,
+  PUBLIC_CHATS,
+  BLOCKED_RELAYS,
+  SEARCH_RELAYS,
+  SIMPLE_GROUPS,
+  RELAY_FEEDS,
+  INTERESTS,
+  MEDIA_FOLLOWS,
+  EMOJIS,
+  DM_RELAYS,
+  FILE_SERVER_PREFERENCE,
+  GOOD_WIKI_AUTHORS,
+  GOOD_WIKI_RELAYS,
+  NWC_WALLET_INFO,
+  LIGHTNING_PUB_RPC,
+  AUTH,
+  NWC_WALLET_REQUEST,
+  NWC_WALLET_RESPONSE,
+  SIGNER_RPC,
+  HTTP_AUTH,
+  NWT,
+  FOLLOW_SET,
+  LIST,
+  RELAY_SET,
+  BOOKMARK_SET,
+  CURATION_SET,
+  VIDEO_CURATION_SET,
+  PICTURE_CURATION_SET,
+  KIND_MUTE_SET,
+  PROFILE_BADGES,
+  BADGE_DEFINITION,
+  INTEREST_SET,
+  CREATE_OR_UPDATE_STALL,
+  CREATE_OR_UPDATE_PRODUCT,
+  LONG_FORM_CONTENT,
+  DRAFT_LONG,
+  EMOJI_SET,
+  RELEASE_ARTIFACT_SET,
+  CUSTOM_APP_DATA,
+  APP_CURATION_SET,
+  LIVE_EVENT,
+  USER_STATUSES,
+  I_TAG_TRUSTED_ASSERTION,
+  CLASSIFIED_LISTING,
+  DRAFT_CLASSIFIED_LISTING,
+  DATE_BASED_CALENDAR_EVENT,
+  TIME_BASED_CALENDAR_EVENT,
+  CALENDAR,
+  CALENDAR_EVENT_RSVP,
+  HANDLER_RECOMMENDATION,
+  HANDLER_INFORMATION,
+  EDITABLE_VIDEO,
+  EDITABLE_SHORT_VIDEO,
+  COMMUNITY_DEFINITION,
+  BINARY_DATA_CHUNK,
+  MAIN_SITE_MANIFEST,
+  NEXT_SITE_MANIFEST,
+  DRAFT_SITE_MANIFEST,
+  STARTER_PACK,
+  MEDIA_STARTER_PACK
+})