Class PrimalCache

Extended relay interface for primal caching server

See

https://github.com/PrimalHQ/primal-server/blob/main/src/app_ext.jl

Hierarchy

Relay
- PrimalCache

Index

Constructors

constructor

new PrimalCache(url?: string, opts?: RelayOptions): PrimalCache
Parameters
- url: string = DEFAULT_PRIMAL_RELAY
- Optionalopts: RelayOptions
Returns PrimalCache
Overrides Relay.constructor
- Defined in extra/src/primal.ts:249

Properties

`Protected`_nip11

_nip11: RelayInformation | null

attempts$

attempts$: BehaviorSubject<number>

How many times the relay has tried to reconnect

authenticated$

authenticated$: Observable<boolean>

Boolean authentication state (will be false if auth failed)

authenticationResponse$

authenticationResponse$: BehaviorSubject<PublishResponse | null>

The response to the last AUTH message sent to the relay

authRequiredForPublish$

authRequiredForPublish$: Observable<boolean>

authRequiredForRead$

authRequiredForRead$: Observable<boolean>

challenge$

challenge$: BehaviorSubject<string | null>

The authentication challenge string from the relay

close$

close$: Subject<CloseEvent>

An observable that emits when underlying websocket is closed

closing$

closing$: Subject<void>

An observable that emits when underlying websocket is closing due to unsubscription

connected$

connected$: BehaviorSubject<boolean>

Whether the relay is connected

eoseTimeout

eoseTimeout: number

If an EOSE message is not seen in this time, emit one locally (default 10s)

error$

error$: BehaviorSubject<Error | null>

The last connection error

eventTimeout

eventTimeout: number

How long to wait for an OK message from the relay (default 10s)

information$

information$: Observable<RelayInformation | null>

An observable that emits the NIP-11 information document for the relay

keepAlive

keepAlive: number

How long to keep the connection alive after nothing is subscribed (default 30s)

limitations$

limitations$: Observable<Partial<Limitations> | null | undefined>

An observable that emits the limitations for the relay

`Protected`log

log: Debugger

message$

message$: Observable<any>

A passive observable of all messages from the relay

Note

Subscribing to this will not connect to the relay

notice$

notice$: Observable<string>

A passive observable of NOTICE messages from the relay

Note

Subscribing to this will not connect to the relay

notices$

notices$: BehaviorSubject<string[]>

The notices from the relay

open$

open$: Subject<Event>

An observable that emits when underlying websocket is opened

publishTimeout

publishTimeout: number

How long to wait for a publish to complete (default 30s)

`Protected`ready$

ready$: BehaviorSubject<boolean>

Whether the relay is ready for subscriptions or event publishing. setting this to false will cause all .req and .event observables to hang until the relay is ready

`Protected`receivedAuthRequiredForEvent

receivedAuthRequiredForEvent: BehaviorSubject<boolean>

`Protected`receivedAuthRequiredForReq

receivedAuthRequiredForReq: BehaviorSubject<boolean>

reconnectTimer

reconnectTimer: (
error: Error | CloseEvent,
attempts: number,
) => Observable<number>

A method that returns an Observable that emits when the relay should reconnect

`Protected`socket

socket: WebSocketSubject<any>

supported$

supported$: Observable<number[] | null>

An array of supported NIPs from the NIP-11 information document

url

url: string

`Protected`watchTower

watchTower: Observable<never>

An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay

Accessors

authenticated

get authenticated(): boolean
Returns boolean
Inherited from Relay.authenticated
- Defined in relay/dist/relay.d.ts:77

authenticationResponse

get authenticationResponse(): PublishResponse | null
Returns PublishResponse | null
Inherited from Relay.authenticationResponse
- Defined in relay/dist/relay.d.ts:78

challenge

get challenge(): string | null
Returns string | null
Inherited from Relay.challenge
- Defined in relay/dist/relay.d.ts:75

connected

get connected(): boolean
Returns boolean
Inherited from Relay.connected
- Defined in relay/dist/relay.d.ts:74

information

get information(): RelayInformation | null
Returns RelayInformation | null
Inherited from Relay.information
- Defined in relay/dist/relay.d.ts:79

notices

get notices(): string[]
Returns string[]
Inherited from Relay.notices
- Defined in relay/dist/relay.d.ts:76

Methods

advancedFeed

advancedFeed(
    params: {
        feed_type: string;
        limit?: number;
        offset?: number;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Advanced feed
Parameters
- params: {
      feed_type: string;
      limit?: number;
      offset?: number;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:375

advancedSearch

advancedSearch(
    params: {
        limit?: number;
        offset?: number;
        query: string;
        since?: number;
        sort?: "popular" | "trending" | "latest";
        until?: number;
    },
): Promise<Event[]>
Advanced search
Parameters
- params: {
      limit?: number;
      offset?: number;
      query: string;
      since?: number;
      sort?: "popular" | "trending" | "latest";
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:368

auth

auth(event: Event): Promise<PublishResponse>
send and AUTH message
Parameters
- event: Event
Returns Promise<PublishResponse>
Inherited from Relay.auth
- Defined in relay/dist/relay.d.ts:112

authenticate

authenticate(signer: AuthSigner): Promise<PublishResponse>
Authenticate with the relay using a signer
Parameters
- signer: AuthSigner
Returns Promise<PublishResponse>
Inherited from Relay.authenticate
- Defined in relay/dist/relay.d.ts:116

broadcastEvents

broadcastEvents(events: Event[], relays: string[]): Promise<Event[]>
Broadcast events
Parameters
- events: Event[]
- relays: string[]
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:477

broadcastReply

broadcastReply(event: Event): Promise<Event[]>
Broadcast reply
Parameters
- event: Event
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:472

cacheRequest

cacheRequest<R extends CacheRequest>(
    request:
        | ["explore_legend_counts", { pubkey: string }]
        | [
            "explore",
            {
                apply_humaness_check?: boolean;
                created_after?: number;
                gm_mode?: boolean;
                group_by_pubkey?: boolean;
                include_top_zaps?: boolean;
                limit?: number;
                offset?: number;
                pubkeys?: string[];
                since?: number;
                timeframe: "popular"
                | "trending"
                | "recent";
                until?: number;
                user_pubkey?: string;
            },
        ]
        | ["explore_global_trending_24h", { limit?: number }]
        | ["explore_global_mostzapped_4h", { limit?: number }]
        | [
            "scored",
            {
                apply_humaness_check?: boolean;
                created_after?: number;
                gm_mode?: boolean;
                group_by_pubkey?: boolean;
                include_top_zaps?: boolean;
                limit?: number;
                offset?: number;
                pubkeys?: string[];
                since?: number;
                timeframe: "popular"
                | "trending"
                | "recent";
                until?: number;
                user_pubkey?: string;
            },
        ]
        | ["scored_users", { limit?: number }]
        | ["scored_users_24h", { limit?: number }]
        | ["get_default_relays", {}]
        | ["get_recommended_users", { limit?: number }]
        | ["get_suggested_users", { limit?: number }]
        | [
            "user_profile_scored_content",
            {
                created_after?: number;
                limit?: number;
                offset?: number;
                pubkey: string;
                since?: number;
                until?: number;
            },
        ]
        | [
            "user_profile_scored_media_thumbnails",
            {
                created_after?: number;
                limit?: number;
                offset?: number;
                pubkey: string;
                since?: number;
                until?: number;
            },
        ]
        | [
            "search",
            {
                limit?: number;
                offset?: number;
                query: string;
                since?: number;
                until?: number;
            },
        ]
        | [
            "advanced_search",
            {
                limit?: number;
                offset?: number;
                query: string;
                since?: number;
                sort?: "popular"
                | "trending"
                | "latest";
                until?: number;
            },
        ]
        | [
            "advanced_feed",
            {
                feed_type: string;
                limit?: number;
                offset?: number;
                since?: number;
                until?: number;
            },
        ]
        | ["relays", {}]
        | [
            "get_notifications",
            {
                limit?: number;
                offset?: number;
                pubkey: string;
                since?: number;
                until?: number;
            },
        ]
        | ["set_notifications_seen", { pubkey: string; until: number }]
        | ["get_notifications_seen", { pubkey: string }]
        | ["user_search", { limit?: number; query: string }]
        | [
            "feed_directive",
            {
                feed_type: string;
                limit?: number;
                offset?: number;
                pubkey: string;
                since?: number;
                until?: number;
            },
        ]
        | [
            "feed_directive_2",
            {
                feed_type: string;
                limit?: number;
                offset?: number;
                pubkey: string;
                since?: number;
                until?: number;
            },
        ]
        | ["get_advanced_feeds", {}]
        | ["trending_hashtags", { limit?: number }]
        | ["trending_hashtags_4h", { limit?: number }]
        | ["trending_hashtags_7d", { limit?: number }]
        | ["trending_images", { limit?: number }]
        | ["trending_images_4h", { limit?: number }]
        | ["report_user", { pubkey: string; reason: string }]
        | ["report_note", { event_id: string; reason: string }]
        | ["get_filterlist", {}]
        | ["check_filterlist", { pubkeys: string[] }]
        | ["broadcast_reply", { event: Event }]
        | ["broadcast_events", { events: Event[]; relays: string[] }]
        | ["trusted_users", { extended_response?: boolean; limit?: number }]
        | [
            "note_mentions",
            {
                event_id?: string;
                identifier?: string;
                limit?: number;
                offset?: number;
                pubkey?: string;
                user_pubkey?: string;
            },
        ]
        | ["note_mentions_count", { event_id: string }]
        | ["get_media_metadata", { urls: string[] }],
): Observable<R["event"]>
Make a "cache" request to the caching server
Type Parameters
- R extends CacheRequest
Parameters
- request:
      | ["explore_legend_counts", { pubkey: string }]
      | [
          "explore",
          {
              apply_humaness_check?: boolean;
              created_after?: number;
              gm_mode?: boolean;
              group_by_pubkey?: boolean;
              include_top_zaps?: boolean;
              limit?: number;
              offset?: number;
              pubkeys?: string[];
              since?: number;
              timeframe: "popular"
              | "trending"
              | "recent";
              until?: number;
              user_pubkey?: string;
          },
      ]
      | ["explore_global_trending_24h", { limit?: number }]
      | ["explore_global_mostzapped_4h", { limit?: number }]
      | [
          "scored",
          {
              apply_humaness_check?: boolean;
              created_after?: number;
              gm_mode?: boolean;
              group_by_pubkey?: boolean;
              include_top_zaps?: boolean;
              limit?: number;
              offset?: number;
              pubkeys?: string[];
              since?: number;
              timeframe: "popular"
              | "trending"
              | "recent";
              until?: number;
              user_pubkey?: string;
          },
      ]
      | ["scored_users", { limit?: number }]
      | ["scored_users_24h", { limit?: number }]
      | ["get_default_relays", {}]
      | ["get_recommended_users", { limit?: number }]
      | ["get_suggested_users", { limit?: number }]
      | [
          "user_profile_scored_content",
          {
              created_after?: number;
              limit?: number;
              offset?: number;
              pubkey: string;
              since?: number;
              until?: number;
          },
      ]
      | [
          "user_profile_scored_media_thumbnails",
          {
              created_after?: number;
              limit?: number;
              offset?: number;
              pubkey: string;
              since?: number;
              until?: number;
          },
      ]
      | [
          "search",
          {
              limit?: number;
              offset?: number;
              query: string;
              since?: number;
              until?: number;
          },
      ]
      | [
          "advanced_search",
          {
              limit?: number;
              offset?: number;
              query: string;
              since?: number;
              sort?: "popular"
              | "trending"
              | "latest";
              until?: number;
          },
      ]
      | [
          "advanced_feed",
          {
              feed_type: string;
              limit?: number;
              offset?: number;
              since?: number;
              until?: number;
          },
      ]
      | ["relays", {}]
      | [
          "get_notifications",
          {
              limit?: number;
              offset?: number;
              pubkey: string;
              since?: number;
              until?: number;
          },
      ]
      | ["set_notifications_seen", { pubkey: string; until: number }]
      | ["get_notifications_seen", { pubkey: string }]
      | ["user_search", { limit?: number; query: string }]
      | [
          "feed_directive",
          {
              feed_type: string;
              limit?: number;
              offset?: number;
              pubkey: string;
              since?: number;
              until?: number;
          },
      ]
      | [
          "feed_directive_2",
          {
              feed_type: string;
              limit?: number;
              offset?: number;
              pubkey: string;
              since?: number;
              until?: number;
          },
      ]
      | ["get_advanced_feeds", {}]
      | ["trending_hashtags", { limit?: number }]
      | ["trending_hashtags_4h", { limit?: number }]
      | ["trending_hashtags_7d", { limit?: number }]
      | ["trending_images", { limit?: number }]
      | ["trending_images_4h", { limit?: number }]
      | ["report_user", { pubkey: string; reason: string }]
      | ["report_note", { event_id: string; reason: string }]
      | ["get_filterlist", {}]
      | ["check_filterlist", { pubkeys: string[] }]
      | ["broadcast_reply", { event: Event }]
      | ["broadcast_events", { events: Event[]; relays: string[] }]
      | ["trusted_users", { extended_response?: boolean; limit?: number }]
      | [
          "note_mentions",
          {
              event_id?: string;
              identifier?: string;
              limit?: number;
              offset?: number;
              pubkey?: string;
              user_pubkey?: string;
          },
      ]
      | ["note_mentions_count", { event_id: string }]
      | ["get_media_metadata", { urls: string[] }]
Returns Observable<R["event"]>
- Defined in extra/src/primal.ts:254

checkFilterlist

checkFilterlist(pubkeys: string[]): Promise<Event[]>
Check filterlist
Parameters
- pubkeys: string[]
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:465

close

close(): void
Force close the connection

Returns void
Inherited from Relay.close
- Defined in relay/dist/relay.d.ts:134

count

count(filters: Filter | Filter[], id?: string): Observable<CountResponse>
Create a COUNT observable that emits a single count response
Parameters
- filters: Filter | Filter[]
- Optionalid: string
Returns Observable<CountResponse>
Inherited from Relay.count
- Defined in relay/dist/relay.d.ts:108

`Protected`customRepeatOperator

customRepeatOperator<T extends unknown = unknown>(
times: number | boolean | RepeatConfig | undefined,
): MonoTypeOperatorFunction<T>
Internal operator for creating the repeat() operator
Type Parameters
- T extends unknown = unknown
Parameters
- times: number | boolean | RepeatConfig | undefined
Returns MonoTypeOperatorFunction<T>
Inherited from Relay.customRepeatOperator
- Defined in relay/dist/relay.d.ts:120

`Protected`customRetryOperator

customRetryOperator<T extends unknown = unknown>(
times: number | boolean | RetryConfig | undefined,
base?: RetryConfig,
): MonoTypeOperatorFunction<T>
Internal operator for creating the retry() operator
Type Parameters
- T extends unknown = unknown
Parameters
- times: number | boolean | RetryConfig | undefined
- Optionalbase: RetryConfig
Returns MonoTypeOperatorFunction<T>
Inherited from Relay.customRetryOperator
- Defined in relay/dist/relay.d.ts:118

`Protected`customTimeoutOperator

customTimeoutOperator<T extends unknown = unknown>(
timeout: number | boolean | undefined,
defaultTimeout: number,
): MonoTypeOperatorFunction<T>
Internal operator for creating the timeout() operator
Type Parameters
- T extends unknown = unknown
Parameters
- timeout: number | boolean | undefined
- defaultTimeout: number
Returns MonoTypeOperatorFunction<T>
Inherited from Relay.customTimeoutOperator
- Defined in relay/dist/relay.d.ts:122

event

event(event: Event, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>
Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors
Parameters
- event: Event
- Optionalverb: "EVENT" | "AUTH"
Returns Observable<PublishResponse>
Inherited from Relay.event
- Defined in relay/dist/relay.d.ts:110

explore

explore(
    params: {
        apply_humaness_check?: boolean;
        created_after?: number;
        gm_mode?: boolean;
        group_by_pubkey?: boolean;
        include_top_zaps?: boolean;
        limit?: number;
        offset?: number;
        pubkeys?: string[];
        since?: number;
        timeframe: "popular" | "trending" | "recent";
        until?: number;
        user_pubkey?: string;
    },
): Promise<Event[]>
Explore content with various filters
Parameters
- params: {
      apply_humaness_check?: boolean;
      created_after?: number;
      gm_mode?: boolean;
      group_by_pubkey?: boolean;
      include_top_zaps?: boolean;
      limit?: number;
      offset?: number;
      pubkeys?: string[];
      since?: number;
      timeframe: "popular" | "trending" | "recent";
      until?: number;
      user_pubkey?: string;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:277

exploreGlobalMostZapped4h

exploreGlobalMostZapped4h(limit?: number): Promise<Event[]>
Get global most zapped content from last 4 hours
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:287

exploreGlobalTrending24h

exploreGlobalTrending24h(limit?: number): Promise<Event[]>
Get global trending content from last 24 hours
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:282

exploreLegendCounts

exploreLegendCounts(pubkey: string): Promise<Event[]>
Get legend counts for explore page
Parameters
- pubkey: string
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:272

feedDirective

feedDirective(
    params: {
        feed_type: string;
        limit?: number;
        offset?: number;
        pubkey: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Feed directive
Parameters
- params: {
      feed_type: string;
      limit?: number;
      offset?: number;
      pubkey: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:380

feedDirective2

feedDirective2(
    params: {
        feed_type: string;
        limit?: number;
        offset?: number;
        pubkey: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Feed directive v2
Parameters
- params: {
      feed_type: string;
      limit?: number;
      offset?: number;
      pubkey: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:385

getAdvancedFeeds

getAdvancedFeeds(): Promise<Event[]>
Get advanced feeds

Returns Promise<Event[]>
- Defined in extra/src/primal.ts:390

getDefaultRelays

getDefaultRelays(): Promise<Event[]>
Get default relays

Returns Promise<Event[]>
- Defined in extra/src/primal.ts:311

getFilterlist

getFilterlist(): Promise<Event[]>
Get filterlist

Returns Promise<Event[]>
- Defined in extra/src/primal.ts:460

getInformation

getInformation(): Promise<RelayInformation | null>
An async method that returns the NIP-11 information document for the relay

Returns Promise<RelayInformation | null>
Inherited from Relay.getInformation
- Defined in relay/dist/relay.d.ts:136

getLimitations

getLimitations(): Promise<Partial<Limitations> | null | undefined>
An async method that returns the NIP-11 limitations for the relay

Returns Promise<Partial<Limitations> | null | undefined>
Inherited from Relay.getLimitations
- Defined in relay/dist/relay.d.ts:138

getMediaMetadata

getMediaMetadata(urls: string[]): Promise<Event[]>
Get media metadata
Parameters
- urls: string[]
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:496

getNotifications

getNotifications(
    params: {
        limit?: number;
        offset?: number;
        pubkey: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Get notifications
Parameters
- params: {
      limit?: number;
      offset?: number;
      pubkey: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:424

getNotificationsSeen

getNotificationsSeen(pubkey: string): Promise<Event[]>
Get notifications seen status
Parameters
- pubkey: string
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:434

getRecommendedUsers

getRecommendedUsers(limit?: number): Promise<Event[]>
Get recommended users
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:318

getSuggestedUsers

getSuggestedUsers(limit?: number): Promise<Event[]>
Get suggested users
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:323

getSupported

getSupported(): Promise<number[] | null>
An async method that returns the supported NIPs for the relay

Returns Promise<number[] | null>
Inherited from Relay.getSupported
- Defined in relay/dist/relay.d.ts:140

`Protected`handleAuthRequiredForReq

handleAuthRequiredForReq(
operation: "REQ" | "COUNT",
): MonoTypeOperatorFunction<any>
Internal operator for handling auth-required errors from REQ/COUNT operations
Parameters
- operation: "REQ" | "COUNT"
Returns MonoTypeOperatorFunction<any>
Inherited from Relay.handleAuthRequiredForReq
- Defined in relay/dist/relay.d.ts:124

multiplex

multiplex<T>(
    open: () => any,
    close: () => any,
    filter: (message: any) => boolean,
): Observable<T>
Creates an Observable, that when subscribed to, sends a message, defined by the subMsg function, to the server over the socket to begin a subscription to data over that socket. Once data arrives, the messageFilter argument will be used to select the appropriate data for the resulting Observable. When finalization occurs, either due to unsubscription, completion, or error, a message defined by the unsubMsg argument will be sent to the server over the WebSocketSubject.
Type Parameters
- T
Parameters
- open: () => any
- close: () => any
- filter: (message: any) => boolean
Returns Observable<T>
Inherited from Relay.multiplex
- Defined in relay/dist/relay.d.ts:102

negentropy

negentropy(
    store: Event[] | IEventStoreRead | IAsyncEventStoreRead,
    filter: Filter,
    reconcile: ReconcileFunction,
    opts?: NegentropySyncOptions,
): Promise<boolean>
Negentropy sync event ids with the relay and an event store
Parameters
- store: Event[] | IEventStoreRead | IAsyncEventStoreRead
- filter: Filter
- reconcile: ReconcileFunction
- Optionalopts: NegentropySyncOptions
Returns Promise<boolean>
Inherited from Relay.negentropy
- Defined in relay/dist/relay.d.ts:114

noteMentions

noteMentions(
    params: {
        event_id?: string;
        identifier?: string;
        limit?: number;
        offset?: number;
        pubkey?: string;
        user_pubkey?: string;
    },
): Promise<Event[]>
Get note mentions
Parameters
- params: {
      event_id?: string;
      identifier?: string;
      limit?: number;
      offset?: number;
      pubkey?: string;
      user_pubkey?: string;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:484

noteMentionsCount

noteMentionsCount(eventId: string): Promise<Event[]>
Get note mentions count
Parameters
- eventId: string
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:489

publish

publish(event: Event, opts?: PublishOptions): Promise<PublishResponse>
Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries )
Parameters
- event: Event
- Optionalopts: PublishOptions
Returns Promise<PublishResponse>
Inherited from Relay.publish
- Defined in relay/dist/relay.d.ts:130

relays

relays(): Promise<Event[]>
Get relays

Returns Promise<Event[]>
- Defined in extra/src/primal.ts:441

reportNote

reportNote(eventId: string, reason: string): Promise<Event[]>
Report note
Parameters
- eventId: string
- reason: string
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:453

reportUser

reportUser(pubkey: string, reason: string): Promise<Event[]>
Report user
Parameters
- pubkey: string
- reason: string
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:448

req

req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>
Create a REQ observable that emits events or "EOSE" or errors
Parameters
- filters: FilterInput
- Optionalid: string
Returns Observable<SubscriptionResponse>
Inherited from Relay.req
- Defined in relay/dist/relay.d.ts:106

request

request(filters: FilterInput, opts?: SubscriptionOptions): Observable<Event>
Makes a single request that retires on errors and completes on EOSE
Parameters
- filters: FilterInput
- Optionalopts: SubscriptionOptions
Returns Observable<Event>
Inherited from Relay.request
- Defined in relay/dist/relay.d.ts:128

`Protected`resetState

resetState(): void
Returns void
Inherited from Relay.resetState
- Defined in relay/dist/relay.d.ts:92

scored

scored(
    params: {
        apply_humaness_check?: boolean;
        created_after?: number;
        gm_mode?: boolean;
        group_by_pubkey?: boolean;
        include_top_zaps?: boolean;
        limit?: number;
        offset?: number;
        pubkeys?: string[];
        since?: number;
        timeframe: "popular" | "trending" | "recent";
        until?: number;
        user_pubkey?: string;
    },
): Promise<Event[]>
Get scored content
Parameters
- params: {
      apply_humaness_check?: boolean;
      created_after?: number;
      gm_mode?: boolean;
      group_by_pubkey?: boolean;
      include_top_zaps?: boolean;
      limit?: number;
      offset?: number;
      pubkeys?: string[];
      since?: number;
      timeframe: "popular" | "trending" | "recent";
      until?: number;
      user_pubkey?: string;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:294

scoredUsers

scoredUsers(limit?: number): Promise<Event[]>
Get scored users
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:299

scoredUsers24h

scoredUsers24h(limit?: number): Promise<Event[]>
Get scored users from last 24 hours
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:304

search

search(
    params: {
        limit?: number;
        offset?: number;
        query: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Search content
Parameters
- params: {
      limit?: number;
      offset?: number;
      query: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:363

send

send(message: any): void
Send a message to the relay
Parameters
- message: any
Returns void
Inherited from Relay.send
- Defined in relay/dist/relay.d.ts:104

setNotificationsSeen

setNotificationsSeen(pubkey: string, until: number): Promise<Event[]>
Set notifications as seen
Parameters
- pubkey: string
- until: number
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:429

`Protected`startReconnectTimer

startReconnectTimer(error: Error | CloseEvent): void
Set ready = false and start the reconnect timer
Parameters
- error: Error | CloseEvent
Returns void
Inherited from Relay.startReconnectTimer
- Defined in relay/dist/relay.d.ts:97

subscription

subscription(
filters: FilterInput,
opts?: SubscriptionOptions,
): Observable<SubscriptionResponse>
Creates a REQ that retries when relay errors ( default 3 retries )
Parameters
- filters: FilterInput
- Optionalopts: SubscriptionOptions
Returns Observable<SubscriptionResponse>
Inherited from Relay.subscription
- Defined in relay/dist/relay.d.ts:126

sync

sync(
    store: Event[] | IEventStoreRead | IAsyncEventStoreRead,
    filter: Filter,
    direction?: SyncDirection,
): Observable<Event>
Negentropy sync events with the relay and an event store
Parameters
- store: Event[] | IEventStoreRead | IAsyncEventStoreRead
- filter: Filter
- Optionaldirection: SyncDirection
Returns Observable<Event>
Inherited from Relay.sync
- Defined in relay/dist/relay.d.ts:132

`Protected`timelineRequest

timelineRequest<R extends RequestAndResponse<any, any, any>>(
method: R["req"][0],
args: R["req"][1],
): Promise<R["event"][]>
Makes a cache request and returns a timeline of events
Type Parameters
- R extends RequestAndResponse<any, any, any>
Parameters
- method: R["req"][0]
- args: R["req"][1]
Returns Promise<R["event"][]>
- Defined in extra/src/primal.ts:262

trendingHashtags

trendingHashtags(limit?: number): Promise<Event[]>
Get trending hashtags
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:397

trendingHashtags4h

trendingHashtags4h(limit?: number): Promise<Event[]>
Get trending hashtags from last 4 hours
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:402

trendingHashtags7d

trendingHashtags7d(limit?: number): Promise<Event[]>
Get trending hashtags from last 7 days
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:407

trendingImages

trendingImages(limit?: number): Promise<Event[]>
Get trending images
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:412

trendingImages4h

trendingImages4h(limit?: number): Promise<Event[]>
Get trending images from last 4 hours
Parameters
- limit: number = 20
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:417

trustedUsers

trustedUsers(limit?: number, extendedResponse?: boolean): Promise<Event[]>
Get trusted users
Parameters
- limit: number = 500
- extendedResponse: boolean = true
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:342

userProfileScoredContent

userProfileScoredContent(
    params: {
        created_after?: number;
        limit?: number;
        offset?: number;
        pubkey: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Get user profile scored content
Parameters
- params: {
      created_after?: number;
      limit?: number;
      offset?: number;
      pubkey: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:349

userProfileScoredMediaThumbnails

userProfileScoredMediaThumbnails(
    params: {
        created_after?: number;
        limit?: number;
        offset?: number;
        pubkey: string;
        since?: number;
        until?: number;
    },
): Promise<Event[]>
Get user profile scored media thumbnails
Parameters
- params: {
      created_after?: number;
      limit?: number;
      offset?: number;
      pubkey: string;
      since?: number;
      until?: number;
  }
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:354

userSearch

userSearch(query: string, limit?: number): Promise<Event[]>
Search for users by query
Parameters
- query: string
- limit: number = 10
Returns Promise<Event[]>
- Defined in extra/src/primal.ts:328

`Protected`waitForAuth

waitForAuth<T extends unknown = unknown>(
requireAuth: Observable<boolean>,
observable: Observable<T>,
): Observable<T>
Wait for authentication state, make connection and then wait for authentication if required
Type Parameters
- T extends unknown = unknown
Parameters
- requireAuth: Observable<boolean>
- observable: Observable<T>
Returns Observable<T>
Inherited from Relay.waitForAuth
- Defined in relay/dist/relay.d.ts:99

`Protected`waitForReady

waitForReady<T extends unknown = unknown>(
observable: Observable<T>,
): Observable<T>
Wait for the relay to be ready to accept connections
Type Parameters
- T extends unknown = unknown
Parameters
- observable: Observable<T>
Returns Observable<T>
Inherited from Relay.waitForReady
- Defined in relay/dist/relay.d.ts:101

`Static`createReconnectTimer

createReconnectTimer(
_relay: string,
): (_error?: Error | CloseEvent, tries?: number) => Observable<0>
Static method to create a reconnection method for each relay
Parameters
- _relay: string
Returns (_error?: Error | CloseEvent, tries?: number) => Observable<0>
Inherited from Relay.createReconnectTimer
- Defined in relay/dist/relay.d.ts:144

`Static`fetchInformationDocument

fetchInformationDocument(url: string): Observable<RelayInformation | null>
Static method to fetch the NIP-11 information document for a relay
Parameters
- url: string
Returns Observable<RelayInformation | null>
Inherited from Relay.fetchInformationDocument
- Defined in relay/dist/relay.d.ts:142

Class PrimalCache

See

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns PrimalCache

Properties

Protected_nip11

attempts$

authenticated$

authenticationResponse$

authRequiredForPublish$

authRequiredForRead$

challenge$

close$

closing$

connected$

eoseTimeout

error$

eventTimeout

information$

keepAlive

limitations$

Protectedlog

message$

Note

notice$

Note

notices$

open$

publishTimeout

Protectedready$

ProtectedreceivedAuthRequiredForEvent

ProtectedreceivedAuthRequiredForReq

reconnectTimer

Protectedsocket

supported$

url

ProtectedwatchTower

Accessors

authenticated

Returns boolean

authenticationResponse

Returns PublishResponse | null

challenge

Returns string | null

connected

Returns boolean

information

Returns RelayInformation | null

notices

Returns string[]

Methods

advancedFeed

Parameters

Returns Promise<Event[]>

advancedSearch

Parameters

Returns Promise<Event[]>

auth

Parameters

Returns Promise<PublishResponse>

authenticate

Parameters

Returns Promise<PublishResponse>

broadcastEvents

Parameters

Returns Promise<Event[]>

broadcastReply

Parameters

Returns Promise<Event[]>

cacheRequest

Type Parameters

Parameters

`Protected`_nip11

`Protected`log

`Protected`ready$

`Protected`receivedAuthRequiredForEvent

`Protected`receivedAuthRequiredForReq

`Protected`socket

`Protected`watchTower

`Protected`customRepeatOperator

`Protected`customRetryOperator

`Protected`customTimeoutOperator

`Protected`handleAuthRequiredForReq