applesauce-relay 0.0.0-next-20251220152312 → 0.0.0-next-20251231055351

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./group.js";
 export * from "./liveness.js";
+export * from "./management.js";
 export * from "./pool.js";
 export * from "./relay.js";
 export * from "./types.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./group.js";
 export * from "./liveness.js";
+export * from "./management.js";
 export * from "./pool.js";
 export * from "./relay.js";
 export * from "./types.js";

package/dist/management.d.ts

@@ -0,0 +1,169 @@
+import { logger } from "applesauce-core";
+import { Observable } from "rxjs";
+import { AuthSigner } from "./types.js";
+import { Relay } from "./relay.js";
+/** Base request structure for all NIP-86 requests */
+export interface TRelayRequest<Method extends string, Params extends any[] = any[]> {
+    /** The method to call */
+    method: Method;
+    /** Parameters for the method */
+    params: Params;
+}
+/** Base response structure for all NIP-86 responses */
+export type TRelayErrorResponse = {
+    /** Error message, non-null in case of error */
+    error: string;
+    result: null;
+};
+export type TRelaySuccessResponse<Result> = {
+    error: null;
+    /** Result object, null in case of error */
+    result: Result;
+};
+/** Merged relay management method and response types */
+export type TRelayMethod<Method extends string = string, Params extends any[] = any[], Result extends any = any> = {
+    /** Method string */
+    method: Method;
+    /** Request type */
+    request: TRelayRequest<Method, Params>;
+    /** Response success type */
+    response: TRelaySuccessResponse<Result>;
+    /** Response error type */
+    error: TRelayErrorResponse;
+};
+export type SupportedMethodsMethod = TRelayMethod<"supportedmethods", [], string[]>;
+export type BanPubkeyMethod = TRelayMethod<"banpubkey", [string, string?], true>;
+export type ListBannedPubkeysMethod = TRelayMethod<"listbannedpubkeys", [], Array<{
+    pubkey: string;
+    reason?: string;
+}>>;
+export type AllowPubkeyMethod = TRelayMethod<"allowpubkey", [string, string?], true>;
+export type ListAllowedPubkeysMethod = TRelayMethod<"listallowedpubkeys", [
+], Array<{
+    pubkey: string;
+    reason?: string;
+}>>;
+export type ListEventsNeedingModerationMethod = TRelayMethod<"listeventsneedingmoderation", [
+], Array<{
+    id: string;
+    reason?: string;
+}>>;
+export type AllowEventMethod = TRelayMethod<"allowevent", [string, string?], true>;
+export type BanEventMethod = TRelayMethod<"banevent", [string, string?], true>;
+export type ListBannedEventsMethod = TRelayMethod<"listbannedevents", [], Array<{
+    id: string;
+    reason?: string;
+}>>;
+export type ChangeRelayNameMethod = TRelayMethod<"changerelayname", [string], true>;
+export type ChangeRelayDescriptionMethod = TRelayMethod<"changerelaydescription", [string], true>;
+export type ChangeRelayIconMethod = TRelayMethod<"changerelayicon", [string], true>;
+export type AllowKindMethod = TRelayMethod<"allowkind", [number], true>;
+export type DisallowKindMethod = TRelayMethod<"disallowkind", [number], true>;
+export type ListAllowedKindsMethod = TRelayMethod<"listallowedkinds", [], number[]>;
+export type BlockIpMethod = TRelayMethod<"blockip", [string, string?], true>;
+export type UnblockIpMethod = TRelayMethod<"unblockip", [string], true>;
+export type ListBlockedIpsMethod = TRelayMethod<"listblockedips", [], Array<{
+    ip: string;
+    reason?: string;
+}>>;
+/** Union type for all relay management method definitions */
+export type RelayManagementMethods = SupportedMethodsMethod | BanPubkeyMethod | ListBannedPubkeysMethod | AllowPubkeyMethod | ListAllowedPubkeysMethod | ListEventsNeedingModerationMethod | AllowEventMethod | BanEventMethod | ListBannedEventsMethod | ChangeRelayNameMethod | ChangeRelayDescriptionMethod | ChangeRelayIconMethod | AllowKindMethod | DisallowKindMethod | ListAllowedKindsMethod | BlockIpMethod | UnblockIpMethod | ListBlockedIpsMethod;
+/** Custom error for relay management operations */
+export declare class RelayManagementError extends Error {
+    readonly method?: string | undefined;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, method?: string | undefined, statusCode?: number | undefined);
+}
+/** RelayManagement class for NIP-86 relay management API */
+export declare class RelayManagement {
+    #private;
+    readonly relay: Relay;
+    readonly signer: AuthSigner;
+    protected log: typeof logger;
+    protected httpUrl: string;
+    constructor(relay: Relay, signer: AuthSigner);
+    /**
+     * Core request method that handles all RPC calls with NIP-98 authentication
+     */
+    request<Method extends RelayManagementMethods>(method: Method["method"], params: Method["request"]["params"]): Promise<Method["response"]["result"]>;
+    /** Get list of supported methods */
+    supportedMethods(): Promise<string[]>;
+    /** Ban a pubkey */
+    banPubkey(pubkey: string, reason?: string): Promise<true>;
+    /** List all banned pubkeys */
+    listBannedPubkeys(): Promise<Array<{
+        pubkey: string;
+        reason?: string;
+    }>>;
+    /** Allow a pubkey */
+    allowPubkey(pubkey: string, reason?: string): Promise<true>;
+    /** List all allowed pubkeys */
+    listAllowedPubkeys(): Promise<Array<{
+        pubkey: string;
+        reason?: string;
+    }>>;
+    /** List events needing moderation */
+    listEventsNeedingModeration(): Promise<Array<{
+        id: string;
+        reason?: string;
+    }>>;
+    /** Allow an event */
+    allowEvent(eventId: string, reason?: string): Promise<true>;
+    /** Ban an event */
+    banEvent(eventId: string, reason?: string): Promise<true>;
+    /** List all banned events */
+    listBannedEvents(): Promise<Array<{
+        id: string;
+        reason?: string;
+    }>>;
+    /** Change relay name */
+    changeRelayName(name: string): Promise<true>;
+    /** Change relay description */
+    changeRelayDescription(description: string): Promise<true>;
+    /** Change relay icon */
+    changeRelayIcon(iconUrl: string): Promise<true>;
+    /** Allow a kind */
+    allowKind(kind: number): Promise<true>;
+    /** Disallow a kind */
+    disallowKind(kind: number): Promise<true>;
+    /** List all allowed kinds */
+    listAllowedKinds(): Promise<number[]>;
+    /** Block an IP address */
+    blockIp(ip: string, reason?: string): Promise<true>;
+    /** Unblock an IP address */
+    unblockIp(ip: string): Promise<true>;
+    /** List all blocked IPs */
+    listBlockedIps(): Promise<Array<{
+        ip: string;
+        reason?: string;
+    }>>;
+    /** Observable that emits supported methods when subscribed */
+    supportMethods$: Observable<string[]>;
+    /** Observable that emits banned pubkeys when subscribed */
+    bannedPubkeys$: Observable<Array<{
+        pubkey: string;
+        reason?: string;
+    }>>;
+    /** Observable that emits allowed pubkeys when subscribed */
+    allowedPubkeys$: Observable<Array<{
+        pubkey: string;
+        reason?: string;
+    }>>;
+    /** Observable that emits events needing moderation when subscribed */
+    eventsNeedingModeration$: Observable<Array<{
+        id: string;
+        reason?: string;
+    }>>;
+    /** Observable that emits banned events when subscribed */
+    bannedEvents$: Observable<Array<{
+        id: string;
+        reason?: string;
+    }>>;
+    /** Observable that emits allowed kinds when subscribed */
+    allowedKinds$: Observable<number[]>;
+    /** Observable that emits blocked IPs when subscribed */
+    blockedIps$: Observable<Array<{
+        ip: string;
+        reason?: string;
+    }>>;
+}

package/dist/management.js

@@ -0,0 +1,202 @@
+import { logger } from "applesauce-core";
+import { ensureHttpURL } from "applesauce-core/helpers/url";
+import { getToken } from "nostr-tools/nip98";
+import { BehaviorSubject, from, shareReplay, throwError } from "rxjs";
+import { catchError, switchMap } from "rxjs/operators";
+/** Custom error for relay management operations */
+export class RelayManagementError extends Error {
+    method;
+    statusCode;
+    constructor(message, method, statusCode) {
+        super(message);
+        this.method = method;
+        this.statusCode = statusCode;
+        this.name = "RelayManagementError";
+    }
+}
+/** RelayManagement class for NIP-86 relay management API */
+export class RelayManagement {
+    relay;
+    signer;
+    log = logger.extend("RelayManagement");
+    httpUrl;
+    // Internal refresh triggers for observables
+    #refreshSupportMethods$ = new BehaviorSubject(undefined);
+    #refreshBannedPubkeys$ = new BehaviorSubject(undefined);
+    #refreshAllowedPubkeys$ = new BehaviorSubject(undefined);
+    #refreshEventsNeedingModeration$ = new BehaviorSubject(undefined);
+    #refreshBannedEvents$ = new BehaviorSubject(undefined);
+    #refreshAllowedKinds$ = new BehaviorSubject(undefined);
+    #refreshBlockedIps$ = new BehaviorSubject(undefined);
+    constructor(relay, signer) {
+        this.relay = relay;
+        this.signer = signer;
+        this.log = this.log.extend(relay.url);
+        this.httpUrl = ensureHttpURL(relay.url);
+    }
+    /**
+     * Core request method that handles all RPC calls with NIP-98 authentication
+     */
+    async request(method, params) {
+        const requestBody = {
+            method,
+            params,
+        };
+        const requestBodyString = JSON.stringify(requestBody);
+        // Generate NIP-98 token using getToken from nostr-tools
+        const authHeader = await getToken(this.httpUrl, "POST", (event) => this.signer.signEvent(event), true, // includeAuthorizationScheme - returns "Nostr <token>" format
+        requestBody);
+        // Make the HTTP request
+        const response = await fetch(this.httpUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/nostr+json+rpc",
+                Authorization: authHeader,
+            },
+            body: requestBodyString,
+        });
+        // Handle HTTP errors
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new RelayManagementError("Unauthorized: Invalid or missing NIP-98 authentication", method, response.status);
+            }
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new RelayManagementError(`HTTP ${response.status}: ${errorText}`, method, response.status);
+        }
+        // Parse the response
+        const data = await response.json();
+        // Handle RPC errors
+        if (data.error) {
+            throw new RelayManagementError(`RPC error: ${data.error}`, method, response.status);
+        }
+        return data.result;
+    }
+    // Convenience methods for each RPC call
+    /** Get list of supported methods */
+    async supportedMethods() {
+        return this.request("supportedmethods", []);
+    }
+    /** Ban a pubkey */
+    async banPubkey(pubkey, reason) {
+        const result = await this.request("banpubkey", reason ? [pubkey, reason] : [pubkey]);
+        this.#refreshBannedPubkeys$.next();
+        return result;
+    }
+    /** List all banned pubkeys */
+    async listBannedPubkeys() {
+        return this.request("listbannedpubkeys", []);
+    }
+    /** Allow a pubkey */
+    async allowPubkey(pubkey, reason) {
+        const result = await this.request("allowpubkey", reason ? [pubkey, reason] : [pubkey]);
+        this.#refreshAllowedPubkeys$.next();
+        this.#refreshBannedPubkeys$.next(); // Also refresh banned list in case it was unbanned
+        return result;
+    }
+    /** List all allowed pubkeys */
+    async listAllowedPubkeys() {
+        return this.request("listallowedpubkeys", []);
+    }
+    /** List events needing moderation */
+    async listEventsNeedingModeration() {
+        return this.request("listeventsneedingmoderation", []);
+    }
+    /** Allow an event */
+    async allowEvent(eventId, reason) {
+        const result = await this.request("allowevent", reason ? [eventId, reason] : [eventId]);
+        this.#refreshBannedEvents$.next(); // Also refresh banned list in case it was unbanned
+        this.#refreshEventsNeedingModeration$.next();
+        return result;
+    }
+    /** Ban an event */
+    async banEvent(eventId, reason) {
+        const result = await this.request("banevent", reason ? [eventId, reason] : [eventId]);
+        this.#refreshBannedEvents$.next();
+        this.#refreshEventsNeedingModeration$.next();
+        return result;
+    }
+    /** List all banned events */
+    async listBannedEvents() {
+        return this.request("listbannedevents", []);
+    }
+    /** Change relay name */
+    async changeRelayName(name) {
+        return this.request("changerelayname", [name]);
+    }
+    /** Change relay description */
+    async changeRelayDescription(description) {
+        return this.request("changerelaydescription", [description]);
+    }
+    /** Change relay icon */
+    async changeRelayIcon(iconUrl) {
+        return this.request("changerelayicon", [iconUrl]);
+    }
+    /** Allow a kind */
+    async allowKind(kind) {
+        const result = await this.request("allowkind", [kind]);
+        this.#refreshAllowedKinds$.next();
+        return result;
+    }
+    /** Disallow a kind */
+    async disallowKind(kind) {
+        const result = await this.request("disallowkind", [kind]);
+        this.#refreshAllowedKinds$.next();
+        return result;
+    }
+    /** List all allowed kinds */
+    async listAllowedKinds() {
+        return this.request("listallowedkinds", []);
+    }
+    /** Block an IP address */
+    async blockIp(ip, reason) {
+        const result = await this.request("blockip", reason ? [ip, reason] : [ip]);
+        this.#refreshBlockedIps$.next();
+        return result;
+    }
+    /** Unblock an IP address */
+    async unblockIp(ip) {
+        const result = await this.request("unblockip", [ip]);
+        this.#refreshBlockedIps$.next();
+        return result;
+    }
+    /** List all blocked IPs */
+    async listBlockedIps() {
+        return this.request("listblockedips", []);
+    }
+    // Reactive observables for list methods
+    /** Observable that emits supported methods when subscribed */
+    supportMethods$ = this.#refreshSupportMethods$.pipe(switchMap(() => from(this.supportedMethods())), catchError((error) => {
+        this.log("Error fetching supported methods:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits banned pubkeys when subscribed */
+    bannedPubkeys$ = this.#refreshBannedPubkeys$.pipe(switchMap(() => from(this.listBannedPubkeys())), catchError((error) => {
+        this.log("Error fetching banned pubkeys:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits allowed pubkeys when subscribed */
+    allowedPubkeys$ = this.#refreshAllowedPubkeys$.pipe(switchMap(() => from(this.listAllowedPubkeys())), catchError((error) => {
+        this.log("Error fetching allowed pubkeys:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits events needing moderation when subscribed */
+    eventsNeedingModeration$ = this.#refreshEventsNeedingModeration$.pipe(switchMap(() => from(this.listEventsNeedingModeration())), catchError((error) => {
+        this.log("Error fetching events needing moderation:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits banned events when subscribed */
+    bannedEvents$ = this.#refreshBannedEvents$.pipe(switchMap(() => from(this.listBannedEvents())), catchError((error) => {
+        this.log("Error fetching banned events:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits allowed kinds when subscribed */
+    allowedKinds$ = this.#refreshAllowedKinds$.pipe(switchMap(() => from(this.listAllowedKinds())), catchError((error) => {
+        this.log("Error fetching allowed kinds:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+    /** Observable that emits blocked IPs when subscribed */
+    blockedIps$ = this.#refreshBlockedIps$.pipe(switchMap(() => from(this.listBlockedIps())), catchError((error) => {
+        this.log("Error fetching blocked IPs:", error);
+        return throwError(() => error);
+    }), shareReplay(1));
+}

package/dist/pool.d.ts

@@ -10,6 +10,8 @@ export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     relays$: BehaviorSubject<Map<string, Relay>>;
     get relays(): Map<string, Relay>;
+    /** Whether to ignore relays that are ready=false */
+    ignoreOffline: boolean;
     /** A signal when a relay is added */
     add$: Subject<IRelay>;
     /** A signal when a relay is removed */
@@ -18,7 +20,7 @@ export declare class RelayPool implements IPool {
     /** Get or create a new relay connection */
     relay(url: string): Relay;
     /** Create a group of relays */
-    group(relays: IPoolRelayInput): RelayGroup;
+    group(relays: IPoolRelayInput, ignoreOffline?: boolean): RelayGroup;
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay: string | IRelay, close?: boolean): void;
     /** Make a REQ to multiple relays that does not deduplicate events */

package/dist/pool.js

@@ -10,6 +10,8 @@ export class RelayPool {
     get relays() {
         return this.relays$.value;
     }
+    /** Whether to ignore relays that are ready=false */
+    ignoreOffline = true;
     /** A signal when a relay is added */
     add$ = new Subject();
     /** A signal when a relay is removed */
@@ -29,14 +31,21 @@ export class RelayPool {
         relay = new Relay(url, this.options);
         this.relays.set(url, relay);
         this.relays$.next(this.relays);
-        this.add$.next(relay);
         return relay;
     }
     /** Create a group of relays */
-    group(relays) {
-        return new RelayGroup(Array.isArray(relays)
+    group(relays, ignoreOffline = this.ignoreOffline) {
+        let input = Array.isArray(relays)
             ? relays.map((url) => this.relay(url))
-            : relays.pipe(map((urls) => urls.map((url) => this.relay(url)))));
+            : relays.pipe(map((urls) => urls.map((url) => this.relay(url))));
+        if (ignoreOffline) {
+            // Filter out the offline relays
+            if (Array.isArray(input))
+                input = input.filter((relay) => relay.ready);
+            else
+                input = input.pipe(map((relays) => relays.filter((relay) => relay.ready)));
+        }
+        return new RelayGroup(input);
     }
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay, close = true) {
@@ -59,15 +68,17 @@ export class RelayPool {
     }
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays, filters, id) {
-        return this.group(relays).req(filters, id);
+        // Never filter out offline relays in manual methods
+        return this.group(relays, false).req(filters, id);
     }
     /** Send an EVENT message to multiple relays */
     event(relays, event) {
-        return this.group(relays).event(event);
+        // Never filter out offline relays in manual methods
+        return this.group(relays, false).event(event);
     }
     /** Negentropy sync event ids with the relays and an event store */
     negentropy(relays, store, filter, reconcile, opts) {
-        return this.group(relays).negentropy(store, filter, reconcile, opts);
+        return this.group(relays, false).negentropy(store, filter, reconcile, opts);
     }
     /** Publish an event to multiple relays */
     publish(relays, event, opts) {

package/dist/relay.d.ts

@@ -25,13 +25,20 @@ export type RelayOptions = {
     publishTimeout?: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive?: number;
+    /** Default retry config for subscription() method */
+    subscriptionRetry?: RetryConfig;
+    /** Default retry config for request() method */
+    requestRetry?: RetryConfig;
+    /** Default retry config for publish() method */
+    publishRetry?: RetryConfig;
 };
 export declare class Relay implements IRelay {
+    #private;
     url: string;
     protected log: typeof logger;
     protected socket: WebSocketSubject<any>;
     /** 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 ready$: BehaviorSubject<boolean>;
+    ready$: Observable<boolean>;
     /** A method that returns an Observable that emits when the relay should reconnect */
     reconnectTimer: (error: CloseEvent | Error, attempts: number) => Observable<number>;
     /** How many times the relay has tried to reconnect */
@@ -61,6 +68,8 @@ export declare class Relay implements IRelay {
     /** An observable that emits the NIP-11 information document for the relay */
     information$: Observable<RelayInformation | null>;
     protected _nip11: RelayInformation | null;
+    /** An observable that emits the icon URL for the relay, or the favicon.ico URL for the relay */
+    icon$: Observable<string | undefined>;
     /** An observable that emits the limitations for the relay */
     limitations$: Observable<RelayInformation["limitation"] | null>;
     /** An array of supported NIPs from the NIP-11 information document */
@@ -71,6 +80,7 @@ export declare class Relay implements IRelay {
     close$: Subject<CloseEvent>;
     /** An observable that emits when underlying websocket is closing due to unsubscription */
     closing$: Subject<void>;
+    get ready(): boolean;
     get connected(): boolean;
     get challenge(): string | null;
     get notices(): string[];
@@ -85,6 +95,12 @@ export declare class Relay implements IRelay {
     publishTimeout: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive: number;
+    /** Default retry config for subscription() method */
+    protected subscriptionReconnect: RetryConfig;
+    /** Default retry config for request() method */
+    protected requestReconnect: RetryConfig;
+    /** Default retry config for publish() method */
+    protected publishRetry: RetryConfig;
     protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
     protected receivedAuthRequiredForEvent: BehaviorSubject<boolean>;
     authRequiredForRead$: Observable<boolean>;

package/dist/relay.js

@@ -8,7 +8,12 @@ import { webSocket } from "rxjs/webSocket";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 const AUTH_REQUIRED_PREFIX = "auth-required:";
-const DEFAULT_RETRY_CONFIG = { count: 10, delay: 1000, resetOnSuccess: true };
+/** Default retry config for all methods */
+const DEFAULT_RETRY_CONFIG = {
+    count: 3,
+    delay: 1000,
+    resetOnSuccess: true,
+};
 /** Flags for the negentropy sync type */
 export var SyncDirection;
 (function (SyncDirection) {
@@ -23,8 +28,10 @@ export class Relay {
     url;
     log = logger.extend("Relay");
     socket;
+    /** Internal subject that tracks the ready state of the relay */
+    #ready$ = new BehaviorSubject(true);
     /** 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 */
-    ready$ = new BehaviorSubject(true);
+    ready$ = this.#ready$.asObservable();
     /** A method that returns an Observable that emits when the relay should reconnect */
     reconnectTimer;
     /** How many times the relay has tried to reconnect */
@@ -54,6 +61,8 @@ export class Relay {
     /** An observable that emits the NIP-11 information document for the relay */
     information$;
     _nip11 = null;
+    /** An observable that emits the icon URL for the relay, or the favicon.ico URL for the relay */
+    icon$;
     /** An observable that emits the limitations for the relay */
     limitations$;
     /** An array of supported NIPs from the NIP-11 information document */
@@ -65,6 +74,9 @@ export class Relay {
     /** An observable that emits when underlying websocket is closing due to unsubscription */
     closing$ = new Subject();
     // sync state
+    get ready() {
+        return this.#ready$.value;
+    }
     get connected() {
         return this.connected$.value;
     }
@@ -91,6 +103,12 @@ export class Relay {
     publishTimeout = 30_000;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive = 30_000;
+    /** Default retry config for subscription() method */
+    subscriptionReconnect;
+    /** Default retry config for request() method */
+    requestReconnect;
+    /** Default retry config for publish() method */
+    publishRetry;
     // Subjects that track if an "auth-required" message has been received for REQ or EVENT
     receivedAuthRequiredForReq = new BehaviorSubject(false);
     receivedAuthRequiredForEvent = new BehaviorSubject(false);
@@ -124,6 +142,10 @@ export class Relay {
             this.publishTimeout = opts.publishTimeout;
         if (opts?.keepAlive !== undefined)
             this.keepAlive = opts.keepAlive;
+        // Set retry configs
+        this.subscriptionReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.subscriptionRetry ?? {}) };
+        this.requestReconnect = { ...DEFAULT_RETRY_CONFIG, ...(opts?.requestRetry ?? {}) };
+        this.publishRetry = { ...DEFAULT_RETRY_CONFIG, ...(opts?.publishRetry ?? {}) };
         // Create an observable that tracks boolean authentication state
         this.authenticated$ = this.authenticationResponse$.pipe(map((response) => response?.ok === true));
         /** Use the static method to create a new reconnect method for this relay */
@@ -134,12 +156,20 @@ export class Relay {
             this.connected$.next(true);
             this.attempts$.next(0);
             this.error$.next(null);
+            // Reset to clean state
             this.resetState();
         });
         this.close$.subscribe((event) => {
-            this.log("Disconnected");
-            this.connected$.next(false);
+            if (this.connected$.value)
+                this.log("Disconnected");
+            else
+                this.log("Failed to connect");
+            // Chnaged the connected state to false
+            if (this.connected$.value)
+                this.connected$.next(false);
+            // Increment the attempts counter
             this.attempts$.next(this.attempts$.value + 1);
+            // Reset the state
             this.resetState();
             // Start the reconnect timer if the connection was not closed cleanly
             if (!event.wasClean)
@@ -165,6 +195,7 @@ export class Relay {
         shareReplay(1));
         this.limitations$ = this.information$.pipe(map((info) => (info ? info.limitation : null)));
         this.supported$ = this.information$.pipe(map((info) => info && Array.isArray(info.supported_nips) ? info.supported_nips.filter((n) => typeof n === "number") : null));
+        this.icon$ = this.information$.pipe(map((info) => info?.icon || new URL("/favicon.ico", ensureHttpURL(this.url)).toString()));
         // Create observables that track if auth is required for REQ or EVENT
         this.authRequiredForRead$ = this.receivedAuthRequiredForReq;
         this.authRequiredForPublish$ = this.receivedAuthRequiredForEvent;
@@ -226,13 +257,13 @@ export class Relay {
     }
     /** Set ready = false and start the reconnect timer */
     startReconnectTimer(error) {
-        if (!this.ready$.value)
+        if (!this.ready)
             return;
         this.error$.next(error instanceof Error ? error : new Error("Connection error"));
-        this.ready$.next(false);
+        this.#ready$.next(false);
         this.reconnectTimer(error, this.attempts$.value)
             .pipe(take(1))
-            .subscribe(() => this.ready$.next(true));
+            .subscribe(() => this.#ready$.next(true));
     }
     /** Wait for authentication state, make connection and then wait for authentication if required */
     waitForAuth(
@@ -251,7 +282,7 @@ export class Relay {
     /** Wait for the relay to be ready to accept connections */
     waitForReady(observable) {
         // Don't wait if the relay is already ready
-        if (this.ready$.value)
+        if (this.ready)
             return observable;
         else
             return this.ready$.pipe(
@@ -466,7 +497,7 @@ export class Relay {
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
         // Retry on connection errors
-        this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, DEFAULT_RETRY_CONFIG), 
+        this.customRetryOperator(opts?.reconnect ?? true, this.subscriptionReconnect), 
         // Create resubscribe logic (repeat operator)
         this.customRepeatOperator(opts?.resubscribe), 
         // Single subscription
@@ -476,7 +507,7 @@ export class Relay {
     request(filters, opts) {
         return this.req(filters, opts?.id).pipe(
         // Retry on connection errors
-        this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, DEFAULT_RETRY_CONFIG), 
+        this.customRetryOperator(opts?.reconnect ?? true, this.requestReconnect), 
         // Create resubscribe logic (repeat operator)
         this.customRepeatOperator(opts?.resubscribe), 
         // Complete when EOSE is received
@@ -493,7 +524,7 @@ export class Relay {
             return of(result);
         }), 
         // Retry the publish until it succeeds or the number of retries is reached
-        this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, DEFAULT_RETRY_CONFIG), 
+        this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, this.publishRetry), 
         // Add timeout for publishing
         this.customTimeoutOperator(opts?.timeout, this.publishTimeout)));
     }

package/dist/types.d.ts

@@ -19,14 +19,10 @@ export type CountResponse = {
 export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
 /** Options for the publish method on the pool and relay */
 export type PublishOptions = {
+    /** Number of times to retry the publish. default is 3 */
+    retries?: boolean | number | Parameters<typeof retry>[0];
     /**
-     * Number of times to retry the publish. default is 10
-     * @see https://rxjs.dev/api/index/function/retry
-     * @deprecated use `reconnect` instead
-     */
-    retries?: number | Parameters<typeof retry>[0];
-    /**
-     * Whether to reconnect when socket fails to connect. default is true (10 retries with 1 second delay)
+     * Whether to reconnect when socket fails to connect. default is true (3 retries with 1 second delay)
      * @see https://rxjs.dev/api/index/function/retry
      */
     reconnect?: boolean | number | Parameters<typeof retry>[0];
@@ -39,19 +35,13 @@ export type RequestOptions = SubscriptionOptions;
 export type SubscriptionOptions = {
     /** Custom REQ id for the subscription */
     id?: string;
-    /**
-     * Number of times to retry the subscription if the relay fails to connect. default is 10
-     * @see https://rxjs.dev/api/index/function/retry
-     * @deprecated use `reconnect` instead
-     */
-    retries?: number | Parameters<typeof retry>[0];
     /**
      * Whether to resubscribe if the subscription is closed by the relay. default is false
      * @see https://rxjs.dev/api/index/function/repeat
      */
     resubscribe?: boolean | number | Parameters<typeof repeat>[0];
     /**
-     * Whether to reconnect when socket is closed. default is true (10 retries with 1 second delay)
+     * Whether to reconnect when socket is closed. default is true (3 retries with 1 second delay)
      * @see https://rxjs.dev/api/index/function/retry
      */
     reconnect?: boolean | number | Parameters<typeof retry>[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20251220152312",
+  "version": "0.0.0-next-20251231055351",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -57,14 +57,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20251220152312",
+    "applesauce-core": "0.0.0-next-20251231055351",
     "nanoid": "^5.0.9",
     "nostr-tools": "~2.18",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "0.0.0-next-20251220152312",
+    "applesauce-signers": "0.0.0-next-20251231055351",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
     "vitest": "^4.0.15",