settings.ts

import { Pubkey, Secret } from './base'
import { EventKinds } from '../constants/base'
import { MessageType } from './messages'
import { SubscriptionFilter } from './subscription'

export interface Info {
  relay_url: string
  name: string
  description: string
  pubkey: string
  banner?: string
  icon?: string
  self?: string
  contact: string
  terms_of_service?: string
}

export interface Network {
  maxPayloadSize?: number
  remoteIpHeader?: string
  trustedProxies?: string[]
}

export interface RateLimit {
  description?: string
  period: number
  rate: number
}

export interface RateLimiterSettings {
  strategy: 'ewma' | 'sliding_window'
}

export interface EventIdLimits {
  minLeadingZeroBits?: number
}

export interface PubkeyLimits {
  minBalance: bigint
  minLeadingZeroBits: number
  whitelist?: Pubkey[]
  blacklist?: Pubkey[]
}

export type EventKindsRange = [EventKinds, EventKinds]

export interface EventRateLimit extends RateLimit {
  kinds?: (EventKinds | [EventKinds, EventKinds])[]
}

export interface KindLimits {
  whitelist?: (EventKinds | EventKindsRange)[]
  blacklist?: (EventKinds | EventKindsRange)[]
}

export interface CreatedAtLimits {
  /**
   * Maximum number of seconds allowed before the current unix timestamp
   */
  maxNegativeDelta?: number
  /**
   * Maximum number of seconds allowed after the current unix timestamp
   */
  maxPositiveDelta?: number
}

export interface ContentLimits {
  description?: string
  kinds?: (EventKinds | EventKindsRange)[]
  /**
   * Maximum number of characters allowed on events
   */
  maxLength?: number
}

export interface EventWhitelists {
  pubkeys?: Pubkey[]
  ipAddresses?: string[]
}

export interface EventRetentionKindLimits {
  whitelist?: (EventKinds | EventKindsRange)[]
}

export interface EventRetentionPubkeyLimits {
  whitelist?: Pubkey[]
}

export interface EventRetentionLimits {
  maxDays?: number
  kind?: EventRetentionKindLimits
  pubkey?: EventRetentionPubkeyLimits
}

export interface EventLimits {
  eventId?: EventIdLimits
  pubkey?: PubkeyLimits
  kind?: KindLimits
  createdAt?: CreatedAtLimits
  content?: ContentLimits | ContentLimits[]
  rateLimits?: EventRateLimit[]
  whitelists?: EventWhitelists
  retention?: EventRetentionLimits
}

export interface ClientSubscriptionLimits {
  maxSubscriptions?: number
  maxFilters?: number
  maxFilterValues?: number
  maxLimit?: number
  minPrefixLength?: number
  maxSubscriptionIdLength?: number
}

export interface ClientLimits {
  subscription?: ClientSubscriptionLimits
}

export interface MessageRateLimit extends RateLimit {
  type?: MessageType
}

export interface MessageLimits {
  rateLimits?: MessageRateLimit[]
  ipWhitelist?: string[]
}

export interface ConnectionLimits {
  rateLimits: RateLimit[]
  ipWhitelist?: string[]
  ipBlacklist?: string[]
}

export interface InvoiceLimits {
  rateLimits: RateLimit[]
  ipWhitelist?: string[]
}

export interface AdmissionCheckLimits {
  rateLimits: RateLimit[]
  ipWhitelist?: string[]
}

export interface AdminLimits {
  rateLimits?: RateLimit[]
  loginRateLimits?: RateLimit[]
  ipWhitelist?: string[]
}

export interface Limits {
  rateLimiter?: RateLimiterSettings
  invoice?: InvoiceLimits
  admissionCheck?: AdmissionCheckLimits
  admin?: AdminLimits
  connection?: ConnectionLimits
  client?: ClientLimits
  event?: EventLimits
  message?: MessageLimits
}

export interface Worker {
  count: number
}

export interface FeeScheduleWhitelists {
  pubkeys?: Pubkey[]
  event_kinds?: (EventKinds | [EventKinds, EventKinds])[]
}

export interface FeeSchedule {
  enabled: boolean
  description?: string
  amount: bigint
  whitelists?: FeeScheduleWhitelists
}

export interface FeeSchedules {
  admission: FeeSchedule[]
  publication: FeeSchedule[]
}

export interface Payments {
  enabled: boolean
  processor: keyof PaymentsProcessors
  feeSchedules: FeeSchedules
}

export interface LnurlPaymentsProcessor {
  invoiceURL: string
}

export interface ZebedeePaymentsProcessor {
  baseURL: string
  callbackBaseURL: string
  ipWhitelist: string[]
}

export interface NodelessPaymentsProcessor {
  baseURL: string
  storeId: string
}

export interface LNbitsPaymentsProcessor {
  baseURL: string
  callbackBaseURL: string
}

export interface OpenNodePaymentsProcessor {
  baseURL: string
  callbackBaseURL: string
}

export interface NwcPaymentsProcessor {
  invoiceExpirySeconds: number
  replyTimeoutMs: number
}

export interface PaymentsProcessors {
  lnurl?: LnurlPaymentsProcessor
  zebedee?: ZebedeePaymentsProcessor
  lnbits?: LNbitsPaymentsProcessor
  nodeless?: NodelessPaymentsProcessor
  opennode?: OpenNodePaymentsProcessor
  nwc?: NwcPaymentsProcessor
}

export interface Local {
  secret: Secret
}

export interface Remote {
  secret: Secret
}

export interface Mirror {
  address: string
  filters?: SubscriptionFilter[]
  secret?: Secret
  limits?: {
    event?: EventLimits
  }
  skipAdmissionCheck?: boolean
}

export interface Mirroring {
  static?: Mirror[]
}

export type Nip05Mode = 'enabled' | 'passive' | 'disabled'

export interface Nip45Settings {
  enabled?: boolean
}

export interface Nip05Settings {
  mode: Nip05Mode
  /**
   * Maximum age (in ms) of a successful verification before an author is blocked.
   * Defaults to 604800000 (7 days) when unset.
   */
  verifyExpiration?: number
  /**
   * Minimum interval (in ms) between background re-verifications per author.
   * Defaults to 86400000 (24 hours) when unset.
   */
  verifyUpdateFrequency?: number
  /**
   * Number of consecutive verification failures after which an author is no longer
   * re-checked. Defaults to 20 when unset.
   */
  maxConsecutiveFailures?: number
  domainWhitelist?: string[]
  domainBlacklist?: string[]
}

export interface AdminSettings {
  enabled: boolean
  passwordHash?: string
  sessionTtlSeconds?: number
}
export interface WoTSettings {
  enabled: boolean
  /**
   * The relay owner's pubkey (hex). The trust graph is rooted here.
   * Required when enabled is true.
   */
  seedPubkey: Pubkey
  /**
   * Minimum number of 1-hop follows a pubkey must have to enter the trust filter.
   * Defaults to 1.
   */
  minimumFollowers: number
  /**
   * How many hours between full trust graph rebuilds.
   * Defaults to 24.
   */
  refreshIntervalHours: number
}

export interface Settings {
  info: Info
  admin?: AdminSettings
  payments?: Payments
  paymentsProcessors?: PaymentsProcessors
  network: Network
  workers?: Worker
  limits?: Limits
  mirroring?: Mirroring
  nip05?: Nip05Settings
  nip45?: Nip45Settings
  wot?: WoTSettings
}