applesauce-relay 0.0.0-next-20250610194602 → 0.0.0-next-20250716144720

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

@@ -22,7 +22,7 @@ export declare class RelayPool implements IPool {
     /** 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/relay.d.ts

@@ -24,8 +24,10 @@ export declare class Relay implements IRelay {
     connected$: BehaviorSubject<boolean>;
     /** The authentication challenge string from the relay */
     challenge$: BehaviorSubject<string | null>;
-    /** Whether the client is authenticated with the relay */
-    authenticated$: BehaviorSubject<boolean>;
+    /** Boolean authentication state (will be false if auth failed) */
+    authenticated$: Observable<boolean>;
+    /** The response to the last AUTH message sent to the relay */
+    authenticationResponse$: BehaviorSubject<PublishResponse | null>;
     /** The notices from the relay */
     notices$: BehaviorSubject<string[]>;
     /** The last connection error */
@@ -49,6 +51,7 @@ export declare class Relay implements IRelay {
     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  */
     eoseTimeout: number;
@@ -58,8 +61,8 @@ export declare class Relay implements IRelay {
     keepAlive: number;
     protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
     protected receivedAuthRequiredForEvent: BehaviorSubject<boolean>;
-    protected authRequiredForReq: Observable<boolean>;
-    protected authRequiredForEvent: Observable<boolean>;
+    authRequiredForRead$: Observable<boolean>;
+    authRequiredForPublish$: Observable<boolean>;
     protected resetState(): void;
     /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     protected watchTower: Observable<never>;
@@ -72,21 +75,21 @@ 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>;
     /** 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>;
     /** 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

@@ -2,8 +2,9 @@ import { logger } from "applesauce-core";
 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, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, of, 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 */
@@ -23,8 +24,10 @@ export class Relay {
     connected$ = new BehaviorSubject(false);
     /** The authentication challenge string from the relay */
     challenge$ = new BehaviorSubject(null);
-    /** Whether the client is authenticated with the relay */
-    authenticated$ = new BehaviorSubject(false);
+    /** Boolean authentication state (will be false if auth failed) */
+    authenticated$;
+    /** The response to the last AUTH message sent to the relay */
+    authenticationResponse$ = new BehaviorSubject(null);
     /** The notices from the relay */
     notices$ = new BehaviorSubject([]);
     /** The last connection error */
@@ -55,7 +58,10 @@ export class Relay {
         return this.notices$.value;
     }
     get authenticated() {
-        return this.authenticated$.value;
+        return this.authenticationResponse?.ok === true;
+    }
+    get authenticationResponse() {
+        return this.authenticationResponse$.value;
     }
     get information() {
         return this._nip11;
@@ -66,18 +72,18 @@ export class Relay {
     eventTimeout = 10_000;
     /** How long to keep the connection alive after nothing is subscribed */
     keepAlive = 30_000;
-    // subjects that track if an "auth-required" message has been received for REQ or EVENT
+    // Subjects that track if an "auth-required" message has been received for REQ or EVENT
     receivedAuthRequiredForReq = new BehaviorSubject(false);
     receivedAuthRequiredForEvent = new BehaviorSubject(false);
     // Computed observables that track if auth is required for REQ or EVENT
-    authRequiredForReq;
-    authRequiredForEvent;
+    authRequiredForRead$;
+    authRequiredForPublish$;
     resetState() {
         // NOTE: only update the values if they need to be changed, otherwise this will cause an infinite loop
         if (this.challenge$.value !== null)
             this.challenge$.next(null);
-        if (this.authenticated$.value)
-            this.authenticated$.next(false);
+        if (this.authenticationResponse$.value)
+            this.authenticationResponse$.next(null);
         if (this.notices$.value.length > 0)
             this.notices$.next([]);
         if (this.receivedAuthRequiredForReq.value)
@@ -90,6 +96,8 @@ export class Relay {
     constructor(url, opts) {
         this.url = url;
         this.log = this.log.extend(url);
+        // 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);
         this.socket = webSocket({
@@ -129,8 +137,8 @@ export class Relay {
         tap((info) => (this._nip11 = info)));
         this.limitations$ = this.information$.pipe(map((info) => info?.limitation));
         // Create observables that track if auth is required for REQ or EVENT
-        this.authRequiredForReq = combineLatest([this.receivedAuthRequiredForReq, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for REQ")), shareReplay(1));
-        this.authRequiredForEvent = combineLatest([this.receivedAuthRequiredForEvent, this.limitations$]).pipe(map(([received, limitations]) => received || limitations?.auth_required === true), tap((required) => required && this.log("Auth required for EVENT")), shareReplay(1));
+        this.authRequiredForRead$ = this.receivedAuthRequiredForReq.pipe(tap((required) => required && this.log("Auth required for REQ")), shareReplay(1));
+        this.authRequiredForPublish$ = this.receivedAuthRequiredForEvent.pipe(tap((required) => required && this.log("Auth required for EVENT")), shareReplay(1));
         // Update the notices state
         const listenForNotice = this.socket.pipe(
         // listen for NOTICE messages
@@ -222,7 +230,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 */
@@ -275,7 +283,7 @@ export class Relay {
         // Only create one upstream subscription
         share());
         // Wait for auth if required and make sure to start the watch tower
-        return this.waitForReady(this.waitForAuth(this.authRequiredForReq, observable));
+        return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable));
     }
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
@@ -308,13 +316,13 @@ export class Relay {
         if (verb === "AUTH")
             return this.waitForReady(observable);
         else
-            return this.waitForReady(this.waitForAuth(this.authRequiredForEvent, observable));
+            return this.waitForReady(this.waitForAuth(this.authRequiredForPublish$, observable));
     }
     /** send and AUTH message */
     auth(event) {
-        return this.event(event, "AUTH").pipe(
+        return lastValueFrom(this.event(event, "AUTH").pipe(
         // update authenticated
-        tap((result) => this.authenticated$.next(result.ok)));
+        tap((result) => this.authenticationResponse$.next(result))));
     }
     /** Authenticate with the relay using a signer */
     authenticate(signer) {
@@ -322,7 +330,7 @@ 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))));
     }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
@@ -340,18 +348,18 @@ export class Relay {
     }
     /** 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));
+        retry(opts?.retries ?? 3)));
     }
     /** Static method to fetch the NIP-11 information document for a relay */
     static fetchInformationDocument(url) {
-        return from(fetch(url, { headers: { Accept: "application/nostr+json" } }).then((res) => res.json())).pipe(
+        return from(fetch(ensureHttpURL(url), { headers: { Accept: "application/nostr+json" } }).then((res) => res.json())).pipe(
         // if the fetch fails, return null
         catchError(() => of(null)), 
         // timeout after 10s

package/dist/types.d.ts

@@ -8,12 +8,6 @@ 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[]>;
-}
 export type PublishOptions = {
     retries?: number;
 };
@@ -30,29 +24,30 @@ export type AuthSigner = {
 };
 /** 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[];
+    /** 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>;
+    }): Promise<PublishResponse>;
     /** Send a REQ message with retries */
     request(filters: FilterInput, opts?: {
         id?: string;
@@ -64,11 +59,15 @@ export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
         retries?: number;
     }): 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>;
+    }): Promise<PublishResponse[]>;
     /** Send a REQ message with retries */
     request(filters: FilterInput, opts?: {
         id?: string;
@@ -81,18 +80,18 @@ export interface IGroup extends Nip01Actions {
     }): 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;
+    /** 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>;
+    }): Promise<PublishResponse[]>;
     /** Send a REQ message to relays with retries */
     request(relays: string[], filters: FilterInput, opts?: {
         id?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250610194602",
+  "version": "0.0.0-next-20250716144720",
   "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": "0.0.0-next-20250610194602",
+    "applesauce-core": "^2.3.0",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "0.0.0-next-20250610194602",
+    "applesauce-signers": "^2.0.0",
     "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
     "vitest": "^3.2.3",