Class RelayPool

constructor

• new RelayPool(options?: RelayOptions): RelayPool

  Parameters

  • Optionaloptions: RelayOptions

  Returns RelayPool

add$

ignoreOffline

Optionaloptions

relays$

remove$

status$

relays

• get relays(): Map<string, Relay>

  Returns Map<string, Relay>

close

• close(): void

  Closes and removes every relay in the pool, tearing down all of their connections and timers

  Returns void

count

• count(
      relays: PoolRelayInput,
      filters: Filter | Filter[],
      id?: string,
  ): Observable<Record<string, RelayCountResponse>>

  Count events on multiple relays

  Parameters

  • relays: PoolRelayInput
  • filters: Filter | Filter[]
  • Optionalid: string

  Returns Observable<Record<string, RelayCountResponse>>

event

• event(relays: PoolRelayInput, event: NostrEvent): Observable<PublishResponse>

  Send an EVENT message to multiple relays

  Parameters

  • relays: PoolRelayInput
  • event: NostrEvent

  Returns Observable<PublishResponse>

group

• group(relays: PoolRelayInput, ignoreOffline?: boolean): RelayGroup

  Create a group of relays

  Parameters

  • relays: PoolRelayInput
  • ignoreOffline: boolean = ...

  Returns RelayGroup

negentropy

• negentropy(
      relays: PoolRelayInput,
      store: NegentropyReadStore,
      filter: Filter,
      reconcile: ReconcileFunction,
      opts?: NegentropySyncOptions,
  ): Promise<boolean>

  Negentropy sync event ids with the relays and an event store

  Parameters

  • relays: PoolRelayInput
  • store: NegentropyReadStore
  • filter: Filter
  • reconcile: ReconcileFunction
  • Optionalopts: NegentropySyncOptions

  Returns Promise<boolean>

outboxSubscription

• outboxSubscription(
      outboxes: OutboxMap | Observable<OutboxMap>,
      filter: Omit<Filter, "authors">,
      options?: GroupSubscriptionOptions,
  ): Observable<NostrEvent>

  Open a subscription for an OutboxMap and filter

  Parameters

  • outboxes: OutboxMap | Observable<OutboxMap>
  • filter: Omit<Filter, "authors">
  • Optionaloptions: GroupSubscriptionOptions

  Returns Observable<NostrEvent>

publish

• publish(
      relays: PoolRelayInput,
      event: NostrEvent,
      opts?: PublishOptions,
  ): Promise<PublishResponse[]>

  Publish an event to multiple relays

  Parameters

  • relays: PoolRelayInput
  • event: NostrEvent
  • Optionalopts: PublishOptions

  Returns Promise<PublishResponse[]>

relay

• relay(url: string): Relay

  Get or create a new relay connection

  Parameters

  • url: string

  Returns Relay

remove

• remove(relay: string | Relay, close?: boolean): void

  Removes a relay from the pool and defaults to closing the connection

  Parameters

  • relay: string | Relay
  • close: boolean = true

  Returns void

req

• req(
      relays: PoolRelayInput,
      filters: FilterInput,
      opts?: RelayReqOptions,
  ): Observable<GroupReqMessage>

  Make a REQ to multiple relays that does not deduplicate events

  Parameters

  • relays: PoolRelayInput
  • filters: FilterInput
  • Optionalopts: RelayReqOptions

  Returns Observable<GroupReqMessage>

request

• request(
      relays: PoolRelayInput,
      filters: FilterInput,
      opts?: GroupRequestOptions,
  ): Observable<NostrEvent>

  Request events from multiple relays

  Parameters

  • relays: PoolRelayInput
  • filters: FilterInput
  • Optionalopts: GroupRequestOptions

  Returns Observable<NostrEvent>

subscription

• subscription(
      relays: PoolRelayInput,
      filters: FilterInput,
      options?: GroupSubscriptionOptions,
  ): Observable<NostrEvent>

  Open a subscription to multiple relays

  Parameters

  • relays: PoolRelayInput
  • filters: FilterInput
  • Optionaloptions: GroupSubscriptionOptions

  Returns Observable<NostrEvent>

subscriptionMap

• subscriptionMap(
      relays: FilterMap | Observable<FilterMap>,
      options?: GroupSubscriptionOptions,
  ): Observable<NostrEvent>

  Open a subscription for a map of relays and filters

  Parameters

  • relays: FilterMap | Observable<FilterMap>
  • Optionaloptions: GroupSubscriptionOptions

  Returns Observable<NostrEvent>

sync

• sync(
      relays: PoolRelayInput,
      store: NostrEvent[] | NegentropySyncStore,
      filter: Filter,
      direction?: SyncDirection,
  ): Observable<NostrEvent>

  Negentropy sync events with the relays and an event store

  Parameters

  • relays: PoolRelayInput
  • store: NostrEvent[] | NegentropySyncStore
  • filter: Filter
  • Optionaldirection: SyncDirection

  Returns Observable<NostrEvent>