libp2r2p 0.0.1

package/relay/services/query.js

@@ -0,0 +1,224 @@
+import { freeRelays, seedRelays } from '../constants/index.js'
+import { relayPool } from './relay-pool.js'
+
+const QUERY_CACHE_MS = 40 * 60 * 1000
+const RELAY_CACHE_MAX_ITEMS = 500
+const HEX_PUBKEY = /^[0-9a-f]{64}$/i
+const relaysByPubkey = Object.create(null)
+const relayCacheTimersByPubkey = Object.create(null)
+const relayCacheAddedAtByPubkey = Object.create(null)
+const relayCacheEventCreatedAtByPubkey = Object.create(null)
+
+const getEvents = (...args) => relayPool.getEvents(...args)
+const getEventsFeedGenerator = (...args) => relayPool.getEventsFeedGenerator(...args)
+
+function hasCachedKey (cache, key) {
+  return Object.prototype.hasOwnProperty.call(cache, key)
+}
+
+function maybeUnref (timer) {
+  timer?.unref?.()
+  return timer
+}
+
+function cloneRelays (relays) {
+  return {
+    read: [...(relays?.read || [])],
+    write: [...(relays?.write || [])]
+  }
+}
+
+// NIP-65 relay-list tags without a marker apply to both read and write use.
+function parseRelayListEvent (event) {
+  const out = { read: [], write: [] }
+  if (!event || event.kind !== 10002) return out
+  for (const tag of event.tags) {
+    if (tag[0] !== 'r' || typeof tag[1] !== 'string') continue
+    if (tag[2] === 'read') out.read.push(tag[1])
+    else if (tag[2] === 'write') out.write.push(tag[1])
+    else { out.read.push(tag[1]); out.write.push(tag[1]) }
+  }
+  out.read = [...new Set(out.read)]
+  out.write = [...new Set(out.write)]
+  return out
+}
+
+function uniquePubkeys (pubkeys, { requireHex = false } = {}) {
+  const values = [...new Set(pubkeys || [])].filter(Boolean)
+  return requireHex ? values.filter(pubkey => HEX_PUBKEY.test(pubkey)) : values
+}
+
+function relayListCreatedAt (event) {
+  return Number.isFinite(event?.created_at) ? event.created_at : 0
+}
+
+function relaySetsEqual (a, b) {
+  const left = new Set(a || [])
+  const right = new Set(b || [])
+  if (left.size !== right.size) return false
+  for (const value of left) if (!right.has(value)) return false
+  return true
+}
+
+function relaySetChanges (previous, next) {
+  const read = !relaySetsEqual(previous?.read, next?.read)
+  const write = !relaySetsEqual(previous?.write, next?.write)
+  return {
+    read,
+    write,
+    both: read || write
+  }
+}
+
+function relayTypeChanged (changes, relayType) {
+  if (relayType === 'read') return changes.read
+  if (relayType === 'write') return changes.write
+  return changes.both
+}
+
+function deleteCachedRelay (pubkey) {
+  clearTimeout(relayCacheTimersByPubkey[pubkey])
+  delete relaysByPubkey[pubkey]
+  delete relayCacheTimersByPubkey[pubkey]
+  delete relayCacheAddedAtByPubkey[pubkey]
+  delete relayCacheEventCreatedAtByPubkey[pubkey]
+}
+
+function setCachedRelays (pubkey, relays, createdAt, cacheMs) {
+  relaysByPubkey[pubkey] = cloneRelays(relays)
+  relayCacheAddedAtByPubkey[pubkey] = Date.now()
+  relayCacheEventCreatedAtByPubkey[pubkey] = createdAt
+  clearTimeout(relayCacheTimersByPubkey[pubkey])
+  if (cacheMs > 0) {
+    relayCacheTimersByPubkey[pubkey] = maybeUnref(setTimeout(() => {
+      deleteCachedRelay(pubkey)
+    }, cacheMs))
+  } else {
+    delete relayCacheTimersByPubkey[pubkey]
+  }
+}
+
+function pruneRelayCache () {
+  const keys = Object.keys(relaysByPubkey)
+  if (keys.length <= RELAY_CACHE_MAX_ITEMS) return
+
+  keys
+    .sort((a, b) => (relayCacheAddedAtByPubkey[a] || 0) - (relayCacheAddedAtByPubkey[b] || 0))
+    .slice(0, keys.length - RELAY_CACHE_MAX_ITEMS)
+    .forEach(deleteCachedRelay)
+}
+
+export function clearRelayQueryCache () {
+  for (const timer of Object.values(relayCacheTimersByPubkey)) clearTimeout(timer)
+  for (const key of Object.keys(relaysByPubkey)) delete relaysByPubkey[key]
+  for (const key of Object.keys(relayCacheTimersByPubkey)) delete relayCacheTimersByPubkey[key]
+  for (const key of Object.keys(relayCacheAddedAtByPubkey)) delete relayCacheAddedAtByPubkey[key]
+  for (const key of Object.keys(relayCacheEventCreatedAtByPubkey)) delete relayCacheEventCreatedAtByPubkey[key]
+}
+
+export function cacheRelayListEvent (event, { cacheMs = QUERY_CACHE_MS } = {}) {
+  if (!event || event.kind !== 10002 || !event.pubkey) return null
+  const createdAt = relayListCreatedAt(event)
+  const previousCreatedAt = relayCacheEventCreatedAtByPubkey[event.pubkey]
+  if (previousCreatedAt != null && createdAt <= previousCreatedAt) return null
+
+  const previousRelays = hasCachedKey(relaysByPubkey, event.pubkey)
+    ? cloneRelays(relaysByPubkey[event.pubkey])
+    : null
+  const relays = parseRelayListEvent(event)
+  const changes = relaySetChanges(previousRelays, relays)
+  setCachedRelays(event.pubkey, relays, createdAt, cacheMs)
+  pruneRelayCache()
+
+  return {
+    pubkey: event.pubkey,
+    event,
+    relays: cloneRelays(relays),
+    previousRelays,
+    changes
+  }
+}
+
+export function subscribeRelayListUpdates (pubkeys, {
+  relayType = 'both',
+  onChange,
+  relays = seedRelays,
+  cacheMs = QUERY_CACHE_MS,
+  _eventsFeedGenerator = getEventsFeedGenerator
+} = {}) {
+  const authors = uniquePubkeys(pubkeys, { requireHex: _eventsFeedGenerator === getEventsFeedGenerator })
+  if (!authors.length) return () => {}
+
+  let closed = false
+  const controller = new AbortController()
+
+  async function consumeRelayListUpdates () {
+    try {
+      for await (const event of _eventsFeedGenerator({
+        kinds: [10002],
+        authors
+      }, relays, {
+        signal: controller.signal,
+        timeout: 5000,
+        timeoutAfterFirstEose: null
+      })) {
+        if (closed || !authors.includes(event.pubkey)) continue
+        const update = cacheRelayListEvent(event, { cacheMs })
+        if (!update || !relayTypeChanged(update.changes, relayType)) continue
+        onChange?.({
+          ...update,
+          relayType
+        })
+      }
+    } catch (error) {
+      if (!closed && error?.message !== 'Aborted') console.error('relay-list watch failed:', error)
+    }
+  }
+
+  consumeRelayListUpdates()
+
+  return () => {
+    closed = true
+    controller.abort()
+  }
+}
+
+export async function getRelaysByPubkey (pubkeys, { _getEvents = getEvents, cacheMs = QUERY_CACHE_MS } = {}) {
+  const pubkeyList = uniquePubkeys(pubkeys, { requireHex: _getEvents === getEvents })
+  if (!pubkeyList.length) return {}
+
+  const out = {}
+  const missingPubkeys = []
+  for (const pubkey of pubkeyList) {
+    if (hasCachedKey(relaysByPubkey, pubkey)) out[pubkey] = cloneRelays(relaysByPubkey[pubkey])
+    else missingPubkeys.push(pubkey)
+  }
+  if (!missingPubkeys.length) return out
+
+  const { result: events } = await _getEvents({
+    kinds: [10002],
+    authors: missingPubkeys,
+    limit: missingPubkeys.length
+  }, seedRelays, {
+    timeout: 5000,
+    timeoutAfterFirstEose: null
+  })
+
+  const latestByPubkey = {}
+  for (const event of events) {
+    if (!missingPubkeys.includes(event.pubkey)) continue
+    if (!latestByPubkey[event.pubkey] || event.created_at > latestByPubkey[event.pubkey].created_at) {
+      latestByPubkey[event.pubkey] = event
+    }
+  }
+
+  for (const pubkey of missingPubkeys) {
+    const relays = latestByPubkey[pubkey]
+      ? parseRelayListEvent(latestByPubkey[pubkey])
+      : { read: freeRelays.slice(0, 2), write: freeRelays.slice(0, 2) }
+    setCachedRelays(pubkey, relays, relayListCreatedAt(latestByPubkey[pubkey]), cacheMs)
+    out[pubkey] = relays
+  }
+  pruneRelayCache()
+  return out
+}

package/relay/services/relay-connection.js

@@ -0,0 +1,156 @@
+import { Relay } from 'nostr-tools/relay'
+import { maybeUnref } from '../helpers/timer.js'
+
+function relayError (reason, fallback) {
+  return reason instanceof Error ? reason : new Error(reason || fallback)
+}
+
+// Relay.auth() caches one authentication promise per connection. NIP-42 permits
+// several pubkeys on one connection, so this adapter tracks AUTH replies by
+// signed auth-event id instead of using Relay.auth().
+export class RelayConnection extends Relay {
+  #challenge = null
+  #pendingAuths = new Map()
+  #countSerial = 0
+  #pendingCounts = new Map()
+
+  constructor (url) {
+    super(url)
+    this.onclose = () => {
+      this.#challenge = null
+      this.#rejectPendingAuths(new Error('AUTH_CONNECTION_CLOSED'))
+      this.#rejectPendingCounts(new Error('COUNT_CONNECTION_CLOSED'))
+    }
+  }
+
+  #settleAuth (eventId, { success, reason }) {
+    const pending = this.#pendingAuths.get(eventId)
+    if (!pending) return
+
+    this.#pendingAuths.delete(eventId)
+    clearTimeout(pending.timer)
+    if (success) pending.resolve(reason)
+    else pending.reject(relayError(reason, 'AUTH_REJECTED'))
+  }
+
+  #rejectPendingAuths (reason) {
+    for (const eventId of [...this.#pendingAuths.keys()]) {
+      this.#settleAuth(eventId, { success: false, reason })
+    }
+  }
+
+  #settleCount (id, { payload, reason }) {
+    const pending = this.#pendingCounts.get(id)
+    if (!pending) return
+
+    this.#pendingCounts.delete(id)
+    pending.signal?.removeEventListener('abort', pending.onAbort)
+    if (reason !== undefined) pending.reject(relayError(reason, 'COUNT_REJECTED'))
+    else pending.resolve(payload)
+  }
+
+  #rejectPendingCounts (reason) {
+    for (const id of [...this.#pendingCounts.keys()]) {
+      this.#settleCount(id, { reason })
+    }
+  }
+
+  // Sends a caller-signed AUTH event and waits for the matching NIP-42 OK.
+  // Each auth event is independent, so different pubkeys can share this socket.
+  async authenticate (getAuthEvent) {
+    if (!this.#challenge) throw new Error('AUTH_CHALLENGE_MISSING')
+
+    const event = await getAuthEvent({
+      relay: this.url,
+      challenge: this.#challenge
+    })
+    if (typeof event?.id !== 'string' || !event.id) throw new Error('AUTH_EVENT_ID_REQUIRED')
+    const existing = this.#pendingAuths.get(event.id)
+    if (existing) return existing.promise
+
+    let resolveAuth
+    let rejectAuth
+    const promise = new Promise((resolve, reject) => {
+      resolveAuth = resolve
+      rejectAuth = reject
+    })
+    const timer = maybeUnref(setTimeout(() => {
+      this.#settleAuth(event.id, { success: false, reason: new Error('AUTH_TIMEOUT') })
+    }, this.publishTimeout))
+    this.#pendingAuths.set(event.id, {
+      resolve: resolveAuth,
+      reject: rejectAuth,
+      timer,
+      promise
+    })
+
+    Promise.resolve(this.send(JSON.stringify(['AUTH', event]))).catch(reason => {
+      this.#settleAuth(event.id, { success: false, reason })
+    })
+    return promise
+  }
+
+  // nostr-tools@2.23.5 exposes only Relay.count(), which discards the NIP-45
+  // HLL payload. Keep these requests separate so callers can aggregate it.
+  countWithHll (filters, { signal } = {}) {
+    if (signal?.aborted) return Promise.reject(new Error('COUNT_ABORTED'))
+
+    const id = `p2r2p-count:${++this.#countSerial}`
+    let resolveCount
+    let rejectCount
+    const promise = new Promise((resolve, reject) => {
+      resolveCount = resolve
+      rejectCount = reject
+    })
+    const onAbort = () => {
+      this.#settleCount(id, { reason: new Error('COUNT_ABORTED') })
+    }
+    this.#pendingCounts.set(id, {
+      resolve: resolveCount,
+      reject: rejectCount,
+      signal,
+      onAbort
+    })
+    signal?.addEventListener('abort', onAbort, { once: true })
+
+    let message
+    try {
+      message = JSON.stringify(['COUNT', id, ...filters])
+    } catch (error) {
+      this.#settleCount(id, { reason: error })
+      return promise
+    }
+    Promise.resolve(this.send(message)).catch(reason => {
+      this.#settleCount(id, { reason })
+    })
+    return promise
+  }
+
+  // Relay assigns this method to its WebSocket handler while connecting. Capture
+  // AUTH and raw COUNT replies before Relay's parser discards COUNT HLL payloads.
+  _onmessage (message) {
+    try {
+      const data = JSON.parse(message.data)
+      if (data[0] === 'AUTH' && typeof data[1] === 'string') {
+        this.#challenge = data[1]
+      } else if (data[0] === 'OK' && typeof data[1] === 'string') {
+        this.#settleAuth(data[1], { success: data[2] === true, reason: data[3] })
+      } else if (data[0] === 'COUNT' && typeof data[1] === 'string') {
+        this.#settleCount(data[1], { payload: data[2] })
+      } else if (data[0] === 'CLOSED' && typeof data[1] === 'string') {
+        this.#settleCount(data[1], { reason: data[2] || 'COUNT_CLOSED' })
+      }
+    } catch {
+      // Relay's own parser below reports malformed relay messages.
+    }
+
+    return super._onmessage(message)
+  }
+
+  close () {
+    this.#challenge = null
+    this.#rejectPendingAuths(new Error('AUTH_CONNECTION_CLOSED'))
+    this.#rejectPendingCounts(new Error('COUNT_CONNECTION_CLOSED'))
+    return super.close()
+  }
+}