Class RelayPool

constructor

• new RelayPool(options?: RelayOptions): RelayPool

  Parameters

  • Optionaloptions: RelayOptions

  Returns RelayPool

add$

blacklist

groups$

Optionaloptions

relays$

remove$

groups

• get groups(): Map<string, RelayGroup>

  Returns Map<string, RelayGroup>

relays

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

  Returns Map<string, Relay>

event

• event(relays: string[], event: Event): Observable<PublishResponse>

  Send an EVENT message to multiple relays

  Parameters

  • relays: string[]
  • event: Event

  Returns Observable<PublishResponse>

group

• group(relays: string[]): RelayGroup

  Create a group of relays

  Parameters

  • relays: string[]

  Returns RelayGroup

negentropy

• negentropy(
      relays: string[],
      store: IEventStoreRead | IAsyncEventStoreRead | Event[],
      filter: Filter,
      reconcile: ReconcileFunction,
      opts?: NegentropySyncOptions,
  ): Promise<boolean>

  Negentropy sync event ids with the relays and an event store

  Parameters

  • relays: string[]
  • store: IEventStoreRead | IAsyncEventStoreRead | Event[]
  • filter: Filter
  • reconcile: ReconcileFunction
  • Optionalopts: NegentropySyncOptions

  Returns Promise<boolean>

publish

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

  Publish an event to multiple relays

  Parameters

  • relays: string[]
  • event: Event
  • 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 | IRelay, close?: boolean): void

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

  Parameters

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

  Returns void

req

• req(
      relays: string[],
      filters: FilterInput,
      id?: string,
  ): Observable<SubscriptionResponse>

  Make a REQ to multiple relays that does not deduplicate events

  Parameters

  • relays: string[]
  • filters: FilterInput
  • Optionalid: string

  Returns Observable<SubscriptionResponse>

request

• request(
      relays: string[],
      filters: FilterInput,
      opts?: GroupRequestOptions,
  ): Observable<Event>

  Request events from multiple relays

  Parameters

  • relays: string[]
  • filters: FilterInput
  • Optionalopts: GroupRequestOptions

  Returns Observable<Event>

subscription

• subscription(
      relays: string[],
      filters: FilterInput,
      options?: GroupSubscriptionOptions,
  ): Observable<SubscriptionResponse>

  Open a subscription to multiple relays

  Parameters

  • relays: string[]
  • filters: FilterInput
  • Optionaloptions: GroupSubscriptionOptions

  Returns Observable<SubscriptionResponse>

sync

• sync(
      relays: string[],
      store: IEventStoreRead | IAsyncEventStoreRead | Event[],
      filter: Filter,
      direction?: SyncDirection,
  ): Observable<Event>

  Negentropy sync events with the relays and an event store

  Parameters

  • relays: string[]
  • store: IEventStoreRead | IAsyncEventStoreRead | Event[]
  • filter: Filter
  • Optionaldirection: SyncDirection

  Returns Observable<Event>