libp2r2p 0.8.0 → 0.10.0

package/nip44-v3/index.js

@@ -5,6 +5,7 @@ import { concatBytes, utf8ToBytes } from '@noble/hashes/utils.js'
 import { chacha20 } from '@noble/ciphers/chacha.js'
 import { bytesToBase64, base64ToBytes } from '../base64/index.js'
 import { sharedXOnlySecret } from '../ecdh/index.js'
+import { ValidationError } from '../error/index.js'
 
 // NIP-44 v3 — local implementation (spec.nostr.land/nip44v3)
 // Copied from the bunker testbench and verified against the vendored
@@ -34,7 +35,7 @@ function readU32be (b, off) {
   return new DataView(b.buffer, b.byteOffset, b.byteLength).getUint32(off, false)
 }
 
-function equalBytes (a, b) {
+function areBytesEqual (a, b) {
   if (a.length !== b.length) return false
   let diff = 0
   for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i]
@@ -47,7 +48,15 @@ function randomBytes32 () {
   return bytes
 }
 
+function assertBytes (value, code, length) {
+  if (!(value instanceof Uint8Array) || (length !== undefined && value.length !== length)) {
+    throw new ValidationError(code)
+  }
+  return value
+}
+
 export function deriveKeys (seckey, pubkey, nonce) {
+  assertBytes(nonce, 'INVALID_NONCE', 32)
   const shared = sharedXOnlySecret(seckey, pubkey)
   const salt = concatBytes(utf8ToBytes('nip44-v3\x00'), nonce)
   const prk = hkdfExtract(sha256, shared, salt)
@@ -71,6 +80,8 @@ export function payloadByteLength (plaintextByteLength, scopeByteLength = 0) {
 }
 
 export function deriveKeysFromConversationKey (conversationKey, nonce) {
+  assertBytes(conversationKey, 'INVALID_CONVERSATION_KEY', 32)
+  assertBytes(nonce, 'INVALID_NONCE', 32)
   const salt = concatBytes(utf8ToBytes('nip44-v3\x00'), nonce)
   const prk = hkdfExtract(sha256, conversationKey, salt)
   return {
@@ -87,6 +98,11 @@ export function encryptBytes (seckey, pubkey, kind, scope, plaintext, nonce) {
 
 export function encryptWithConversationKeyBytes (conversationKey, kind, scope, plaintext, nonce) {
   nonce ??= randomBytes32()
+  assertBytes(conversationKey, 'INVALID_CONVERSATION_KEY', 32)
+  kind = normalizeKind(kind)
+  assertBytes(scope, 'INVALID_SCOPE')
+  assertBytes(plaintext, 'INVALID_PLAINTEXT')
+  assertBytes(nonce, 'INVALID_NONCE', 32)
   const { encryption_key: encryptionKey, mac_key: macKey } = deriveKeysFromConversationKey(conversationKey, nonce)
   const prefixed = concatBytes(u32be(plaintext.length), plaintext)
   const padded = new Uint8Array(targetSize(prefixed.length))
@@ -102,34 +118,37 @@ export function decryptBytes (seckey, pubkey, expectedKind, expectedScope, ciphe
 }
 
 export function decryptWithConversationKeyBytes (conversationKey, expectedKind, expectedScope, ciphertext) {
-  if (!ciphertext || ciphertext.length === 0) throw new Error('empty ciphertext')
-  if (ciphertext[0] === '#') throw new Error('unsupported future version')
+  assertBytes(conversationKey, 'INVALID_CONVERSATION_KEY', 32)
+  expectedKind = normalizeKind(expectedKind)
+  assertBytes(expectedScope, 'INVALID_SCOPE')
+  if (typeof ciphertext !== 'string' || ciphertext.length === 0) throw new ValidationError('EMPTY_CIPHERTEXT', { message: 'empty ciphertext' })
+  if (ciphertext[0] === '#') throw new ValidationError('UNSUPPORTED_NIP44_VERSION', { message: 'unsupported future version' })
   let decoded
-  try { decoded = base64ToBytes(ciphertext) } catch { throw new Error('invalid base64') }
-  if (decoded.length < 77) throw new Error('ciphertext too short')
-  if (decoded[0] !== VERSION) throw new Error(`unsupported version ${decoded[0]}`)
+  try { decoded = base64ToBytes(ciphertext) } catch (cause) { throw new ValidationError('INVALID_BASE64', { message: 'invalid base64', cause }) }
+  if (decoded.length < 77) throw new ValidationError('NIP44_CIPHERTEXT_TOO_SHORT', { message: 'ciphertext too short' })
+  if (decoded[0] !== VERSION) throw new ValidationError('UNSUPPORTED_NIP44_VERSION', { message: `unsupported version ${decoded[0]}` })
   const nonce = decoded.subarray(1, 33)
   const mac = decoded.subarray(33, 65)
   const kind = readU32be(decoded, 65)
   const scopeLength = readU32be(decoded, 69)
-  if (scopeLength > decoded.length - 73) throw new Error('invalid scope length')
+  if (scopeLength > decoded.length - 73) throw new ValidationError('INVALID_NIP44_SCOPE_LENGTH', { message: 'invalid scope length' })
   const scope = decoded.subarray(73, 73 + scopeLength)
-  try { fatalTextDecoder.decode(scope) } catch { throw new Error('scope is not valid UTF-8') }
+  try { fatalTextDecoder.decode(scope) } catch (cause) { throw new ValidationError('INVALID_NIP44_SCOPE_UTF8', { message: 'scope is not valid UTF-8', cause }) }
   const ct = decoded.subarray(73 + scopeLength)
-  if (ct.length < 4) throw new Error('ciphertext too short')
-  if (kind !== expectedKind) throw new Error(`kind mismatch: got ${kind}, expected ${expectedKind}`)
-  if (!equalBytes(scope, expectedScope)) throw new Error('scope mismatch')
+  if (ct.length < 4) throw new ValidationError('NIP44_CIPHERTEXT_TOO_SHORT', { message: 'ciphertext too short' })
+  if (kind !== expectedKind) throw new ValidationError('NIP44_KIND_MISMATCH', { message: `kind mismatch: got ${kind}, expected ${expectedKind}` })
+  if (!areBytesEqual(scope, expectedScope)) throw new ValidationError('NIP44_SCOPE_MISMATCH', { message: 'scope mismatch' })
   const { encryption_key: encryptionKey, mac_key: macKey } = deriveKeysFromConversationKey(conversationKey, nonce)
   const authData = concatBytes(nonce, u32be(kind), u32be(scope.length), scope, ct)
-  if (!equalBytes(mac, hmac(sha256, macKey, authData))) throw new Error('invalid MAC')
+  if (!areBytesEqual(mac, hmac(sha256, macKey, authData))) throw new ValidationError('INVALID_MAC', { message: 'invalid MAC' })
   const padded = chacha(encryptionKey, ct)
   const plaintextLength = readU32be(padded, 0)
-  if (plaintextLength + 4 > padded.length) throw new Error('invalid plaintext length')
-  if (plaintextLength > 2 ** 31 - 1) throw new Error('plaintext too long')
+  if (plaintextLength + 4 > padded.length) throw new ValidationError('INVALID_PLAINTEXT_LENGTH', { message: 'invalid plaintext length' })
+  if (plaintextLength > 2 ** 31 - 1) throw new ValidationError('PLAINTEXT_TOO_LONG', { message: 'plaintext too long' })
   // Only verify the padding is all-zeroes. Per spec, implementations MUST NOT do any
   // other check on the padding length — non-standard zero-padding must decrypt.
   const padding = padded.subarray(4 + plaintextLength)
-  if (!equalBytes(padding, new Uint8Array(padding.length))) throw new Error('invalid padding')
+  if (!areBytesEqual(padding, new Uint8Array(padding.length))) throw new ValidationError('INVALID_PADDING', { message: 'invalid padding' })
   return padded.subarray(4, 4 + plaintextLength)
 }
 
@@ -139,7 +158,7 @@ function deriveSharedConversationKey (seckey, pubkey) {
 
 export function normalizeKind (kind) {
   const n = typeof kind === 'string' && kind.trim() !== '' ? Number(kind) : kind
-  if (!Number.isInteger(n) || n < 0 || n > 0xffffffff) throw new Error('INVALID_KIND')
+  if (!Number.isInteger(n) || n < 0 || n > 0xffffffff) throw new ValidationError('INVALID_KIND')
   return n
 }
 

package/nip46/helpers/frame.js

@@ -1,10 +1,10 @@
-import { finalizeEvent, verifyEvent } from 'nostr-tools'
-import { decrypt, encrypt, getConversationKey } from 'nostr-tools/nip44'
+import { finalizeEvent, isValidEvent } from '../../event/index.js'
+import { decrypt, encrypt, getConversationKey } from '../../nip44/index.js'
 import { NIP46_KIND } from '../constants/index.js'
 
 const PUBKEY = /^[0-9a-f]{64}$/
 
-export function validPubkey (value) {
+export function isValidPubkey (value) {
   return typeof value === 'string' && PUBKEY.test(value)
 }
 
@@ -14,9 +14,9 @@ export function hasPTag (event, pubkey) {
 
 export function isNip46EventFor (event, pubkey) {
   return event?.kind === NIP46_KIND &&
-    validPubkey(event.pubkey) &&
+    isValidPubkey(event.pubkey) &&
     hasPTag(event, pubkey) &&
-    verifyEvent(event)
+    isValidEvent(event)
 }
 
 export function decodeNip46Frame (event, secretKey) {
@@ -38,7 +38,7 @@ export function createNip46Event ({ secretKey, recipientPubkey, payload }) {
   }, secretKey)
 }
 
-export function validRequestFrame (frame) {
+export function isValidRequestFrame (frame) {
   return typeof frame?.id === 'string' && frame.id &&
     typeof frame.method === 'string' && frame.method &&
     Array.isArray(frame.params) && frame.params.every(param => typeof param === 'string')

package/nip46/helpers/url.js

@@ -1,3 +1,5 @@
+import { ValidationError } from '../../error/index.js'
+
 const PUBKEY = /^[0-9a-f]{64}$/
 
 function uniqueStrings (values) {
@@ -5,7 +7,7 @@ function uniqueStrings (values) {
   return [...new Set(values.filter(value => typeof value === 'string' && value))]
 }
 
-function validPubkey (value) {
+function isValidPubkey (value) {
   return typeof value === 'string' && PUBKEY.test(value)
 }
 
@@ -13,7 +15,7 @@ export function normalizeBunkerPointer (pointer) {
   if (!pointer || typeof pointer !== 'object') return null
   const remoteSignerPubkey = String(pointer.remoteSignerPubkey || '').toLowerCase()
   const relays = uniqueStrings(pointer.relays)
-  if (!validPubkey(remoteSignerPubkey) || !relays.length) return null
+  if (!isValidPubkey(remoteSignerPubkey) || !relays.length) return null
   return {
     remoteSignerPubkey,
     relays,
@@ -39,7 +41,7 @@ export function parseBunkerUrl (input) {
 // Serializes a direct NIP-46 bunker pointer without any network lookup.
 export function toBunkerUrl (pointer) {
   const normalized = normalizeBunkerPointer(pointer)
-  if (!normalized) throw new Error('INVALID_BUNKER_POINTER')
+  if (!normalized) throw new ValidationError('INVALID_BUNKER_POINTER')
   const url = new URL(`bunker://${normalized.remoteSignerPubkey}`)
   for (const relay of normalized.relays) url.searchParams.append('relay', relay)
   if (normalized.secret) url.searchParams.set('secret', normalized.secret)
@@ -58,8 +60,8 @@ export function createNostrConnectURI ({
 } = {}) {
   const normalizedPubkey = String(clientPubkey || '').toLowerCase()
   const normalizedRelays = uniqueStrings(relays)
-  if (!validPubkey(normalizedPubkey) || !normalizedRelays.length || typeof secret !== 'string' || !secret) {
-    throw new Error('INVALID_NOSTRCONNECT_URI')
+  if (!isValidPubkey(normalizedPubkey) || !normalizedRelays.length || typeof secret !== 'string' || !secret) {
+    throw new ValidationError('INVALID_NOSTRCONNECT_URI')
   }
 
   const uri = new URL(`nostrconnect://${normalizedPubkey}`)
@@ -78,7 +80,7 @@ export function parseNostrConnectURI (input) {
     const clientPubkey = url.hostname.toLowerCase()
     const relays = uniqueStrings(url.searchParams.getAll('relay'))
     const secret = url.searchParams.get('secret') || ''
-    if (url.protocol !== 'nostrconnect:' || !validPubkey(clientPubkey) || !relays.length || !secret) return null
+    if (url.protocol !== 'nostrconnect:' || !isValidPubkey(clientPubkey) || !relays.length || !secret) return null
     return {
       clientPubkey,
       relays,

package/nip46/services/bunker-signer.js

@@ -1,5 +1,6 @@
-import { verifyEvent } from 'nostr-tools'
-import { validPubkey } from '../helpers/frame.js'
+import { ValidationError } from '../../error/index.js'
+import { isValidEvent } from '../../event/index.js'
+import { isValidPubkey } from '../helpers/frame.js'
 import { Nip46Client } from './client.js'
 
 // A NIP-46 remote signer with the standard Nostr signing commands.
@@ -14,7 +15,7 @@ export class BunkerSigner extends Nip46Client {
   async getPublicKey (options) {
     if (!options?.extension && this.#cachedPubkey) return this.#cachedPubkey
     const pubkey = await this.sendRequest('get_public_key', [], options)
-    if (!validPubkey(pubkey)) throw new Error('NIP46_INVALID_PUBLIC_KEY')
+    if (!isValidPubkey(pubkey)) throw new ValidationError('NIP46_INVALID_PUBLIC_KEY')
     if (!options?.extension) this.#cachedPubkey = pubkey
     return pubkey
   }
@@ -24,10 +25,10 @@ export class BunkerSigner extends Nip46Client {
     let signed
     try {
       signed = JSON.parse(response)
-    } catch {
-      throw new Error('NIP46_INVALID_SIGNED_EVENT')
+    } catch (cause) {
+      throw new ValidationError('NIP46_INVALID_SIGNED_EVENT', { cause })
     }
-    if (!verifyEvent(signed)) throw new Error('NIP46_INVALID_SIGNED_EVENT')
+    if (!isValidEvent(signed)) throw new ValidationError('NIP46_INVALID_SIGNED_EVENT')
     return signed
   }
 

package/nip46/services/client.js

@@ -1,4 +1,5 @@
-import { getPublicKey } from 'nostr-tools'
+import { ValidationError } from '../../error/index.js'
+import { getPublicKey } from '../../key/index.js'
 import { relayPool as defaultRelayPool } from '../../relay/index.js'
 import {
   DEFAULT_TIMEOUT,
@@ -10,10 +11,10 @@ import {
   decodeNip46Frame,
   isNip46EventFor,
   requestError,
-  validRequestFrame
+  isValidRequestFrame
 } from '../helpers/frame.js'
 import { normalizeBunkerPointer, parseNostrConnectURI } from '../helpers/url.js'
-import { Nip46Transport, sameRelays, waitForNip46 } from './transport.js'
+import { areRelaySetsEqual, Nip46Transport, waitForNip46 } from './transport.js'
 
 function cleanClientMetadata (value) {
   if (!value || typeof value !== 'object') return null
@@ -41,7 +42,7 @@ export class Nip46Client {
     timeoutAfterFirstEose = DEFAULT_TIMEOUT_AFTER_FIRST_EOSE
   } = {}) {
     const normalized = normalizeBunkerPointer(pointer)
-    if (!normalized) throw new Error('INVALID_BUNKER_POINTER')
+    if (!normalized) throw new ValidationError('INVALID_BUNKER_POINTER')
     this.#secretKey = clientSecretKey
     this.#pointer = normalized
     this.#onAuthUrl = onAuthUrl
@@ -64,7 +65,7 @@ export class Nip46Client {
   static async fromURI (clientSecretKey, uri, options = {}) {
     const parsed = parseNostrConnectURI(uri)
     const clientPubkey = getPublicKey(clientSecretKey)
-    if (!parsed || clientPubkey !== parsed.clientPubkey) throw new Error('INVALID_NOSTRCONNECT_URI')
+    if (!parsed || clientPubkey !== parsed.clientPubkey) throw new ValidationError('INVALID_NOSTRCONNECT_URI')
 
     const relayPool = options.relayPool || defaultRelayPool
     const controller = new AbortController()
@@ -169,7 +170,7 @@ export class Nip46Client {
     if (relays === null) return false
 
     const nextPointer = normalizeBunkerPointer({ ...this.#pointer, relays })
-    if (!nextPointer || sameRelays(nextPointer.relays, this.#pointer.relays)) return false
+    if (!nextPointer || areRelaySetsEqual(nextPointer.relays, this.#pointer.relays)) return false
 
     const nextContext = this.#openResponseContext(nextPointer)
     try {
@@ -229,7 +230,7 @@ export class Nip46Client {
   }
 
   async #handleRequest (peerPubkey, request, context) {
-    if (!validRequestFrame(request)) {
+    if (!isValidRequestFrame(request)) {
       if (typeof request?.id === 'string') {
         await this.#transport.reply(peerPubkey, request.id, null, 'NIP46_INVALID_REQUEST', { context })
       }

package/nip46/services/server-session.js

@@ -1,11 +1,12 @@
+import { ValidationError } from '../../error/index.js'
 import { relayPool as defaultRelayPool } from '../../relay/index.js'
 import { DEFAULT_TIMEOUT, DEFAULT_TIMEOUT_AFTER_FIRST_EOSE, NIP46_KIND } from '../constants/index.js'
 import {
   decodeNip46Frame,
   isNip46EventFor,
-  validRequestFrame
+  isValidRequestFrame
 } from '../helpers/frame.js'
-import { Nip46Transport, sameRelays } from './transport.js'
+import { areRelaySetsEqual, Nip46Transport } from './transport.js'
 
 function cleanRelays (relays) {
   return [...new Set((Array.isArray(relays) ? relays : [])
@@ -48,8 +49,8 @@ export class Nip46ServerSession {
     timeoutAfterFirstEose = DEFAULT_TIMEOUT_AFTER_FIRST_EOSE
   } = {}) {
     this.#relays = cleanRelays(relays)
-    if (!this.#relays.length) throw new Error('NIP46_RELAYS_REQUIRED')
-    if (typeof secret !== 'string') throw new Error('NIP46_SECRET_REQUIRED')
+    if (!this.#relays.length) throw new ValidationError('NIP46_RELAYS_REQUIRED')
+    if (typeof secret !== 'string') throw new ValidationError('NIP46_SECRET_REQUIRED')
     this.#secretKey = serverSecretKey
     this.#secret = secret
     this.#onConnect = onConnect
@@ -85,8 +86,8 @@ export class Nip46ServerSession {
   // Opens replacements now and switches only after the client requests them.
   async updateRelays (relays) {
     const nextRelays = cleanRelays(relays)
-    if (!nextRelays.length) throw new Error('NIP46_RELAYS_REQUIRED')
-    if (sameRelays(nextRelays, this.#relays)) return false
+    if (!nextRelays.length) throw new ValidationError('NIP46_RELAYS_REQUIRED')
+    if (areRelaySetsEqual(nextRelays, this.#relays)) return false
     if (!this.#transport.activeContext) {
       this.#relays = nextRelays
       return true
@@ -137,7 +138,7 @@ export class Nip46ServerSession {
   }
 
   async #handleRequest (peerPubkey, request, context) {
-    if (!validRequestFrame(request)) {
+    if (!isValidRequestFrame(request)) {
       if (typeof request?.id === 'string') {
         await this.#transport.reply(peerPubkey, request.id, null, 'NIP46_INVALID_REQUEST', { context })
       }

package/nip46/services/transport.js

@@ -1,4 +1,5 @@
-import { getPublicKey } from 'nostr-tools'
+import { ValidationError } from '../../error/index.js'
+import { getPublicKey } from '../../key/index.js'
 import { relayPool as defaultRelayPool } from '../../relay/index.js'
 import { DEFAULT_TIMEOUT, DEFAULT_TIMEOUT_AFTER_FIRST_EOSE } from '../constants/index.js'
 import { createNip46Event, requestError } from '../helpers/frame.js'
@@ -14,9 +15,9 @@ function requestId () {
 
 function requestExtension (value) {
   if (value === undefined || value === null) return null
-  if (typeof value !== 'object' || Array.isArray(value)) throw new Error('NIP46_REQUEST_EXTENSION_REQUIRED')
+  if (typeof value !== 'object' || Array.isArray(value)) throw new ValidationError('NIP46_REQUEST_EXTENSION_REQUIRED')
   for (const key of ['id', 'method', 'params']) {
-    if (Object.hasOwn(value, key)) throw new Error(`NIP46_REQUEST_EXTENSION_CANNOT_SET_${key.toUpperCase()}`)
+    if (Object.hasOwn(value, key)) throw new ValidationError(`NIP46_REQUEST_EXTENSION_CANNOT_SET_${key.toUpperCase()}`)
   }
   return value
 }
@@ -46,7 +47,7 @@ export function waitForNip46 (promise, { timeout = null, signal, label = 'NIP46_
   })
 }
 
-export function sameRelays (left, right) {
+export function areRelaySetsEqual (left, right) {
   if (left.length !== right.length) return false
   const values = new Set(left)
   return right.every(value => values.has(value))
@@ -74,8 +75,8 @@ export class Nip46Transport {
     timeoutAfterFirstEose = DEFAULT_TIMEOUT_AFTER_FIRST_EOSE,
     onError
   } = {}) {
-    if (!(secretKey instanceof Uint8Array)) throw new Error('NIP46_SECRET_KEY_REQUIRED')
-    if (!relayPool?.getLiveEventsGenerator || !relayPool?.sendEvent) throw new Error('RELAY_POOL_REQUIRED')
+    if (!(secretKey instanceof Uint8Array)) throw new ValidationError('NIP46_SECRET_KEY_REQUIRED')
+    if (!relayPool?.getLiveEventsGenerator || !relayPool?.sendEvent) throw new ValidationError('RELAY_POOL_REQUIRED')
     this.#secretKey = secretKey
     this.#pubkey = getPublicKey(secretKey)
     this.#relayPool = relayPool
@@ -164,9 +165,9 @@ export class Nip46Transport {
     extension
   } = {}) {
     if (this.#closed) throw new Error('NIP46_CLOSED')
-    if (typeof method !== 'string' || !method) throw new Error('NIP46_METHOD_REQUIRED')
+    if (typeof method !== 'string' || !method) throw new ValidationError('NIP46_METHOD_REQUIRED')
     if (!Array.isArray(params) || !params.every(param => typeof param === 'string')) {
-      throw new Error('NIP46_PARAMS_REQUIRED')
+      throw new ValidationError('NIP46_PARAMS_REQUIRED')
     }
     if (signal?.aborted) throw new Error('Aborted')
     const context = this.#activeContext