libp2r2p 0.0.1

package/private-messenger/recovery/index.js

@@ -0,0 +1,316 @@
+import { getEventHash } from 'nostr-tools'
+import { bytesToBase64, base64ToBytes } from '../../base64/index.js'
+import { ASK_KIND, parseRumorContent } from '../../private-message/index.js'
+
+export const SEEDER_PRESENCE_CODE = 'seederPresence_8mj8'
+export const MISSING_MESSAGES_ASK_CODE = 'missingMessages_ask_8mj8'
+export const MISSING_MESSAGES_REPLY_CODE = 'missingMessages_reply_8mj8'
+export const ROUTER_SEED_RECORD_TYPE = 'routerEnvelopeRow_v1'
+export const NYM_CARRIER_SEED_RECORD_TYPE = 'nymCarrier_v1'
+
+const DEFAULT_EVENTS_PER_CHUNK = 100
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+const HASH_PUBKEY = '0'.repeat(64)
+
+function nowSeconds () {
+  return Math.floor(Date.now() / 1000)
+}
+
+function isPlainObject (value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function parseEventContent (event) {
+  return parseRumorContent(event)
+}
+
+function splitJsonl (jsonl) {
+  return String(jsonl || '').split('\n').filter(Boolean)
+}
+
+function decodeJsonl (content) {
+  try { return decoder.decode(base64ToBytes(content || '')) } catch { return '' }
+}
+
+function encodeJsonlRows (...rows) {
+  return bytesToBase64(encoder.encode(rows.map(row => String(row).endsWith('\n') ? row : `${row}\n`).join('')))
+}
+
+function eventInRange (event, since, until) {
+  if (!Number.isFinite(event?.created_at)) return true
+  if (since != null && event.created_at < since) return false
+  if (until != null && event.created_at > until) return false
+  return true
+}
+
+function compactRouter (router = {}) {
+  return {
+    kind: router.kind,
+    pubkey: router.pubkey,
+    created_at: router.created_at,
+    tags: (router.tags || []).filter(tag => tag[0] !== 'c')
+  }
+}
+
+function cloneTags (tags) {
+  return (tags || []).map(tag => Array.isArray(tag) ? [...tag] : tag)
+}
+
+export function compactSeedRouter (router = {}) {
+  return {
+    ...compactRouter(router),
+    content: router.content || ''
+  }
+}
+
+function parseRouterRow (line) {
+  try {
+    const record = JSON.parse(line)
+    if (!Array.isArray(record) || record.length === 1) return null
+    return {
+      receiverPubkey: record[0] || '',
+      iykcPubkey: record[2] || ''
+    }
+  } catch {
+    return null
+  }
+}
+
+function parsePayloadRow (line) {
+  try {
+    const record = JSON.parse(line)
+    if (!Array.isArray(record) || record.length !== 1 || typeof record[0] !== 'string') return ''
+    return line
+  } catch {
+    return ''
+  }
+}
+
+function rowHash (payloadRow, row) {
+  return getEventHash({
+    kind: 0,
+    pubkey: HASH_PUBKEY,
+    created_at: 0,
+    tags: [],
+    content: `${payloadRow}\n${row}`
+  })
+}
+
+export function compactSeedRouterRows (seed = {}) {
+  const router = compactRouter(seed.router)
+  const createdAt = router.created_at || seed.outer?.created_at || nowSeconds()
+  const rows = []
+  const innerEventIdsByRowIndex = seed.innerEventIdsByRowIndex || {}
+  const lines = splitJsonl(seed.jsonl || decodeJsonl(seed.router?.content))
+  const payloadRow = parsePayloadRow(lines[0])
+  if (!payloadRow) return []
+  for (let index = 0; index < lines.length; index++) {
+    const row = lines[index]
+    const parsed = parseRouterRow(row)
+    if (!parsed?.receiverPubkey) continue
+    const innerEventId = innerEventIdsByRowIndex[index] || innerEventIdsByRowIndex[String(index)] || ''
+    rows.push({
+      type: 'seed',
+      recordType: ROUTER_SEED_RECORD_TYPE,
+      router,
+      receiverPubkey: parsed.receiverPubkey,
+      iykcPubkey: parsed.iykcPubkey,
+      innerEventId,
+      rowHash: innerEventId ? '' : rowHash(payloadRow, row),
+      payloadRow,
+      row,
+      firstSeenAt: createdAt,
+      lastSeenAt: createdAt
+    })
+  }
+  return rows
+}
+
+export function routerSeedRowKey (seed = {}) {
+  const row = seed.row ? parseRouterRow(seed.row) : null
+  const innerEventId = seed.innerEventId || ''
+  const fallbackRowHash = seed.rowHash || (seed.payloadRow && seed.row ? rowHash(seed.payloadRow, seed.row) : '')
+  return [
+    seed.channelPubkey || '',
+    seed.receiverPubkey || row?.receiverPubkey || '',
+    innerEventId ? `event:${innerEventId}` : `row:${fallbackRowHash}`
+  ].join(':')
+}
+
+export function compactSeedNymCarriers (carriers = []) {
+  return carriers.map(carrier => ({
+    id: carrier.id,
+    kind: carrier.kind,
+    pubkey: carrier.pubkey,
+    created_at: carrier.created_at,
+    tags: cloneTags(carrier.tags),
+    content: carrier.content || '',
+    sig: carrier.sig
+  }))
+}
+
+function routerWithSingleRow (router, payloadRow, row) {
+  const compact = compactRouter(router)
+  return {
+    ...compact,
+    tags: compact.tags.concat([['c', '0', '1']]),
+    content: encodeJsonlRows(payloadRow, row)
+  }
+}
+
+function seedRowInRange (seed, since, until) {
+  const firstSeenAt = seed.firstSeenAt ?? seed.router?.created_at
+  const lastSeenAt = seed.lastSeenAt ?? seed.router?.created_at
+  if (!Number.isFinite(firstSeenAt) || !Number.isFinite(lastSeenAt)) return eventInRange(seed.router, since, until)
+  if (since != null && lastSeenAt < since) return false
+  if (until != null && firstSeenAt > until) return false
+  return true
+}
+
+function compactRoutersFromSeed (seed, { receiverPubkey, since, until }) {
+  if (!seed?.payloadRow || !seed?.row || !seed?.router || !seedRowInRange(seed, since, until)) return []
+  if (receiverPubkey && seed.receiverPubkey !== receiverPubkey) return []
+  return [{
+    recordType: ROUTER_SEED_RECORD_TYPE,
+    router: routerWithSingleRow(seed.router, seed.payloadRow, seed.row)
+  }]
+}
+
+function nymCarrierRecordTime (seed) {
+  return seed?.carriers?.reduce((max, carrier) => Math.max(max, carrier.created_at || 0), 0) || 0
+}
+
+function compactNymCarriersFromSeed (seed, { since, until }) {
+  // eslint-disable-next-line camelcase
+  const created_at = nymCarrierRecordTime(seed)
+  // eslint-disable-next-line camelcase
+  if (!seed?.carriers?.length || !eventInRange({ created_at }, since, until)) return []
+  return [{
+    recordType: NYM_CARRIER_SEED_RECORD_TYPE,
+    carriers: compactSeedNymCarriers(seed.carriers)
+  }]
+}
+
+function compactRecordsFromSeed (seed, { receiverPubkey, since, until }) {
+  if (seed?.recordType === NYM_CARRIER_SEED_RECORD_TYPE) {
+    return compactNymCarriersFromSeed(seed, { since, until })
+  }
+  if (seed?.recordType === ROUTER_SEED_RECORD_TYPE) {
+    return compactRoutersFromSeed(seed, { receiverPubkey, since, until })
+  }
+  return []
+}
+
+function backfillRequestRange (question, since, until) {
+  const content = parseEventContent({ ...question, kind: ASK_KIND })
+  const payload = isPlainObject(content?.payload) ? content.payload : {}
+  return {
+    since: since ?? payload.since ?? 0,
+    until: until ?? payload.until ?? nowSeconds()
+  }
+}
+
+function eventRecordFromInput (event) {
+  return Number.isInteger(event?.kind) ? [event] : []
+}
+
+export function createEventReplyPacker ({
+  messenger,
+  channelPubkey,
+  question,
+  receiverPubkey = question?.pubkey,
+  code,
+  payload = {},
+  eventsPerChunk = DEFAULT_EVENTS_PER_CHUNK,
+  recordsFromInput = eventRecordFromInput,
+  sendEmptyReply = false
+}) {
+  if (!messenger?.reply) throw new Error('MESSENGER_REQUIRED')
+  if (!question?.id) throw new Error('QUESTION_REQUIRED')
+  if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
+  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new Error('INVALID_EVENTS_PER_CHUNK')
+
+  let chunk = ''
+  let chunkEvents = 0
+  let index = 0
+  let finalized = false
+  let published = false
+
+  async function publish (isLast) {
+    const jsonl = chunk
+    chunk = ''
+    chunkEvents = 0
+    published = true
+    await messenger.reply({
+      channelPubkey,
+      question,
+      receiverPubkey,
+      code,
+      payload: {
+        ...payload,
+        index: index++,
+        isLast,
+        jsonl
+      }
+    })
+  }
+
+  async function appendRecord (record, { flush = true } = {}) {
+    chunk += `${JSON.stringify(record)}\n`
+    chunkEvents++
+    if (flush && chunkEvents >= eventsPerChunk) await publish(false)
+  }
+
+  async function appendRecords (records, { final = false } = {}) {
+    for (let i = 0; i < records.length; i++) {
+      const isLast = final && i === records.length - 1
+      await appendRecord(records[i], { flush: !isLast })
+    }
+  }
+
+  async function update (input) {
+    if (finalized) throw new Error('PACKER_FINALIZED')
+    await appendRecords(await recordsFromInput(input))
+  }
+
+  async function finalize (input) {
+    if (finalized) return
+    if (input != null) await appendRecords(await recordsFromInput(input), { final: true })
+    finalized = true
+    if (!chunk && !sendEmptyReply && !published) return
+    await publish(true)
+  }
+
+  return {
+    update,
+    finalize
+  }
+}
+
+export function createMissingMessageReplyPacker ({
+  messenger,
+  channelPubkey,
+  question,
+  receiverPubkey = question?.pubkey,
+  since,
+  until,
+  eventsPerChunk = DEFAULT_EVENTS_PER_CHUNK
+}) {
+  if (!messenger?.reply) throw new Error('MESSENGER_REQUIRED')
+  if (!question?.id) throw new Error('QUESTION_REQUIRED')
+  if (!receiverPubkey) throw new Error('RECEIVER_PUBKEY_REQUIRED')
+  if (!Number.isSafeInteger(eventsPerChunk) || eventsPerChunk < 1) throw new Error('INVALID_EVENTS_PER_CHUNK')
+
+  const range = backfillRequestRange(question, since, until)
+  return createEventReplyPacker({
+    messenger,
+    channelPubkey,
+    question,
+    receiverPubkey,
+    code: MISSING_MESSAGES_REPLY_CODE,
+    payload: { since: range.since, until: range.until },
+    eventsPerChunk,
+    recordsFromInput: seed => compactRecordsFromSeed(seed, { receiverPubkey, since: range.since, until: range.until })
+  })
+}

package/relay/constants/index.js

@@ -0,0 +1,18 @@
+// Used only to discover users' NIP-65 relay lists (kind:10002).
+export const seedRelays = [
+  'wss://relay.44billion.net',
+  'wss://purplepag.es',
+  'wss://user.kindpag.es',
+  'wss://relay.nos.social',
+  'wss://nostr.land',
+  'wss://indexer.coracle.social'
+]
+
+// Fallback write-accepting relays. Used as the initial write/read-relay set for
+// new accounts and as a fallback when we cannot resolve a user's own relays.
+export const freeRelays = [
+  'wss://relay.44billion.net',
+  'wss://nos.lol',
+  'wss://relay.primal.net',
+  'wss://relay.damus.io'
+]

package/relay/helpers/hll.js

@@ -0,0 +1,62 @@
+const REGISTER_COUNT = 256
+const HLL_HEX_LENGTH = REGISTER_COUNT * 2
+
+function assertRegisters (registers) {
+  if (!(registers instanceof Uint8Array) || registers.length !== REGISTER_COUNT) {
+    throw new Error('INVALID_HLL_REGISTERS')
+  }
+}
+
+// NIP-45 serializes one uint8 register for each of the 256 HLL buckets.
+export function decodeHll (value) {
+  if (typeof value !== 'string' || value.length !== HLL_HEX_LENGTH || !/^[0-9a-fA-F]+$/.test(value)) {
+    return null
+  }
+
+  const registers = new Uint8Array(REGISTER_COUNT)
+  for (let index = 0; index < REGISTER_COUNT; index++) {
+    registers[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16)
+  }
+  return registers
+}
+
+export function encodeHll (registers) {
+  assertRegisters(registers)
+
+  let value = ''
+  for (const register of registers) value += register.toString(16).padStart(2, '0')
+  return value
+}
+
+// Combining independent relay sketches keeps the largest observation per bucket.
+export function mergeHll (target, source) {
+  assertRegisters(target)
+  assertRegisters(source)
+
+  for (let index = 0; index < REGISTER_COUNT; index++) {
+    if (source[index] > target[index]) target[index] = source[index]
+  }
+  return target
+}
+
+// Small sketches use linear counting; larger ones use the standard HLL estimate.
+export function estimateHllCount (registers) {
+  assertRegisters(registers)
+
+  let zeroes = 0
+  let sum = 0
+  for (const register of registers) {
+    if (register === 0) zeroes++
+    sum += 1 / 2 ** register
+  }
+
+  if (zeroes > 0) {
+    const linearCount = REGISTER_COUNT * Math.log(REGISTER_COUNT / zeroes)
+    if (linearCount <= 220) return Math.floor(linearCount)
+    if (sum > 0 && (0.7182725932495458 * REGISTER_COUNT * REGISTER_COUNT) / sum <= REGISTER_COUNT * 3) {
+      return Math.floor(linearCount)
+    }
+  }
+
+  return Math.floor((0.7182725932495458 * REGISTER_COUNT * REGISTER_COUNT) / sum)
+}

package/relay/helpers/publish.js

@@ -0,0 +1,100 @@
+import { maybeUnref } from './timer.js'
+
+function publishTimeoutError () {
+  return new Error('PUBLISH_TIMEOUT')
+}
+
+// Resolves once any relay accepts the event, all relays reject, an optional
+// early deadline expires, or the full report has already finished.
+export function firstFulfillment (promises, timeout, { fallback } = {}) {
+  return new Promise((resolve) => {
+    let settled = false
+    let rejected = 0
+    let timer = null
+    const finish = (success) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(success)
+    }
+    if (timeout !== null) timer = maybeUnref(setTimeout(() => finish(false), timeout))
+    for (const promise of promises) {
+      Promise.resolve(promise).then(
+        () => finish(true),
+        () => {
+          rejected++
+          if (rejected === promises.length) finish(false)
+        }
+      )
+    }
+    if (fallback) Promise.resolve(fallback).then(finish, () => finish(false))
+  })
+}
+
+// Gives every relay one terminal result under a single operation-wide deadline.
+// timeout() also lets the early-return path close every pending report at once.
+export function createPublishSettlements (promises, timeout, { onSettled } = {}) {
+  const settlements = new Array(promises.length)
+  let remaining = promises.length
+  let timer = null
+  let isFinished = false
+  let resolve
+
+  const promise = new Promise(nextResolve => { resolve = nextResolve })
+  const finish = () => {
+    if (isFinished) return
+    isFinished = true
+    clearTimeout(timer)
+    resolve(settlements)
+  }
+
+  const settle = (index, settlement) => {
+    if (settlements[index]) return
+    settlements[index] = settlement
+    onSettled?.(settlement, index)
+    remaining--
+    if (remaining === 0) finish()
+  }
+
+  const timeoutPending = () => {
+    if (isFinished) return
+    for (let index = 0; index < settlements.length; index++) {
+      settle(index, { status: 'rejected', outcome: 'timed-out', reason: publishTimeoutError() })
+    }
+  }
+
+  if (remaining === 0) finish()
+  else {
+    if (timeout !== null) timer = maybeUnref(setTimeout(timeoutPending, timeout))
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise).then(
+        value => settle(index, { status: 'fulfilled', value }),
+        reason => settle(index, { status: 'rejected', outcome: 'failed', reason })
+      )
+    })
+  }
+
+  return { promise, timeout: timeoutPending }
+}
+
+// Turns ordered relay settlements into a stable, caller-facing report. Failed
+// relays retain their Error while optional successful URLs make acknowledgements visible.
+export function publishSummary (settlements, relays, { result, includeSucceededRelays = false } = {}) {
+  const succeededRelays = []
+  const errors = []
+
+  settlements.forEach((settlement, index) => {
+    if (settlement.status === 'fulfilled') succeededRelays.push(relays[index])
+    else errors.push({ relay: relays[index], reason: settlement.reason })
+  })
+
+  const summary = {
+    success: succeededRelays.length > 0,
+    total: relays.length,
+    fulfilled: succeededRelays.length,
+    errors
+  }
+  if (result !== undefined) summary.result = result
+  if (includeSucceededRelays) summary.succeededRelays = succeededRelays
+  return summary
+}

package/relay/helpers/routing.js

@@ -0,0 +1,36 @@
+import { freeRelays } from '../constants/index.js'
+
+const DEFAULT_RELAYS_PER_PUBKEY = 2
+
+// Given pubkeys and their relay mappings, picks the minimum set of relays
+// that covers all pubkeys (up to maxPerPubkey relays each), preferring
+// relays shared by more pubkeys. Returns Map<relayUrl, pubkey[]>.
+export function pickRelaysForPubkeys (pubkeys, relaysByPubkey, { maxPerPubkey = DEFAULT_RELAYS_PER_PUBKEY, relayType = 'write' } = {}) {
+  const type = relayType === 'read' ? 'read' : 'write'
+  const pkToPossibleRelays = new Map()
+  for (const pk of pubkeys) {
+    const relays = relaysByPubkey[pk]?.[type] || []
+    pkToPossibleRelays.set(pk, new Set(relays.length ? relays : freeRelays.slice(0, DEFAULT_RELAYS_PER_PUBKEY)))
+  }
+
+  const relayCounts = new Map()
+  for (const relays of pkToPossibleRelays.values()) {
+    for (const relay of relays) relayCounts.set(relay, (relayCounts.get(relay) || 0) + 1)
+  }
+  const rankedRelays = [...relayCounts.keys()].sort((a, b) => relayCounts.get(b) - relayCounts.get(a))
+
+  const relayToAuthors = new Map()
+  for (const pk of pubkeys) {
+    const possibleRelays = pkToPossibleRelays.get(pk)
+    let assigned = 0
+    for (const relay of rankedRelays) {
+      if (assigned >= maxPerPubkey) break
+      if (!possibleRelays.has(relay)) continue
+      if (!relayToAuthors.has(relay)) relayToAuthors.set(relay, [])
+      relayToAuthors.get(relay).push(pk)
+      assigned++
+    }
+  }
+
+  return relayToAuthors
+}

package/relay/helpers/timer.js

@@ -0,0 +1,4 @@
+export function maybeUnref (timer) {
+  timer?.unref?.()
+  return timer
+}

package/relay/index.js

@@ -0,0 +1,4 @@
+export { freeRelays, seedRelays } from './constants/index.js'
+export { pickRelaysForPubkeys } from './helpers/routing.js'
+export { RelayPool, relayPool } from './services/relay-pool.js'
+export { getRelaysByPubkey, subscribeRelayListUpdates } from './services/query.js'