Class RelayGroup

constructor

• new RelayGroup(relays: GroupRelayInput): RelayGroup

  Parameters

  • relays: GroupRelayInput

  Returns RelayGroup

status$

relays

• get relays(): Relay[]

  Returns Relay[]

add

• add(relay: Relay): void

  Add a relay to the group

  Parameters

  • relay: Relay

  Returns void

count

• count(
      filters: Filter | Filter[],
      id?: string,
      opts?: RelayCountOptions,
  ): Observable<RelayCountOutcomes>

  Count events on all relays in the group

  Parameters

  • filters: Filter | Filter[]
  • id: string = ...
  • Optionalopts: RelayCountOptions

  Returns Observable<RelayCountOutcomes>

event

• event(event: NostrEvent): Observable<PublishResponse>

  Send an event to all relays

  Parameters

  • event: NostrEvent

  Returns Observable<PublishResponse>

has

• has(relay: string | Relay): boolean

  Check if a relay is in the group

  Parameters

  • relay: string | Relay

  Returns boolean

publish

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

  Publish an event to all relays with retries ( default 3 retries )

  Parameters

  • event: NostrEvent
  • Optionalopts: PublishOptions

  Returns Promise<PublishResponse[]>

remove

• remove(relay: Relay): void

  Remove a relay from the group

  Parameters

  • relay: Relay

  Returns void

req

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

  Send a REQ to all relays and returns all responses

  Parameters

  • filters: FilterInput
  • Optionalopts: RelayReqOptions

  Returns Observable<GroupReqMessage>

request

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

  Request events from all relays and complete based on condition

  Parameters

  • filters: FilterInput
  • Optionalopts: GroupRequestOptions

  Returns Observable<NostrEvent>

subscription

• subscription(
      filters: FilterInput,
      opts?: GroupSubscriptionOptions,
  ): Observable<NostrEvent>

  Open a subscription to all relays with retries ( default 3 retries )

  Parameters

  • filters: FilterInput
  • Optionalopts: GroupSubscriptionOptions

  Returns Observable<NostrEvent>

sync

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

  Negentropy sync events with the relays and an event store

  Parameters

  • store: NostrEvent[] | NegentropySyncStore
  • filter: Filter
  • Optionaldirection: SyncDirection
  • Optionalopts: RelaySyncOptions

  Returns Observable<GroupSyncMessage>

StaticcompleteAfterFirstRelay

• completeAfterFirstRelay(timeout?: number): GroupRequestCompleteOperator

  Creates a complete condition that waits for the first EOSE message from a relay and then starts a timeout for the remaining relays

  Parameters

  • timeout: number = 5_000

    The timeout in milliseconds for the remaining relays

  Returns GroupRequestCompleteOperator

StaticcompleteAfterIdle

• completeAfterIdle(opts?: CompleteAfterIdleOptions): GroupRequestCompleteOperator

  Creates a complete condition that waits after the first EOSE while relays are still sending events

  Parameters

  • Optionalopts: CompleteAfterIdleOptions

    Options for RelayGroup.completeAfterIdle()

    • Optionalcap?: number

      Maximum time after the first EOSE before completing (default 15 seconds)

    • Optionalgrace?: number

      Minimum time after the first EOSE to wait for relays that have not responded (default 3 seconds)

    • Optionalidle?: number

      Time without any events before completing once the grace period has passed (default 1.5 seconds)

    • Optionalprogress?: number

      Maximum time without new event ids while duplicates arrive, bounded below by idle (default 5 seconds)

  Returns GroupRequestCompleteOperator

StaticcompleteOnAll

• completeOnAll(
      ...conditions: GroupRequestCompleteOperator[],
  ): GroupRequestCompleteOperator

  A group request complete condition that completes when any of the provided conditions are truthy (AND)

  Parameters

  • ...conditions: GroupRequestCompleteOperator[]

  Returns GroupRequestCompleteOperator

StaticcompleteOnAllEose

• completeOnAllEose(): GroupRequestCompleteOperator

  Creates a group request complete operator that waits for all relays to send an EOSE message or timeout

  Returns GroupRequestCompleteOperator

StaticcompleteOnAny

• completeOnAny(
      ...conditions: GroupRequestCompleteOperator[],
  ): GroupRequestCompleteOperator

  A group request complete condition that completes when any of the provided conditions are truthy (OR)

  Parameters

  • ...conditions: GroupRequestCompleteOperator[]

  Returns GroupRequestCompleteOperator