nostr-tools
Version:
Tools for making a Nostr client.
111 lines (110 loc) • 3.88 kB
TypeScript
import type { Event, EventTemplate, VerifiedEvent, Nostr } from './core.ts';
import { type Filter } from './filter.ts';
export type AbstractRelayConstructorOptions = {
verifyEvent: Nostr['verifyEvent'];
websocketImplementation?: typeof WebSocket;
enablePing?: boolean;
enableReconnect?: boolean;
};
export declare class SendingOnClosedConnection extends Error {
constructor(message: string, relay: string);
}
export declare class AbstractRelay {
readonly url: string;
private _connected;
onclose: (() => void) | null;
onnotice: (msg: string) => void;
onauth: undefined | ((evt: EventTemplate) => Promise<VerifiedEvent>);
baseEoseTimeout: number;
publishTimeout: number;
pingFrequency: number;
pingTimeout: number;
resubscribeBackoff: number[];
openSubs: Map<string, Subscription>;
enablePing: boolean | undefined;
enableReconnect: boolean;
idleSince: number | undefined;
ongoingOperations: number;
private reconnectTimeoutHandle;
private pingIntervalHandle;
private reconnectAttempts;
private skipReconnection;
private connectionPromise;
private openCountRequests;
private openEventPublishes;
private ws;
private challenge;
private authPromise;
private serial;
private verifyEvent;
private _WebSocket;
constructor(url: string, opts: AbstractRelayConstructorOptions);
static connect(url: string, opts: AbstractRelayConstructorOptions & Parameters<AbstractRelay['connect']>[0]): Promise<AbstractRelay>;
private closeAllSubscriptions;
get connected(): boolean;
private reconnect;
private handleHardClose;
connect(opts?: {
timeout?: number;
abort?: AbortSignal;
}): Promise<void>;
private waitForPingPong;
private waitForDummyReq;
private pingpong;
send(message: string): Promise<void>;
auth(signAuthEvent: (evt: EventTemplate) => Promise<VerifiedEvent>): Promise<string>;
publish(event: Event): Promise<string>;
count(filters: Filter[], params: {
id?: string | null;
}): Promise<number>;
subscribe(filters: Filter[], params: Partial<SubscriptionParams> & {
label?: string;
id?: string;
}): Subscription;
prepareSubscription(filters: Filter[], params: Partial<SubscriptionParams> & {
label?: string;
id?: string;
}): Subscription;
close(): void;
_onmessage(ev: MessageEvent<any>): void;
}
export declare class Subscription {
readonly relay: AbstractRelay;
readonly id: string;
lastEmitted: number | undefined;
closed: boolean;
eosed: boolean;
filters: Filter[];
alreadyHaveEvent: ((id: string) => boolean) | undefined;
receivedEvent: ((relay: AbstractRelay, id: string) => void) | undefined;
onevent: (evt: Event) => void;
oninvalidevent: ((evt: unknown) => void) | undefined;
oneose: (() => void) | undefined;
onclose: ((reason: string) => void) | undefined;
oncustom: ((msg: string[]) => void) | undefined;
eoseTimeout: number;
private eoseTimeoutHandle;
constructor(relay: AbstractRelay, id: string, filters: Filter[], params: SubscriptionParams);
fire(): void;
receivedEose(): void;
close(reason?: string): void;
}
export type SubscriptionParams = {
onevent?: (evt: Event) => void;
oninvalidevent?: (evt: unknown) => void;
oneose?: () => void;
onclose?: (reason: string) => void;
alreadyHaveEvent?: (id: string) => boolean;
receivedEvent?: (relay: AbstractRelay, id: string) => void;
eoseTimeout?: number;
abort?: AbortSignal;
};
export type CountResolver = {
resolve: (count: number) => void;
reject: (err: Error) => void;
};
export type EventPublishResolver = {
resolve: (reason: string) => void;
reject: (err: Error) => void;
timeout: ReturnType<typeof setTimeout>;
};