Class RelayPool

constructor

• new RelayPool(options?: RelayOptions): RelayPool

  Parameters

  • Optionaloptions: RelayOptions

  Returns RelayPool

add$

Optionaloptions

relays$

remove$

relays

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

  Returns Map<string, Relay>

count

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

  Count events on multiple relays

  Parameters

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

  Returns Observable<Record<string, CountResponse>>

event

• event(relays: IPoolRelayInput, event: Event): Observable<PublishResponse>

  Send an EVENT message to multiple relays

  Parameters

  • relays: IPoolRelayInput
  • event: Event

  Returns Observable<PublishResponse>

group

• group(relays: IPoolRelayInput): RelayGroup

  Create a group of relays

  Parameters

  • relays: IPoolRelayInput

  Returns RelayGroup

negentropy

• negentropy(
      relays: IPoolRelayInput,
      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: IPoolRelayInput
  • store: IEventStoreRead | IAsyncEventStoreRead | Event[]
  • filter: Filter
  • reconcile: ReconcileFunction
  • Optionalopts: NegentropySyncOptions

  Returns Promise<boolean>

outboxSubscription

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

  Open a subscription for an OutboxMap and filter

  Parameters

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

  Returns Observable<SubscriptionResponse>

publish

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

  Publish an event to multiple relays

  Parameters

  • relays: IPoolRelayInput
  • 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: IPoolRelayInput,
      filters: FilterInput,
      id?: string,
  ): Observable<SubscriptionResponse>

  Make a REQ to multiple relays that does not deduplicate events

  Parameters

  • relays: IPoolRelayInput
  • filters: FilterInput
  • Optionalid: string

  Returns Observable<SubscriptionResponse>

request

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

  Request events from multiple relays

  Parameters

  • relays: IPoolRelayInput
  • filters: FilterInput
  • Optionalopts: GroupRequestOptions

  Returns Observable<Event>

subscription

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

  Open a subscription to multiple relays

  Parameters

  • relays: IPoolRelayInput
  • filters: FilterInput
  • Optionaloptions: GroupSubscriptionOptions

  Returns Observable<SubscriptionResponse>

subscriptionMap

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

  Open a subscription for a map of relays and filters

  Parameters

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

  Returns Observable<SubscriptionResponse>

sync

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

  Negentropy sync events with the relays and an event store

  Parameters

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

  Returns Observable<Event>