libp2r2p 0.8.0 → 0.9.0

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

package/nip96/index.js

@@ -0,0 +1,285 @@
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { bytesToBase16 } from '../base16/index.js'
+import { ValidationError } from '../error/index.js'
+import { FILE_SERVER_PREFERENCE } from '../kind/index.js'
+
+const WELL_KNOWN_PATH = '/.well-known/nostr/nip96.json'
+
+function isValidHttpUrl (value) {
+  try {
+    const url = new URL(value)
+    return url.protocol === 'http:' || url.protocol === 'https:'
+  } catch {
+    return false
+  }
+}
+
+function combineSignal (signal, timeoutMs) {
+  if (signal?.aborted) throw signal.reason ?? new DOMException('This operation was aborted', 'AbortError')
+  const controller = new AbortController()
+  const onAbort = () => controller.abort(signal.reason)
+  signal?.addEventListener('abort', onAbort, { once: true })
+  const timeout = Number.isFinite(timeoutMs) && timeoutMs >= 0
+    ? setTimeout(() => controller.abort(new DOMException('NIP-96 request timed out', 'TimeoutError')), timeoutMs)
+    : null
+  return {
+    signal: controller.signal,
+    cleanup () {
+      if (timeout !== null) clearTimeout(timeout)
+      signal?.removeEventListener('abort', onAbort)
+    }
+  }
+}
+
+async function fetchJson (url, options, { fetch: fetchImpl = globalThis.fetch, signal, timeoutMs = 10000 } = {}) {
+  if (typeof fetchImpl !== 'function') throw new Error('FETCH_IS_NOT_AVAILABLE')
+  const combined = combineSignal(signal, timeoutMs)
+  try {
+    const response = await fetchImpl(url, { ...options, signal: combined.signal })
+    if (!response.ok) {
+      const error = new Error(`NIP-96 request failed with status ${response.status}`)
+      error.status = response.status
+      throw error
+    }
+    try {
+      return { response, data: await response.json() }
+    } catch (cause) {
+      throw new ValidationError('INVALID_NIP96_JSON_RESPONSE', { cause })
+    }
+  } finally {
+    combined.cleanup()
+  }
+}
+
+function serverConfigurationError (config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return 'INVALID_NIP96_SERVER_CONFIGURATION'
+  const hasApi = typeof config.api_url === 'string' && config.api_url.length > 0
+  const hasDelegation = typeof config.delegated_to_url === 'string' && config.delegated_to_url.length > 0
+  if (!hasApi && !hasDelegation) return 'NIP96_SERVER_CONFIGURATION_SOURCE_REQUIRED'
+  if (hasApi && hasDelegation) return 'NIP96_SERVER_CONFIGURATION_SOURCE_CONFLICT'
+  if (hasApi && !isValidHttpUrl(config.api_url)) return 'INVALID_NIP96_API_URL'
+  if (hasDelegation && !isValidHttpUrl(config.delegated_to_url)) return 'INVALID_NIP96_DELEGATION_URL'
+  if (config.download_url !== undefined && !isValidHttpUrl(config.download_url)) return 'INVALID_NIP96_DOWNLOAD_URL'
+  return null
+}
+
+export function isValidServerConfiguration (config) {
+  return serverConfigurationError(config) === null
+}
+
+export function assertValidServerConfiguration (config) {
+  const code = serverConfigurationError(config)
+  if (code) throw new ValidationError(code)
+  return config
+}
+
+export async function readServerConfig ({ serverUrl, fetch, signal, timeoutMs = 10000 }) {
+  if (!isValidHttpUrl(serverUrl)) throw new ValidationError('INVALID_SERVER_URL')
+  const firstUrl = new URL(WELL_KNOWN_PATH, new URL(serverUrl).origin)
+  const first = await fetchJson(firstUrl, { headers: { Accept: 'application/json' } }, { fetch, signal, timeoutMs })
+  assertValidServerConfiguration(first.data)
+  if (!first.data.delegated_to_url) return first.data
+
+  const delegated = await fetchJson(first.data.delegated_to_url, { headers: { Accept: 'application/json' } }, { fetch, signal, timeoutMs })
+  try {
+    assertValidServerConfiguration(delegated.data)
+  } catch (cause) {
+    throw new ValidationError('INVALID_DELEGATED_SERVER_CONFIGURATION', { cause })
+  }
+  if (delegated.data.delegated_to_url) throw new ValidationError('INVALID_DELEGATED_SERVER_CONFIGURATION')
+  return delegated.data
+}
+
+function fileUploadResponseError (response) {
+  if (!response || typeof response !== 'object' || Array.isArray(response)) return 'INVALID_NIP96_FILE_UPLOAD_RESPONSE'
+  if (!['success', 'error', 'processing'].includes(response.status)) return 'INVALID_NIP96_UPLOAD_STATUS'
+  if (typeof response.message !== 'string') return 'INVALID_NIP96_UPLOAD_MESSAGE'
+  if (response.status === 'processing' && !isValidHttpUrl(response.processing_url)) return 'INVALID_NIP96_PROCESSING_URL'
+  if (response.processing_url !== undefined && !isValidHttpUrl(response.processing_url)) return 'INVALID_NIP96_PROCESSING_URL'
+  if (response.status === 'success' && !response.nip94_event) return 'NIP96_FILE_METADATA_REQUIRED'
+  if (response.nip94_event !== undefined) {
+    const { tags } = response.nip94_event
+    if (!Array.isArray(tags) || tags.some(tag => !Array.isArray(tag) || tag.length < 2 || tag.some(value => typeof value !== 'string'))) return 'INVALID_NIP94_TAGS'
+    if (!tags.some(tag => tag[0] === 'url' && isValidHttpUrl(tag[1]))) return 'NIP94_URL_TAG_REQUIRED'
+    if (!tags.some(tag => tag[0] === 'ox' && /^[0-9a-f]{64}$/.test(tag[1]))) return 'NIP94_ORIGINAL_HASH_TAG_REQUIRED'
+  }
+  return null
+}
+
+export function isValidFileUploadResponse (response) {
+  return fileUploadResponseError(response) === null
+}
+
+export function assertValidFileUploadResponse (response) {
+  const code = fileUploadResponseError(response)
+  if (code) throw new ValidationError(code)
+  return response
+}
+
+function uploadError (status) {
+  const messages = {
+    400: 'Bad request! Some fields are missing or invalid!',
+    402: 'Payment required!',
+    403: 'Forbidden! Payload tag does not match the requested file!',
+    413: 'File too large!'
+  }
+  const error = new Error(messages[status] ?? 'Unknown error in uploading file!')
+  error.status = status
+  return error
+}
+
+function makeFormData (file, optionalFormDataFields) {
+  const formData = new FormData()
+  for (const [key, value] of Object.entries(optionalFormDataFields ?? {})) {
+    if (value !== undefined) formData.append(key, value)
+  }
+  formData.append('file', file)
+  return formData
+}
+
+function emitProgress (onProgress, event) {
+  if (typeof onProgress !== 'function') return
+  try { onProgress(event) } catch (error) { console.error('NIP-96 progress callback failed:', error) }
+}
+
+function uploadWithXhr ({ file, serverApiUrl, nip98AuthorizationHeader, optionalFormDataFields, onProgress, signal, timeoutMs, xhrFactory }) {
+  return new Promise((resolve, reject) => {
+    const xhr = xhrFactory ? xhrFactory() : new XMLHttpRequest()
+    const onAbort = () => xhr.abort()
+    const settle = callback => value => {
+      signal?.removeEventListener('abort', onAbort)
+      callback(value)
+    }
+    const resolveUpload = settle(resolve)
+    const rejectUpload = settle(reject)
+    xhr.open('POST', serverApiUrl, true)
+    if (nip98AuthorizationHeader) xhr.setRequestHeader('Authorization', nip98AuthorizationHeader)
+    if (Number.isFinite(timeoutMs) && timeoutMs >= 0) xhr.timeout = timeoutMs
+    xhr.upload.addEventListener('progress', event => emitProgress(onProgress, event))
+    xhr.addEventListener('abort', () => rejectUpload(signal?.reason ?? new DOMException('This operation was aborted', 'AbortError')))
+    xhr.addEventListener('timeout', () => rejectUpload(new DOMException('NIP-96 request timed out', 'TimeoutError')))
+    xhr.addEventListener('error', () => rejectUpload(new Error('NIP-96 upload failed')))
+    xhr.addEventListener('load', () => {
+      if (xhr.status < 200 || xhr.status >= 300) return rejectUpload(uploadError(xhr.status))
+      let data
+      try { data = JSON.parse(xhr.responseText) } catch (cause) {
+        return rejectUpload(new ValidationError('INVALID_UPLOAD_RESPONSE_JSON', { cause }))
+      }
+      try {
+        resolveUpload(assertValidFileUploadResponse(data))
+      } catch (error) {
+        rejectUpload(error)
+      }
+    })
+    if (signal?.aborted) return rejectUpload(signal.reason ?? new DOMException('This operation was aborted', 'AbortError'))
+    signal?.addEventListener('abort', onAbort, { once: true })
+    xhr.send(makeFormData(file, optionalFormDataFields))
+  })
+}
+
+export async function uploadFile ({
+  file,
+  serverApiUrl,
+  nip98AuthorizationHeader,
+  optionalFormDataFields = {},
+  onProgress,
+  signal,
+  timeoutMs = 30000,
+  fetch: fetchImpl,
+  xhrFactory
+}) {
+  if (!file || !isValidHttpUrl(serverApiUrl)) throw new ValidationError('INVALID_UPLOAD_ARGUMENTS')
+  if (!fetchImpl && (xhrFactory || typeof XMLHttpRequest === 'function') && typeof onProgress === 'function') {
+    return uploadWithXhr({ file, serverApiUrl, nip98AuthorizationHeader, optionalFormDataFields, onProgress, signal, timeoutMs, xhrFactory })
+  }
+
+  const total = Number.isFinite(file.size) ? file.size : 0
+  emitProgress(onProgress, { lengthComputable: Number.isFinite(file.size), loaded: 0, total })
+  let result
+  try {
+    result = await fetchJson(serverApiUrl, {
+      method: 'POST',
+      headers: nip98AuthorizationHeader ? { Authorization: nip98AuthorizationHeader } : {},
+      body: makeFormData(file, optionalFormDataFields)
+    }, { fetch: fetchImpl, signal, timeoutMs })
+  } catch (error) {
+    if (error.status) throw uploadError(error.status)
+    throw error
+  }
+  assertValidFileUploadResponse(result.data)
+  emitProgress(onProgress, { lengthComputable: Number.isFinite(file.size), loaded: total, total })
+  return result.data
+}
+
+export function generateDownloadUrl ({ fileHash, serverDownloadUrl, fileExtension = '' }) {
+  if (typeof fileHash !== 'string' || !isValidHttpUrl(serverDownloadUrl) || typeof fileExtension !== 'string') {
+    throw new ValidationError('INVALID_DOWNLOAD_ARGUMENTS')
+  }
+  return `${serverDownloadUrl.replace(/\/$/, '')}/${fileHash}${fileExtension}`
+}
+
+export async function deleteFile ({ fileHash, serverApiUrl, nip98AuthorizationHeader, fetch, signal, timeoutMs = 10000 }) {
+  const url = generateDownloadUrl({ fileHash, serverDownloadUrl: serverApiUrl })
+  const result = await fetchJson(url, {
+    method: 'DELETE',
+    headers: nip98AuthorizationHeader ? { Authorization: nip98AuthorizationHeader } : {}
+  }, { fetch, signal, timeoutMs })
+  return result.data
+}
+
+function delayedProcessingResponseError (response) {
+  if (!response || typeof response !== 'object' || Array.isArray(response)) return 'INVALID_NIP96_DELAYED_RESPONSE'
+  if (!['processing', 'error'].includes(response.status)) return 'INVALID_NIP96_DELAYED_STATUS'
+  if (typeof response.message !== 'string') return 'INVALID_NIP96_DELAYED_MESSAGE'
+  if (typeof response.percentage !== 'number' || !Number.isFinite(response.percentage) ||
+      response.percentage < 0 || response.percentage > 100) return 'INVALID_NIP96_DELAYED_PERCENTAGE'
+  return null
+}
+
+export function isValidDelayedProcessingResponse (response) {
+  return delayedProcessingResponseError(response) === null
+}
+
+export function assertValidDelayedProcessingResponse (response) {
+  const code = delayedProcessingResponseError(response)
+  if (code) throw new ValidationError(code)
+  return response
+}
+
+export async function checkFileProcessingStatus ({ processingUrl, fetch, signal, timeoutMs = 10000 }) {
+  if (!isValidHttpUrl(processingUrl)) throw new ValidationError('INVALID_PROCESSING_URL')
+  const { response, data } = await fetchJson(processingUrl, {}, { fetch, signal, timeoutMs })
+  if (response.status === 201) return assertValidFileUploadResponse(data)
+  if (response.status === 200) return assertValidDelayedProcessingResponse(data)
+  throw new ValidationError('INVALID_PROCESSING_RESPONSE')
+}
+
+export function generateFSPEventTemplate ({ serverUrls, createdAt = Math.floor(Date.now() / 1000) }) {
+  if (!Array.isArray(serverUrls)) throw new ValidationError('SERVER_URLS_SHOULD_BE_AN_ARRAY')
+  return {
+    kind: FILE_SERVER_PREFERENCE,
+    content: '',
+    tags: serverUrls.filter(isValidHttpUrl).map(serverUrl => ['server', serverUrl]),
+    created_at: createdAt
+  }
+}
+
+export async function calculateFileHash (file) {
+  if (!file || typeof file.stream !== 'function') {
+    if (!file || typeof file.arrayBuffer !== 'function') throw new ValidationError('FILE_SHOULD_BE_A_BLOB')
+    return bytesToBase16(sha256(new Uint8Array(await file.arrayBuffer())))
+  }
+  const hash = sha256.create()
+  const reader = file.stream().getReader()
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      hash.update(value)
+    }
+    return bytesToBase16(hash.digest())
+  } finally {
+    reader.releaseLock()
+  }
+}

package/nip98/index.js

@@ -0,0 +1,56 @@
+import { sha256 } from '@noble/hashes/sha2.js'
+
+import { bytesToBase16 } from '../base16/index.js'
+import { bytesToBase64 } from '../base64/index.js'
+import { ValidationError } from '../error/index.js'
+import { isValidEvent } from '../event/index.js'
+import { HTTP_AUTH } from '../kind/index.js'
+
+const encoder = new TextEncoder()
+const PAYLOAD_HASH = /^[0-9a-f]{64}$/
+
+async function payloadBytes (payload) {
+  if (typeof payload === 'string') return encoder.encode(payload)
+  if (payload instanceof Uint8Array) return payload
+  if (payload instanceof ArrayBuffer) return new Uint8Array(payload)
+  if (ArrayBuffer.isView(payload)) return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength)
+  if (typeof Blob === 'function' && payload instanceof Blob) return new Uint8Array(await payload.arrayBuffer())
+  throw new ValidationError('INVALID_PAYLOAD')
+}
+
+export async function getToken ({
+  loginUrl,
+  httpMethod,
+  signEvent,
+  includeAuthorizationScheme = false,
+  payload,
+  payloadHash
+}) {
+  if (typeof loginUrl !== 'string' || loginUrl.length === 0) throw new ValidationError('INVALID_LOGIN_URL')
+  try { new URL(loginUrl) } catch (cause) { throw new ValidationError('INVALID_LOGIN_URL', { cause }) }
+  if (typeof httpMethod !== 'string' || httpMethod.trim().length === 0) throw new ValidationError('INVALID_HTTP_METHOD')
+  if (typeof signEvent !== 'function') throw new ValidationError('SIGN_EVENT_SHOULD_BE_A_FUNCTION')
+  if (payload !== undefined && payloadHash !== undefined) throw new ValidationError('PAYLOAD_AND_HASH_ARE_MUTUALLY_EXCLUSIVE')
+
+  let hash = payloadHash
+  if (payload !== undefined) hash = bytesToBase16(sha256(await payloadBytes(payload)))
+  if (hash !== undefined && !PAYLOAD_HASH.test(hash)) throw new ValidationError('INVALID_PAYLOAD_HASH')
+
+  const method = httpMethod.trim().toUpperCase()
+  const tags = [['u', loginUrl], ['method', method]]
+  if (hash !== undefined) tags.push(['payload', hash])
+  const event = await signEvent({
+    kind: HTTP_AUTH,
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+    content: ''
+  })
+  if (!isValidEvent(event) || event.kind !== HTTP_AUTH) throw new ValidationError('INVALID_SIGNED_HTTP_AUTH_EVENT')
+  if (!event.tags.some(tag => tag[0] === 'u' && tag[1] === loginUrl) ||
+      !event.tags.some(tag => tag[0] === 'method' && tag[1] === method) ||
+      (hash !== undefined && !event.tags.some(tag => tag[0] === 'payload' && tag[1] === hash))) {
+    throw new ValidationError('SIGNED_HTTP_AUTH_EVENT_WAS_CHANGED')
+  }
+  const token = bytesToBase64(encoder.encode(JSON.stringify(event)))
+  return includeAuthorizationScheme ? `Nostr ${token}` : token
+}