applesauce-relay 2.3.0 → 3.0.0

package/README.md

@@ -56,9 +56,8 @@ const event = {
   // ... other required fields
 };
 
-relay.event(event).subscribe((response) => {
-  console.log(`Published:`, response.ok);
-});
+const response = await relay.publish(event);
+console.log(`Published:`, response.ok);
 ```
 
 ### Relay Pool
@@ -85,7 +84,8 @@ pool
   });
 
 // Publish to multiple relays
-pool.event(relays, event).subscribe((response) => {
+const responses = await pool.publish(relays, event);
+responses.forEach((response) => {
   console.log(`Published to ${response.from}:`, response.ok);
 });
 ```
@@ -112,7 +112,8 @@ group
   });
 
 // Publish to all relays in group
-group.event(event).subscribe((response) => {
+const responses = await group.publish(event);
+responses.forEach((response) => {
   console.log(`Published to ${response.from}:`, response.ok);
 });
 ```

package/dist/group.d.ts

@@ -1,6 +1,6 @@
 import { type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions, FilterInput } from "./types.js";
+import { FilterInput, IGroup, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 export declare class RelayGroup implements IGroup {
     relays: IRelay[];
     constructor(relays: IRelay[]);
@@ -11,7 +11,7 @@ export declare class RelayGroup implements IGroup {
     /** Send an event to all relays */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Publish an event to all relays with retries ( default 3 retries ) */
-    publish(event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
+    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Request events from all relays with retries ( default 3 retries ) */
     request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */

package/dist/group.js

@@ -35,9 +35,9 @@ export class RelayGroup {
     }
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event, opts) {
-        return merge(...this.relays.map((relay) => relay.publish(event, opts).pipe(
+        return Promise.all(this.relays.map((relay) => relay.publish(event, opts).catch(
         // Catch error and return as PublishResponse
-        catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" })))));
+        (err) => ({ ok: false, from: relay.url, message: err?.message || "Unknown error" }))));
     }
     /** Request events from all relays with retries ( default 3 retries ) */
     request(filters, opts) {

package/dist/pool.d.ts

@@ -2,7 +2,7 @@ import { type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay, RelayOptions } from "./relay.js";
-import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse, FilterInput } from "./types.js";
+import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse, FilterInput, IRelay } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     groups$: BehaviorSubject<Map<string, RelayGroup>>;
@@ -17,12 +17,14 @@ export declare class RelayPool implements IPool {
     relay(url: string): Relay;
     /** Create a group of relays */
     group(relays: string[]): 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 */
     req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Publish an event to multiple relays */
-    publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
+    publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Request events from multiple relays */
     request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to multiple relays */

package/dist/pool.js

@@ -33,7 +33,8 @@ export class RelayPool {
             return relay;
         // Create a new relay
         relay = new Relay(url, this.options);
-        this.relays$.next(this.relays.set(url, relay));
+        this.relays.set(url, relay);
+        this.relays$.next(this.relays);
         return relay;
     }
     /** Create a group of relays */
@@ -50,6 +51,24 @@ export class RelayPool {
         this.groups$.next(this.groups.set(key, group));
         return group;
     }
+    /** Removes a relay from the pool and defaults to closing the connection */
+    remove(relay, close = true) {
+        let instance;
+        if (typeof relay === "string") {
+            instance = this.relays.get(relay);
+            if (!instance)
+                return;
+        }
+        else if (Array.from(this.relays.values()).some((r) => r === relay)) {
+            instance = relay;
+        }
+        else
+            return;
+        if (close)
+            instance?.close();
+        this.relays.delete(instance.url);
+        this.relays$.next(this.relays);
+    }
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays, filters, id) {
         return this.group(relays).req(filters, id);

package/dist/relay.d.ts

@@ -1,14 +1,21 @@
 import { logger } from "applesauce-core";
 import { type Filter, type NostrEvent } from "nostr-tools";
-import { BehaviorSubject, Observable } from "rxjs";
-import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { RelayInformation } from "nostr-tools/nip11";
+import { BehaviorSubject, MonoTypeOperatorFunction, Observable, RepeatConfig, RetryConfig, Subject } from "rxjs";
+import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { AuthSigner, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** An error that is thrown when a REQ is closed from the relay side */
 export declare class ReqCloseError extends Error {
 }
 export type RelayOptions = {
+    /** Custom WebSocket implementation */
     WebSocket?: WebSocketSubjectConfig<any>["WebSocketCtor"];
+    /** How long to wait for an EOSE message (default 10s) */
+    eoseTimeout?: number;
+    /** How long to wait for an OK message from the relay (default 10s) */
+    eventTimeout?: number;
+    /** How long to keep the connection alive after nothing is subscribed (default 30s) */
+    keepAlive?: number;
 };
 export declare class Relay implements IRelay {
     url: string;
@@ -47,17 +54,23 @@ export declare class Relay implements IRelay {
     protected _nip11: RelayInformation | null;
     /** An observable that emits the limitations for the relay */
     limitations$: Observable<RelayInformation["limitation"] | null>;
+    /** An observable that emits when underlying websocket is opened */
+    open$: Subject<Event>;
+    /** An observable that emits when underlying websocket is closed */
+    close$: Subject<CloseEvent>;
+    /** An observable that emits when underlying websocket is closing due to unsubscription */
+    closing$: Subject<void>;
     get connected(): boolean;
     get challenge(): string | null;
     get notices(): string[];
     get authenticated(): boolean;
     get authenticationResponse(): PublishResponse | null;
     get information(): RelayInformation | null;
-    /** If an EOSE message is not seen in this time, emit one locally  */
+    /** If an EOSE message is not seen in this time, emit one locally (default 10s)  */
     eoseTimeout: number;
-    /** How long to wait for an OK message from the relay */
+    /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout: number;
-    /** How long to keep the connection alive after nothing is subscribed */
+    /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive: number;
     protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
     protected receivedAuthRequiredForEvent: BehaviorSubject<boolean>;
@@ -75,21 +88,27 @@ export declare class Relay implements IRelay {
     protected waitForReady<T extends unknown = unknown>(observable: Observable<T>): Observable<T>;
     multiplex<T>(open: () => any, close: () => any, filter: (message: any) => boolean): Observable<T>;
     /** Send a message to the relay */
-    next(message: any): void;
+    send(message: any): void;
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
     /** send and AUTH message */
-    auth(event: NostrEvent): Observable<PublishResponse>;
+    auth(event: NostrEvent): Promise<PublishResponse>;
     /** Authenticate with the relay using a signer */
-    authenticate(signer: AuthSigner): Observable<PublishResponse>;
+    authenticate(signer: AuthSigner): Promise<PublishResponse>;
+    /** Internal operator for creating the retry() operator */
+    protected customRetryOperator<T extends unknown = unknown>(times: number | RetryConfig): MonoTypeOperatorFunction<T>;
+    /** Internal operator for creating the repeat() operator */
+    protected customRepeatOperator<T extends unknown = unknown>(times: boolean | number | RepeatConfig | undefined): MonoTypeOperatorFunction<T>;
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
     /** Makes a single request that retires on errors and completes on EOSE */
     request(filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
     /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
-    publish(event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
+    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;
+    /** Force close the connection */
+    close(): void;
     /** Static method to fetch the NIP-11 information document for a relay */
     static fetchInformationDocument(url: string): Observable<RelayInformation | null>;
     /** Static method to create a reconnection method for each relay */

package/dist/relay.js

@@ -1,10 +1,10 @@
 import { logger } from "applesauce-core";
+import { ensureHttpURL } from "applesauce-core/helpers";
 import { simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { nip42 } from "nostr-tools";
-import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, from, ignoreElements, isObservable, map, merge, mergeMap, mergeWith, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, of, repeat, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
-import { ensureHttpURL } from "applesauce-core/helpers";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 /** An error that is thrown when a REQ is closed from the relay side */
@@ -47,6 +47,12 @@ export class Relay {
     _nip11 = null;
     /** An observable that emits the limitations for the relay */
     limitations$;
+    /** An observable that emits when underlying websocket is opened */
+    open$ = new Subject();
+    /** An observable that emits when underlying websocket is closed */
+    close$ = new Subject();
+    /** An observable that emits when underlying websocket is closing due to unsubscription */
+    closing$ = new Subject();
     // sync state
     get connected() {
         return this.connected$.value;
@@ -66,11 +72,11 @@ export class Relay {
     get information() {
         return this._nip11;
     }
-    /** If an EOSE message is not seen in this time, emit one locally  */
+    /** If an EOSE message is not seen in this time, emit one locally (default 10s)  */
     eoseTimeout = 10_000;
-    /** How long to wait for an OK message from the relay */
+    /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout = 10_000;
-    /** How long to keep the connection alive after nothing is subscribed */
+    /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive = 30_000;
     // Subjects that track if an "auth-required" message has been received for REQ or EVENT
     receivedAuthRequiredForReq = new BehaviorSubject(false);
@@ -96,32 +102,39 @@ export class Relay {
     constructor(url, opts) {
         this.url = url;
         this.log = this.log.extend(url);
+        // Set common options
+        if (opts?.eoseTimeout !== undefined)
+            this.eoseTimeout = opts.eoseTimeout;
+        if (opts?.eventTimeout !== undefined)
+            this.eventTimeout = opts.eventTimeout;
+        if (opts?.keepAlive !== undefined)
+            this.keepAlive = opts.keepAlive;
         // 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 */
         this.reconnectTimer = Relay.createReconnectTimer(url);
+        // Subscribe to open and close events
+        this.open$.subscribe(() => {
+            this.log("Connected");
+            this.connected$.next(true);
+            this.attempts$.next(0);
+            this.error$.next(null);
+            this.resetState();
+        });
+        this.close$.subscribe((event) => {
+            this.log("Disconnected");
+            this.connected$.next(false);
+            this.attempts$.next(this.attempts$.value + 1);
+            this.resetState();
+            // Start the reconnect timer if the connection was not closed cleanly
+            if (!event.wasClean)
+                this.startReconnectTimer(event);
+        });
         this.socket = webSocket({
             url,
-            openObserver: {
-                next: () => {
-                    this.log("Connected");
-                    this.connected$.next(true);
-                    this.attempts$.next(0);
-                    this.error$.next(null);
-                    this.resetState();
-                },
-            },
-            closeObserver: {
-                next: (event) => {
-                    this.log("Disconnected");
-                    this.connected$.next(false);
-                    this.attempts$.next(this.attempts$.value + 1);
-                    this.resetState();
-                    // Start the reconnect timer if the connection was not closed cleanly
-                    if (!event.wasClean)
-                        this.startReconnectTimer(event);
-                },
-            },
+            openObserver: this.open$,
+            closeObserver: this.close$,
+            closingObserver: this.closing$,
             WebSocketCtor: opts?.WebSocket,
         });
         // Create an observable to fetch the NIP-11 information document
@@ -200,7 +213,7 @@ export class Relay {
     }
     /** Wait for authentication state, make connection and then wait for authentication if required */
     waitForAuth(
-    // NOTE: require BehaviorSubject so it always has a value
+    // NOTE: require BehaviorSubject or shareReplay so it always has a value
     requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
         // Once the auth state is known, make a connection and watch for auth challenges
@@ -230,7 +243,7 @@ export class Relay {
         return this.socket.multiplex(open, close, filter);
     }
     /** Send a message to the relay */
-    next(message) {
+    send(message) {
         this.socket.next(message);
     }
     /** Create a REQ observable that emits events or "EOSE" or errors */
@@ -238,21 +251,26 @@ export class Relay {
         // Convert filters input into an observable, if its a normal value merge it with NEVER so it never completes
         const input = isObservable(filters) ? filters : merge(of(filters), NEVER);
         // Create an observable that completes when the upstream observable completes
-        const complete = input.pipe(ignoreElements(), endWith(null));
+        const filtersComplete = input.pipe(ignoreElements(), endWith(null));
         // Create an observable that filters responses from the relay to just the ones for this REQ
-        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "EVENT" || m[0] === "CLOSED" || m[0] === "EOSE") && m[1] === id));
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "EVENT" || m[0] === "CLOSED" || m[0] === "EOSE") && m[1] === id), 
+        // Singleton (prevents the .pipe() operator later from sending two REQ messages )
+        share());
         // Create an observable that controls sending the filters and closing the REQ
         const control = input.pipe(
         // Send the filters when they change
         tap((filters) => this.socket.next(Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters])), 
-        // Close the req when unsubscribed
+        // Send the CLOSE message when unsubscribed or input completes
         finalize(() => this.socket.next(["CLOSE", id])), 
         // Once filters have been sent, switch to listening for messages
         switchMap(() => messages));
         // Start the watch tower with the observables
         const observable = merge(this.watchTower, control).pipe(
+        // Complete the subscription when the control observable completes
+        // This is to work around the fact that merge() waits for both observables to complete
+        takeUntil(messages.pipe(ignoreElements(), endWith(true))), 
         // Complete the subscription when the input is completed
-        takeUntil(complete), 
+        takeUntil(filtersComplete), 
         // Map the messages to events, EOSE, or throw an error
         map((message) => {
             if (message[0] === "EOSE")
@@ -287,15 +305,20 @@ export class Relay {
     }
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
-        const base = defer(() => {
+        const messages = defer(() => {
             // Send event when subscription starts
             this.socket.next([verb, event]);
             return this.socket.pipe(filter((m) => m[0] === "OK" && m[1] === event.id), 
             // format OK message
             map((m) => ({ ok: m[2], message: m[3], from: this.url })));
-        });
+        }).pipe(
+        // Singleton (prevents the .pipe() operator later from sending two EVENT messages )
+        share());
         // Start the watch tower and add complete operators
-        const observable = merge(this.watchTower, base).pipe(
+        const observable = merge(this.watchTower, messages).pipe(
+        // Complete the subscription when the messages observable completes
+        // This is to work around the fact that merge() waits for both observables to complete
+        takeUntil(messages.pipe(ignoreElements(), endWith(true))), 
         // complete on first value
         take(1), 
         // listen for OK auth-required
@@ -320,9 +343,9 @@ export class Relay {
     }
     /** send and AUTH message */
     auth(event) {
-        return this.event(event, "AUTH").pipe(
+        return lastValueFrom(this.event(event, "AUTH").pipe(
         // update authenticated
-        tap((result) => this.authenticationResponse$.next(result)));
+        tap((result) => this.authenticationResponse$.next(result))));
     }
     /** Authenticate with the relay using a signer */
     authenticate(signer) {
@@ -330,32 +353,66 @@ export class Relay {
             throw new Error("Have not received authentication challenge");
         const p = signer.signEvent(nip42.makeAuthEvent(this.url, this.challenge));
         const start = p instanceof Promise ? from(p) : of(p);
-        return start.pipe(switchMap((event) => this.auth(event)));
+        return lastValueFrom(start.pipe(switchMap((event) => this.auth(event))));
+    }
+    /** Internal operator for creating the retry() operator */
+    customRetryOperator(times) {
+        if (typeof times === "number")
+            return retry(times);
+        else
+            return retry(times);
+    }
+    /** Internal operator for creating the repeat() operator */
+    customRepeatOperator(times) {
+        if (times === false || times === undefined)
+            return identity;
+        else if (times === true)
+            return repeat();
+        else if (typeof times === "number")
+            return repeat(times);
+        else
+            return repeat(times);
     }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
         // Retry on connection errors
-        retry({ count: opts?.retries ?? 3, resetOnSuccess: true }));
+        this.customRetryOperator(opts?.retries ?? 3), 
+        // Create reconnect logic (repeat operator)
+        this.customRepeatOperator(opts?.reconnect), 
+        // Single subscription
+        share());
     }
     /** Makes a single request that retires on errors and completes on EOSE */
     request(filters, opts) {
         return this.req(filters, opts?.id).pipe(
         // Retry on connection errors
-        retry(opts?.retries ?? 3), 
+        this.customRetryOperator(opts?.retries ?? 3), 
+        // Create reconnect logic (repeat operator)
+        this.customRepeatOperator(opts?.reconnect), 
         // Complete when EOSE is received
-        completeOnEose());
+        completeOnEose(), 
+        // Single subscription
+        share());
     }
     /** Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries ) */
     publish(event, opts) {
-        return this.event(event).pipe(mergeMap((result) => {
+        return lastValueFrom(this.event(event).pipe(mergeMap((result) => {
             // If the relay responds with auth-required, throw an error for the retry operator to handle
             if (result.ok === false && result.message?.startsWith("auth-required:"))
                 return throwError(() => new Error(result.message));
             return of(result);
         }), 
         // Retry the publish until it succeeds or the number of retries is reached
-        retry(opts?.retries ?? 3));
+        this.customRetryOperator(opts?.retries ?? 3), 
+        // Create reconnect logic (repeat operator)
+        this.customRepeatOperator(opts?.reconnect), 
+        // Single subscription
+        share()));
+    }
+    /** Force close the connection */
+    close() {
+        this.socket.unsubscribe();
     }
     /** Static method to fetch the NIP-11 information document for a relay */
     static fetchInformationDocument(url) {

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { type EventTemplate, type Filter, type NostrEvent } from "nostr-tools";
-import { Observable } from "rxjs";
+import { Observable, repeat, retry } from "rxjs";
 import { WebSocketSubject } from "rxjs/webSocket";
 export type SubscriptionResponse = NostrEvent | "EOSE";
 export type PublishResponse = {
@@ -8,99 +8,97 @@ export type PublishResponse = {
     from: string;
 };
 export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
-export interface IRelayState {
-    connected$: Observable<boolean>;
-    challenge$: Observable<string | null>;
-    authenticated$: Observable<boolean>;
-    notices$: Observable<string[]>;
-}
+/** Options for the publish method on the pool and relay */
 export type PublishOptions = {
-    retries?: number;
-};
-export type RequestOptions = {
-    id?: string;
-    retries?: number;
+    /**
+     * Number of times to retry the publish. default is 3
+     * @see https://rxjs.dev/api/index/function/retry
+     */
+    retries?: number | Parameters<typeof retry>[0];
+    /**
+     * Whether to reconnect when socket is closed. A number of times or true for infinite. default is false
+     * @see https://rxjs.dev/api/index/function/repeat
+     */
+    reconnect?: boolean | Parameters<typeof repeat>[0];
 };
+/** Options for the request method on the pool and relay */
+export type RequestOptions = SubscriptionOptions;
+/** Options for the subscription method on the pool and relay */
 export type SubscriptionOptions = {
+    /** Custom REQ id for the subscription */
     id?: string;
-    retries?: number;
+    /**
+     * Number of times to retry a request. default is 3
+     * @see https://rxjs.dev/api/index/function/retry
+     */
+    retries?: number | Parameters<typeof retry>[0];
+    /**
+     * Whether to reconnect when socket is closed. A number of times or true for infinite. default is false
+     * @see https://rxjs.dev/api/index/function/repeat
+     */
+    reconnect?: boolean | Parameters<typeof repeat>[0];
 };
 export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
 /** The type of input the REQ method accepts */
 export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]>;
-export interface Nip01Actions {
-    /** Send an EVENT message */
-    event(event: NostrEvent): Observable<PublishResponse>;
-    /** Send a REQ message */
-    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
-}
-export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
+export interface IRelay extends MultiplexWebSocket {
     url: string;
     message$: Observable<any>;
     notice$: Observable<string>;
+    connected$: Observable<boolean>;
+    challenge$: Observable<string | null>;
+    authenticated$: Observable<boolean>;
+    notices$: Observable<string[]>;
     readonly connected: boolean;
     readonly authenticated: boolean;
     readonly challenge: string | null;
     readonly notices: string[];
+    /** Force close the connection */
+    close(): void;
+    /** Send a REQ message */
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Send an EVENT message */
+    event(event: NostrEvent): Observable<PublishResponse>;
     /** Send an AUTH message */
-    auth(event: NostrEvent): Observable<{
-        ok: boolean;
-        message?: string;
-    }>;
+    auth(event: NostrEvent): Promise<PublishResponse>;
+    /** Authenticate with the relay using a signer */
+    authenticate(signer: AuthSigner): Promise<PublishResponse>;
     /** Send an EVENT message with retries */
-    publish(event: NostrEvent, opts?: {
-        retries?: number;
-    }): Observable<PublishResponse>;
+    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;
     /** Send a REQ message with retries */
-    request(filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }
-export interface IGroup extends Nip01Actions {
+export interface IGroup {
+    /** Send a REQ message */
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Send an EVENT message */
+    event(event: NostrEvent): Observable<PublishResponse>;
     /** Send an EVENT message with retries */
-    publish(event: NostrEvent, opts?: {
-        retries?: number;
-    }): Observable<PublishResponse>;
+    publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Send a REQ message with retries */
-    request(filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }
 export interface IPool {
-    /** Send an EVENT message */
-    event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
-    /** Send a REQ message */
-    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */
     group(relays: string[]): IGroup;
+    /** Removes a relay from the pool and defaults to closing the connection */
+    remove(relay: string | IRelay, close?: boolean): void;
+    /** Send a REQ message */
+    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Send an EVENT message */
+    event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Send an EVENT message to relays with retries */
-    publish(relays: string[], event: NostrEvent, opts?: {
-        retries?: number;
-    }): Observable<PublishResponse>;
+    publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Send a REQ message to relays with retries */
-    request(relays: string[], filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<NostrEvent>;
+    request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to relays with retries */
-    subscription(relays: string[], filters: FilterInput, opts?: {
-        id?: string;
-        retries?: number;
-    }): Observable<SubscriptionResponse>;
+    subscription(relays: string[], filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,14 +54,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^2.3.0",
+    "applesauce-core": "^3.0.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^2.0.0",
+    "applesauce-signers": "^3.0.0",
     "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.3",