Class RelayGroup

constructor

• new RelayGroup(relays: IGroupRelayInput): RelayGroup

  Parameters

  • relays: IGroupRelayInput

  Returns RelayGroup

status$

relays

• get relays(): IRelay[]

  Returns IRelay[]

add

• add(relay: IRelay): void

  Add a relay to the group

  Parameters

  • relay: IRelay

  Returns void

count

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

  Count events on all relays in the group

  Parameters

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

  Returns Observable<Record<string, CountResponse>>

event

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

  Send an event to all relays

  Parameters

  • event: NostrEvent

  Returns Observable<PublishResponse>

has

• has(relay: string | IRelay): boolean

  Check if a relay is in the group

  Parameters

  • relay: string | IRelay

  Returns boolean

negentropy

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

  Negentropy sync events with the relays and an event store

  Parameters

  • store: NegentropyReadStore
  • filter: Filter
  • reconcile: ReconcileFunction
  • Optionalopts: GroupNegentropySyncOptions

  Returns Promise<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: IRelay): void

  Remove a relay from the group

  Parameters

  • relay: IRelay

  Returns void

req

• req(
      filters: FilterInput,
      id?: string,
      opts?: { eventStore?: IAsyncEventStoreActions | IEventStoreActions | null },
  ): Observable<SubscriptionResponse>

  Make a request to all relays

  Parameters

  • filters: FilterInput
  • id: string = ...
  • Optionalopts: { eventStore?: IAsyncEventStoreActions | IEventStoreActions | null }

    • OptionaleventStore?: IAsyncEventStoreActions | IEventStoreActions | null

      Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication

  Returns Observable<SubscriptionResponse>

  Note

  This does not deduplicate events

request

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

  Request events from all relays and complete on EOSE

  Parameters

  • filters: FilterInput
  • Optionalopts: GroupRequestOptions

  Returns Observable<NostrEvent>

subscription

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

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

  Parameters

  • filters: FilterInput
  • Optionalopts: GroupSubscriptionOptions

  Returns Observable<SubscriptionResponse>

sync

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

  Negentropy sync events with the relays and an event store

  Parameters

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

  Returns Observable<NostrEvent>