applesauce-relay 6.0.2 → 6.2.0

package/dist/lib/negentropy.js

@@ -1,6 +1,6 @@
 // (C) 2023 Doug Hoyte. MIT license
 // Modified by hzrd149 to be TypeScript and work without the window.cyrpto.subtle API
-import { sha256 } from "@noble/hashes/sha2";
+import { sha256 } from "@noble/hashes/sha2.js";
 const PROTOCOL_VERSION = 0x61; // Version 1
 const ID_SIZE = 32;
 const FINGERPRINT_SIZE = 16;

package/dist/pool.d.ts

@@ -4,15 +4,18 @@ import { FilterMap, OutboxMap } from "applesauce-core/helpers/relay-selection";
 import { BehaviorSubject, Observable, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import type { NegentropySyncOptions, ReconcileFunction } from "./negentropy.js";
-import { Relay, SyncDirection, type RelayOptions } from "./relay.js";
-import type { RelayCountResponse, FilterInput, GroupReqOptions, GroupReqMessage, PoolRelayInput, NegentropyReadStore, NegentropySyncStore, PublishResponse, RelayStatus } from "./types.js";
+import { Relay, type RelayOptions, SyncDirection } from "./relay.js";
+import type { FilterInput, GroupReqMessage, GroupReqOptions, NegentropyReadStore, NegentropySyncStore, PoolRelayInput, PublishResponse, RelayCountResponse, RelayStatus } from "./types.js";
 export declare class RelayPool {
     options?: RelayOptions | undefined;
     relays$: BehaviorSubject<Map<string, Relay>>;
     get relays(): Map<string, Relay>;
     /** Observable of relay status for all relays in the pool */
     status$: Observable<Record<string, RelayStatus>>;
-    /** Whether to ignore relays that are ready=false */
+    /**
+     * Whether to ignore relays that are ready=false
+     * @deprecated use {@link ignoreUnhealthyRelays} in group() or request() input
+     */
     ignoreOffline: boolean;
     /** A signal when a relay is added */
     add$: Subject<Relay>;
@@ -25,6 +28,8 @@ export declare class RelayPool {
     group(relays: PoolRelayInput, ignoreOffline?: boolean): RelayGroup;
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay: string | Relay, close?: boolean): void;
+    /** Closes and removes every relay in the pool, tearing down all of their connections and timers */
+    close(): void;
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays: PoolRelayInput, filters: FilterInput, opts?: GroupReqOptions): Observable<GroupReqMessage>;
     /** Send an EVENT message to multiple relays */

package/dist/pool.js

@@ -1,7 +1,7 @@
 import { isFilterEqual } from "applesauce-core/helpers/filter";
 import { createFilterMap } from "applesauce-core/helpers/relay-selection";
 import { normalizeURL } from "applesauce-core/helpers/url";
-import { BehaviorSubject, distinctUntilChanged, isObservable, map, merge, of, scan, shareReplay, startWith, Subject, switchMap, } from "rxjs";
+import { BehaviorSubject, combineLatest, distinctUntilChanged, filter, isObservable, map, merge, of, scan, shareReplay, startWith, Subject, switchMap, take, } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
 export class RelayPool {
@@ -12,8 +12,11 @@ export class RelayPool {
     }
     /** Observable of relay status for all relays in the pool */
     status$;
-    /** Whether to ignore relays that are ready=false */
-    ignoreOffline = true;
+    /**
+     * Whether to ignore relays that are ready=false
+     * @deprecated use {@link ignoreUnhealthyRelays} in group() or request() input
+     */
+    ignoreOffline = false;
     /** A signal when a relay is added */
     add$ = new Subject();
     /** A signal when a relay is removed */
@@ -55,11 +58,17 @@ export class RelayPool {
             ? relays.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)));
+            // Convert input to an observable so it can react to relays becoming ready.
+            // Each relay is included once `ready$` first emits true, and stays included
+            // afterwards (subsequent ready=false changes are ignored since the request
+            // or subscription will have already started).
+            const input$ = Array.isArray(input) ? of(input) : input;
+            input = input$.pipe(switchMap((relays) => {
+                if (relays.length === 0)
+                    return of([]);
+                const signals = relays.map((relay) => relay.ready$.pipe(filter((ready) => ready), take(1), map(() => relay), startWith(null)));
+                return combineLatest(signals).pipe(map((arr) => arr.filter((r) => r !== null)));
+            }));
         }
         return new RelayGroup(input);
     }
@@ -82,19 +91,22 @@ export class RelayPool {
         this.relays$.next(this.relays);
         this.remove$.next(instance);
     }
+    /** Closes and removes every relay in the pool, tearing down all of their connections and timers */
+    close() {
+        for (const relay of [...this.relays.values()])
+            this.remove(relay, true);
+    }
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays, filters, opts) {
-        // Never filter out offline relays in manual methods
-        return this.group(relays, false).req(filters, opts);
+        return this.group(relays).req(filters, opts);
     }
     /** Send an EVENT message to multiple relays */
     event(relays, event) {
-        // Never filter out offline relays in manual methods
-        return this.group(relays, false).event(event);
+        return this.group(relays).event(event);
     }
     /** Negentropy sync event ids with the relays and an event store */
     negentropy(relays, store, filter, reconcile, opts) {
-        return this.group(relays, false).negentropy(store, filter, reconcile, opts);
+        return this.group(relays).negentropy(store, filter, reconcile, opts);
     }
     /** Publish an event to multiple relays */
     publish(relays, event, opts) {
@@ -134,10 +146,12 @@ export class RelayPool {
     }
     /** Count events on multiple relays */
     count(relays, filters, id) {
-        return this.group(relays).count(filters, id);
+        // Never filter out offline relays in manual methods
+        return this.group(relays, false).count(filters, id);
     }
     /** Negentropy sync events with the relays and an event store */
     sync(relays, store, filter, direction) {
-        return this.group(relays).sync(store, filter, direction);
+        // Never filter out offline relays in manual methods
+        return this.group(relays, false).sync(store, filter, direction);
     }
 }

package/dist/relay.d.ts

@@ -1,7 +1,7 @@
 import { logger } from "applesauce-core";
 import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { Filter } from "applesauce-core/helpers/filter";
-import { BehaviorSubject, MonoTypeOperatorFunction, Observable, RepeatConfig, RetryConfig, Subject } from "rxjs";
+import { BehaviorSubject, MonoTypeOperatorFunction, Observable, RepeatConfig, ReplaySubject, RetryConfig, Subject, Subscription } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { type NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
 import { AuthSigner, FilterInput, NegentropyReadStore, NegentropySyncStore, PublishOptions, PublishResponse, RelayCountResponse, RelayInformation, RelayReqMessage, RelayReqOptions, RelayRequestCompleteOperator, RelayRequestOptions, RelayRequestResponse, RelayStatus, RelaySubscriptionOptions, RelaySubscriptionResponse } from "./types.js";
@@ -149,6 +149,15 @@ export declare class Relay {
     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>;
+    /** Long-lived state-watcher subscriptions created in the constructor (open/close/auth) */
+    protected internalSubscriptions: Subscription;
+    /** The currently armed reconnect timer subscription, if any */
+    protected reconnectSubscription: Subscription | null;
+    /**
+     * Fires when the relay is closed. Used to cancel the watchTower's keepAlive reset timer.
+     * A ReplaySubject so a reset timer armed after close() is torn down immediately.
+     */
+    protected destroy$: ReplaySubject<void>;
     constructor(url: string, opts?: RelayOptions);
     /** Set ready = false and start the reconnect timer */
     protected startReconnectTimer(error: Error | CloseEvent): void;
@@ -192,7 +201,10 @@ export declare class Relay {
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse>;
     /** Negentropy sync events with the relay and an event store */
     sync(store: NegentropySyncStore, filters: Filter, direction?: SyncDirection): Observable<NostrEvent>;
-    /** Force close the connection */
+    /**
+     * Force close the connection and tear down all internal subscriptions and timers.
+     * @note This is a terminal operation; the relay should be discarded after calling it.
+     */
     close(): void;
     /** An async method that returns the NIP-11 information document for the relay */
     getInformation(): Promise<RelayInformation | null>;

package/dist/relay.js

@@ -4,7 +4,7 @@ import { ensureHttpURL } from "applesauce-core/helpers/url";
 import { mapEventsToStore, simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { makeAuthEvent } from "nostr-tools/nip42";
-import { BehaviorSubject, catchError, combineLatest, defer, EMPTY, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, takeWhile, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, EMPTY, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, ReplaySubject, retry, scan, share, shareReplay, startWith, Subject, Subscription, switchMap, take, takeUntil, takeWhile, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { completeWhen } from "./operators/complete-when.js";
 const AUTH_REQUIRED_PREFIX = "auth-required:";
@@ -210,6 +210,15 @@ export class Relay {
     }
     /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     watchTower;
+    /** Long-lived state-watcher subscriptions created in the constructor (open/close/auth) */
+    internalSubscriptions = new Subscription();
+    /** The currently armed reconnect timer subscription, if any */
+    reconnectSubscription = null;
+    /**
+     * Fires when the relay is closed. Used to cancel the watchTower's keepAlive reset timer.
+     * A ReplaySubject so a reset timer armed after close() is torn down immediately.
+     */
+    destroy$ = new ReplaySubject(1);
     constructor(url, opts) {
         this.url = url;
         this.log = this.log.extend(url);
@@ -239,15 +248,15 @@ export class Relay {
         /** 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.internalSubscriptions.add(this.open$.subscribe(() => {
             this.log("Connected");
             this.connected$.next(true);
             this.attempts$.next(0);
             this.error$.next(null);
             // Reset to clean state
             this.resetState();
-        });
-        this.close$.subscribe((event) => {
+        }));
+        this.internalSubscriptions.add(this.close$.subscribe((event) => {
             if (this.connected$.value)
                 this.log("Disconnected");
             else
@@ -262,7 +271,7 @@ export class Relay {
             // Start the reconnect timer if the connection was not closed cleanly
             if (!event.wasClean)
                 this.startReconnectTimer(event);
-        });
+        }));
         this.socket = webSocket({
             url,
             openObserver: this.open$,
@@ -288,12 +297,12 @@ export class Relay {
         this.authRequiredForRead$ = this.receivedAuthRequiredForReq;
         this.authRequiredForPublish$ = this.receivedAuthRequiredForEvent;
         // Log when auth is required
-        this.authRequiredForRead$
+        this.internalSubscriptions.add(this.authRequiredForRead$
             .pipe(filter((r) => r === true), take(1))
-            .subscribe(() => this.log("Auth required for REQ"));
-        this.authRequiredForPublish$
+            .subscribe(() => this.log("Auth required for REQ")));
+        this.internalSubscriptions.add(this.authRequiredForPublish$
             .pipe(filter((r) => r === true), take(1))
-            .subscribe(() => this.log("Auth required for EVENT"));
+            .subscribe(() => this.log("Auth required for EVENT")));
         // Create status$ observable by combining state observables
         this.status$ = combineLatest({
             url: of(this.url),
@@ -413,8 +422,8 @@ export class Relay {
                 this.startReconnectTimer(error instanceof Error ? error : new Error("Connection error"));
                 return NEVER;
             }), 
-            // Add keep alive timer to the connection
-            share({ resetOnRefCountZero: () => timer(this.keepAlive) }));
+            // Add keep alive timer to the connection, cancelled when the relay is closed
+            share({ resetOnRefCountZero: () => timer(this.keepAlive).pipe(takeUntil(this.destroy$)) }));
         }), 
         // There should only be a single watch tower
         share());
@@ -425,9 +434,12 @@ export class Relay {
             return;
         this.error$.next(error instanceof Error ? error : new Error("Connection error"));
         this._ready$.next(false);
-        this.reconnectTimer(error, this.attempts$.value)
+        // Cancel any previously armed reconnect timer before arming a new one
+        this.reconnectSubscription?.unsubscribe();
+        this.reconnectSubscription = this.reconnectTimer(error, this.attempts$.value)
             .pipe(take(1))
             .subscribe(() => {
+            this.reconnectSubscription = null;
             this._ready$.next(true);
         });
     }
@@ -826,8 +838,14 @@ export class Relay {
                 // Send missing events to the relay
                 if (direction & SyncDirection.SEND && have.length > 0) {
                     const events = await getEvents(have);
-                    // Send all events to the relay
-                    await Promise.allSettled(events.map((event) => lastValueFrom(this.event(event))));
+                    // Send all events to the relay, marking them as seen on this relay once accepted.
+                    // The events were not fetched from the relay, but after a successful publish the relay has them.
+                    await Promise.allSettled(events.map(async (event) => {
+                        const response = await lastValueFrom(this.event(event));
+                        if (response.ok)
+                            addSeenRelay(event, this.url);
+                        return response;
+                    }));
                 }
                 // Fetch missing events from the relay
                 if (direction & SyncDirection.RECEIVE && need.length > 0) {
@@ -862,8 +880,23 @@ export class Relay {
         // Only create one upstream subscription
         share());
     }
-    /** Force close the connection */
+    /**
+     * Force close the connection and tear down all internal subscriptions and timers.
+     * @note This is a terminal operation; the relay should be discarded after calling it.
+     */
     close() {
+        // Cancel the watchTower's keepAlive reset timer armed at refcount-zero (and any future one)
+        this.destroy$.next();
+        this.destroy$.complete();
+        // Cancel any pending reconnect timer so it cannot fire (or hold the event loop open) after close
+        this.reconnectSubscription?.unsubscribe();
+        this.reconnectSubscription = null;
+        // Tear down the constructor state watchers (open/close/auth)
+        this.internalSubscriptions.unsubscribe();
+        // Mark as disconnected since the close$ watcher has been torn down
+        if (this.connected$.value)
+            this.connected$.next(false);
+        // Finally close the underlying socket
         this.socket.unsubscribe();
     }
     /** An async method that returns the NIP-11 information document for the relay */

package/package.json

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