applesauce-relay 4.0.0 → 4.1.0

package/README.md

@@ -10,16 +10,15 @@ npm install applesauce-relay
 
 ## Features
 
-- [x] NIP-01
+- [x] NIP-01 `REQ` and `EVENT` messages
 - [x] Relay pool and groups
-- [x] Fetch NIP-11 information before connecting
 - [x] NIP-11 `auth_required` limitation
 - [ ] NIP-11 `max_subscriptions` limitation
 - [x] Client negentropy sync
 - [x] Reconnection backoff logic
 - [x] republish event on reconnect and auth-required
 - [x] Resubscribe on reconnect and auth-required
-- [ ] NIP-45 COUNT
+- [x] NIP-45 COUNT
 
 ## Examples
 

package/dist/group.d.ts

@@ -2,7 +2,7 @@ import { Filter, type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreActions, IEventStoreRead } from "applesauce-core";
 import { NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
-import { FilterInput, IGroup, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { CountResponse, FilterInput, IGroup, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 import { SyncDirection } from "./relay.js";
 /** Options for negentropy sync on a group of relays */
 export type GroupNegentropySyncOptions = NegentropySyncOptions & {
@@ -28,7 +28,10 @@ export declare class RelayGroup implements IGroup {
      * Make a request to all relays
      * @note This does not deduplicate events
      */
-    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string, opts?: {
+        /** Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication */
+        eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
+    }): Observable<SubscriptionResponse>;
     /** Send an event to all relays */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Negentropy sync events with the relays and an event store */
@@ -39,6 +42,8 @@ export declare class RelayGroup implements IGroup {
     request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */
     subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Count events on all relays in the group */
+    count(filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relays and an event store */
     sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/dist/group.js

@@ -1,5 +1,5 @@
 import { nanoid } from "nanoid";
-import { catchError, defer, EMPTY, endWith, identity, ignoreElements, merge, of, share, switchMap, } from "rxjs";
+import { catchError, combineLatest, defer, EMPTY, endWith, identity, ignoreElements, merge, of, share, switchMap, } from "rxjs";
 import { EventMemory, filterDuplicateEvents, } from "applesauce-core";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { onlyEvents } from "./operators/only-events.js";
@@ -28,12 +28,12 @@ export class RelayGroup {
      * Make a request to all relays
      * @note This does not deduplicate events
      */
-    req(filters, id = nanoid(8)) {
+    req(filters, id = nanoid(), opts) {
         const requests = this.relays.map((relay) => relay.req(filters, id).pipe(
         // Ignore connection errors
         catchError(() => of("EOSE"))));
         // Merge events and the single EOSE stream
-        return this.mergeEOSE(requests);
+        return this.mergeEOSE(requests, opts?.eventStore);
     }
     /** Send an event to all relays */
     event(event) {
@@ -77,6 +77,10 @@ export class RelayGroup {
         // Pass event store so that duplicate events are removed
         opts?.eventStore);
     }
+    /** Count events on all relays in the group */
+    count(filters, id = nanoid()) {
+        return combineLatest(Object.fromEntries(this.relays.map((relay) => [relay.url, relay.count(filters, id)])));
+    }
     /** Negentropy sync events with the relays and an event store */
     sync(store, filter, direction) {
         // Get an array of relays that support NIP-77 negentropy sync

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/liveness.d.ts

@@ -0,0 +1,123 @@
+import { Observable } from "rxjs";
+import { IPool } from "./types.js";
+/** Relay health states for liveness tracking */
+export type RelayHealthState = "online" | "offline" | "dead";
+/** State information for a relay's health tracking */
+export interface RelayState {
+    /** Current relay health state */
+    state: RelayHealthState;
+    /** Number of consecutive failures */
+    failureCount: number;
+    /** Timestamp of last failure */
+    lastFailureTime: number;
+    /** Timestamp of last success */
+    lastSuccessTime: number;
+    /** When the backoff period ends (timestamp) */
+    backoffUntil?: number;
+}
+/** Storage adapter interface for persisting relay liveness state */
+export interface LivenessStorage {
+    /**
+     * Get an item from storage
+     * @param key The storage key
+     * @returns The stored value or null if not found
+     */
+    getItem(key: string): Promise<any> | any;
+    /**
+     * Set an item in storage
+     * @param key The storage key
+     * @param value The value to store
+     */
+    setItem(key: string, value: any): Promise<void> | void;
+}
+/** Configuration options for RelayLiveness */
+export interface LivenessOptions {
+    /** Optional async storage adapter for persistence */
+    storage?: LivenessStorage;
+    /** Maximum failures before moving from offline to dead */
+    maxFailuresBeforeDead?: number;
+    /** Base delay for exponential backoff (ms) */
+    backoffBaseDelay?: number;
+    /** Maximum backoff delay (ms) */
+    backoffMaxDelay?: number;
+}
+/** Record and manage liveness reports for relays */
+export declare class RelayLiveness {
+    private log;
+    private readonly options;
+    private readonly states$;
+    /** Relays that have been seen this session. this should be used when checking dead relays for liveness */
+    readonly seen: Set<string>;
+    /** Storage adapter for persistence */
+    readonly storage?: LivenessStorage;
+    /** An observable of all relays that are online */
+    online$: Observable<string[]>;
+    /** An observable of all relays that are offline */
+    offline$: Observable<string[]>;
+    /** An observable of all relays that are dead */
+    dead$: Observable<string[]>;
+    /** An observable of all relays that are online or not in backoff */
+    healthy$: Observable<string[]>;
+    /** An observable of all relays that are dead or in backoff */
+    unhealthy$: Observable<string[]>;
+    /** Relays that are known to be online */
+    get online(): string[];
+    /** Relays that are known to be offline */
+    get offline(): string[];
+    /** Relays that are known to be dead */
+    get dead(): string[];
+    /** Relays that are online or not in backoff */
+    get healthy(): string[];
+    /** Relays that are dead or in backoff */
+    get unhealthy(): string[];
+    /**
+     * Create a new RelayLiveness instance
+     * @param options Configuration options for the liveness tracker
+     */
+    constructor(options?: LivenessOptions);
+    /** Load relay states from storage */
+    load(): Promise<void>;
+    /** Save all known relays and their states to storage */
+    save(): Promise<void>;
+    /** Filter relay list, removing dead relays and relays in backoff */
+    filter(relays: string[]): string[];
+    /** Subscribe to a relays state */
+    state(relay: string): Observable<RelayState | undefined>;
+    /** Revive a dead relay with the max backoff delay */
+    revive(relay: string): void;
+    /** Get current relay health state for a relay */
+    getState(relay: string): RelayState | undefined;
+    /** Check if a relay is currently in backoff period */
+    isInBackoff(relay: string): boolean;
+    /** Get remaining backoff time for a relay (in ms) */
+    getBackoffRemaining(relay: string): number;
+    /** Calculate backoff delay based on failure count */
+    private calculateBackoffDelay;
+    /**
+     * Record a successful connection
+     * @param relay The relay URL that succeeded
+     */
+    recordSuccess(relay: string): void;
+    /**
+     * Record a failed connection
+     * @param relay The relay URL that failed
+     */
+    recordFailure(relay: string): void;
+    /**
+     * Get all seen relays (for debugging/monitoring)
+     */
+    getSeenRelays(): string[];
+    /**
+     * Reset state for one or all relays
+     * @param relay Optional specific relay URL to reset, or reset all if not provided
+     */
+    reset(relay?: string): void;
+    private connections;
+    /** Connect to a {@link RelayPool} instance and track relay connections */
+    connectToPool(pool: IPool): void;
+    /** Disconnect from a {@link RelayPool} instance */
+    disconnectFromPool(pool: IPool): void;
+    private updateRelayState;
+    private saveKnownRelays;
+    private saveRelayState;
+}

package/dist/liveness.js

@@ -0,0 +1,327 @@
+import { logger } from "applesauce-core";
+import { BehaviorSubject, map } from "rxjs";
+/** Record and manage liveness reports for relays */
+export class RelayLiveness {
+    log = logger.extend("RelayLiveness");
+    options;
+    states$ = new BehaviorSubject({});
+    /** Relays that have been seen this session. this should be used when checking dead relays for liveness */
+    seen = new Set();
+    /** Storage adapter for persistence */
+    storage;
+    /** An observable of all relays that are online */
+    online$;
+    /** An observable of all relays that are offline */
+    offline$;
+    /** An observable of all relays that are dead */
+    dead$;
+    /** An observable of all relays that are online or not in backoff */
+    healthy$;
+    /** An observable of all relays that are dead or in backoff */
+    unhealthy$;
+    /** Relays that are known to be online */
+    get online() {
+        return Object.keys(this.states$.value).filter((relay) => this.states$.value[relay].state === "online");
+    }
+    /** Relays that are known to be offline */
+    get offline() {
+        return Object.keys(this.states$.value).filter((relay) => this.states$.value[relay].state === "offline");
+    }
+    /** Relays that are known to be dead */
+    get dead() {
+        return Object.keys(this.states$.value).filter((relay) => this.states$.value[relay].state === "dead");
+    }
+    /** Relays that are online or not in backoff */
+    get healthy() {
+        return Object.keys(this.states$.value).filter((relay) => {
+            const state = this.states$.value[relay];
+            return state.state === "online" || (state.state === "offline" && !this.isInBackoff(relay));
+        });
+    }
+    /** Relays that are dead or in backoff */
+    get unhealthy() {
+        return Object.keys(this.states$.value).filter((relay) => {
+            const state = this.states$.value[relay];
+            return state.state === "dead" || (state.state === "offline" && this.isInBackoff(relay));
+        });
+    }
+    /**
+     * Create a new RelayLiveness instance
+     * @param options Configuration options for the liveness tracker
+     */
+    constructor(options = {}) {
+        this.options = {
+            maxFailuresBeforeDead: options.maxFailuresBeforeDead ?? 5,
+            backoffBaseDelay: options.backoffBaseDelay ?? 30 * 1000, // 30 seconds
+            backoffMaxDelay: options.backoffMaxDelay ?? 5 * 60 * 1000, // 5 minutes
+        };
+        this.storage = options.storage;
+        // Create observable interfaces
+        this.online$ = this.states$.pipe(map((states) => Object.keys(states).filter((relay) => states[relay].state === "online")));
+        this.offline$ = this.states$.pipe(map((states) => Object.keys(states).filter((relay) => states[relay].state === "offline")));
+        this.dead$ = this.states$.pipe(map((states) => Object.keys(states).filter((relay) => states[relay].state === "dead")));
+        this.healthy$ = this.states$.pipe(map((states) => Object.keys(states).filter((relay) => {
+            const state = states[relay];
+            return state.state === "online" || (state.state === "offline" && !this.isInBackoff(relay));
+        })));
+        this.unhealthy$ = this.states$.pipe(map((states) => Object.keys(states).filter((relay) => {
+            const state = states[relay];
+            return state.state === "dead" || (state.state === "offline" && this.isInBackoff(relay));
+        })));
+    }
+    /** Load relay states from storage */
+    async load() {
+        if (!this.storage)
+            return;
+        const known = await this.storage.getItem("known");
+        if (!Array.isArray(known))
+            return;
+        this.log(`Loading states for ${known.length} known relays`);
+        const states = {};
+        for (const relay of known) {
+            try {
+                const state = await this.storage.getItem(relay);
+                if (state)
+                    states[relay] = state;
+            }
+            catch (error) {
+                // Ignore relay loading errors
+            }
+        }
+        this.states$.next(states);
+    }
+    /** Save all known relays and their states to storage */
+    async save() {
+        await this.saveKnownRelays();
+        await Promise.all(Object.entries(this.states$.value).map(([relay, state]) => this.saveRelayState(relay, state)));
+        this.log("Relay states saved to storage");
+    }
+    /** Filter relay list, removing dead relays and relays in backoff */
+    filter(relays) {
+        const results = [];
+        for (const relay of relays) {
+            // Track that this relay has been seen
+            this.seen.add(relay);
+            const state = this.getState(relay);
+            // Filter based on state and backoff
+            switch (state?.state) {
+                case undefined: // unknown state
+                case "online":
+                    results.push(relay);
+                    break;
+                case "offline":
+                    // Only include if not in backoff
+                    if (!this.isInBackoff(relay))
+                        results.push(relay);
+                    break;
+                case "dead":
+                default:
+                    // Don't include dead relays
+                    break;
+            }
+        }
+        return results;
+    }
+    /** Subscribe to a relays state */
+    state(relay) {
+        return this.states$.pipe(map((states) => states[relay]));
+    }
+    /** Revive a dead relay with the max backoff delay */
+    revive(relay) {
+        const state = this.getState(relay);
+        if (!state)
+            return;
+        this.updateRelayState(relay, {
+            state: "offline",
+            failureCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: Date.now(),
+            backoffUntil: this.options.backoffMaxDelay,
+        });
+        this.log(`Relay ${relay} revived to offline state with max backoff delay`);
+    }
+    /** Get current relay health state for a relay */
+    getState(relay) {
+        return this.states$.value[relay];
+    }
+    /** Check if a relay is currently in backoff period */
+    isInBackoff(relay) {
+        const state = this.getState(relay);
+        if (!state?.backoffUntil)
+            return false;
+        return Date.now() < state.backoffUntil;
+    }
+    /** Get remaining backoff time for a relay (in ms) */
+    getBackoffRemaining(relay) {
+        const state = this.getState(relay);
+        if (!state?.backoffUntil)
+            return 0;
+        return Math.max(0, state.backoffUntil - Date.now());
+    }
+    /** Calculate backoff delay based on failure count */
+    calculateBackoffDelay(failureCount) {
+        const delay = this.options.backoffBaseDelay * Math.pow(2, failureCount - 1);
+        return Math.min(delay, this.options.backoffMaxDelay);
+    }
+    /**
+     * Record a successful connection
+     * @param relay The relay URL that succeeded
+     */
+    recordSuccess(relay) {
+        const now = Date.now();
+        const state = this.getState(relay);
+        // Don't update dead relays
+        if (state?.state === "dead") {
+            this.log(`Ignoring success for dead relay ${relay}`);
+            return;
+        }
+        // Record new relays
+        if (state === undefined) {
+            this.seen.add(relay);
+            this.saveKnownRelays();
+        }
+        // TODO: resetting the state back to online might be too aggressive?
+        const newState = {
+            state: "online",
+            failureCount: 0,
+            lastFailureTime: 0,
+            lastSuccessTime: now,
+        };
+        this.updateRelayState(relay, newState);
+        // Log transition if it's not the first time we've seen the relay
+        if (state && state.state !== newState.state)
+            this.log(`Relay ${relay} transitioned ${state?.state} -> online`);
+    }
+    /**
+     * Record a failed connection
+     * @param relay The relay URL that failed
+     */
+    recordFailure(relay) {
+        const state = this.getState(relay);
+        // Don't update dead relays
+        if (state?.state === "dead")
+            return;
+        // Ignore failures during backoff, this should help catch double reporting of failures
+        if (this.isInBackoff(relay))
+            return;
+        const now = Date.now();
+        const failureCount = (state?.failureCount || 0) + 1;
+        // Record new relays
+        if (state === undefined) {
+            this.seen.add(relay);
+            this.saveKnownRelays();
+        }
+        // Calculate backoff delay
+        const backoffDelay = this.calculateBackoffDelay(failureCount);
+        const newState = failureCount >= this.options.maxFailuresBeforeDead ? "dead" : "offline";
+        const relayState = {
+            state: newState,
+            failureCount,
+            lastFailureTime: now,
+            lastSuccessTime: state?.lastSuccessTime || 0,
+            backoffUntil: now + backoffDelay,
+        };
+        this.updateRelayState(relay, relayState);
+        // Log transition if it's not the first time we've seen the relay
+        if (newState !== state?.state)
+            this.log(`Relay ${relay} transitioned ${state?.state} -> ${newState}`);
+        // Set a timeout that will clear the backoff period
+        setTimeout(() => {
+            const state = this.getState(relay);
+            if (!state || state.backoffUntil === undefined)
+                return;
+            this.updateRelayState(relay, { ...state, backoffUntil: undefined });
+        }, backoffDelay);
+    }
+    /**
+     * Get all seen relays (for debugging/monitoring)
+     */
+    getSeenRelays() {
+        return Array.from(this.seen);
+    }
+    /**
+     * Reset state for one or all relays
+     * @param relay Optional specific relay URL to reset, or reset all if not provided
+     */
+    reset(relay) {
+        if (relay) {
+            const newStates = { ...this.states$.value };
+            delete newStates[relay];
+            this.states$.next(newStates);
+            this.seen.delete(relay);
+        }
+        else {
+            // Reset all relays
+            this.states$.next({});
+            this.seen.clear();
+        }
+    }
+    // The connected pools and cleanup methods
+    connections = new Map();
+    /** Connect to a {@link RelayPool} instance and track relay connections */
+    connectToPool(pool) {
+        // Relay cleanup methods
+        const relays = new Map();
+        // Listen for relays being added
+        const add = pool.add$.subscribe((relay) => {
+            // Record seen relays
+            this.seen.add(relay.url);
+            const open = relay.open$.subscribe(() => {
+                this.recordSuccess(relay.url);
+            });
+            const close = relay.close$.subscribe((event) => {
+                if (event.wasClean === false)
+                    this.recordFailure(relay.url);
+            });
+            // Register the cleanup method
+            relays.set(relay, () => {
+                open.unsubscribe();
+                close.unsubscribe();
+            });
+        });
+        // Listen for relays being removed
+        const remove = pool.remove$.subscribe((relay) => {
+            const cleanup = relays.get(relay);
+            if (cleanup)
+                cleanup();
+            relays.delete(relay);
+        });
+        // register the cleanup method
+        this.connections.set(pool, () => {
+            add.unsubscribe();
+            remove.unsubscribe();
+        });
+    }
+    /** Disconnect from a {@link RelayPool} instance */
+    disconnectFromPool(pool) {
+        const cleanup = this.connections.get(pool);
+        if (cleanup)
+            cleanup();
+        this.connections.delete(pool);
+    }
+    updateRelayState(relay, state) {
+        this.states$.next({ ...this.states$.value, [relay]: state });
+        // Auto-save to storage
+        this.saveRelayState(relay, state);
+    }
+    async saveKnownRelays() {
+        if (!this.storage)
+            return;
+        try {
+            await this.storage.setItem("known", Object.keys(this.states$.value));
+        }
+        catch (error) {
+            // Ignore storage errors
+        }
+    }
+    async saveRelayState(relay, state) {
+        if (!this.storage)
+            return;
+        try {
+            await this.storage.setItem(relay, state);
+        }
+        catch (error) {
+            // Ignore storage errors
+        }
+    }
+}

package/dist/operators/index.d.ts

@@ -3,3 +3,4 @@ export * from "./mark-from-relay.js";
 export * from "./only-events.js";
 export * from "./store-events.js";
 export * from "./to-event-store.js";
+export * from "./liveness.js";

package/dist/operators/index.js

@@ -3,3 +3,4 @@ export * from "./mark-from-relay.js";
 export * from "./only-events.js";
 export * from "./store-events.js";
 export * from "./to-event-store.js";
+export * from "./liveness.js";

package/dist/operators/liveness.d.ts

@@ -0,0 +1,17 @@
+import { MonoTypeOperatorFunction, Observable } from "rxjs";
+type ILivenessTracker = {
+    unhealthy$: Observable<string[]>;
+    seen?: Set<string>;
+};
+/** Filters out unhealthy relays from an array of pointers */
+export declare function ignoreUnhealthyRelaysOnPointers<T extends {
+    relays?: string[];
+}, Tracker extends ILivenessTracker>(liveness: Tracker): MonoTypeOperatorFunction<T[]>;
+/** Filters out unhealthy relays from the inboxes and outboxes */
+export declare function ignoreUnhealthyMailboxes<T extends {
+    inboxes?: string[];
+    outboxes?: string[];
+}, Tracker extends ILivenessTracker>(liveness: Tracker): MonoTypeOperatorFunction<T>;
+/** Filters out unhealthy relays from an array of relays */
+export declare function ignoreUnhealthyRelays<Tracker extends ILivenessTracker>(liveness: Tracker): MonoTypeOperatorFunction<string[]>;
+export {};

package/dist/operators/liveness.js

@@ -0,0 +1,47 @@
+import { combineLatestWith, map } from "rxjs";
+function filterRelays(relays, unhealthy, liveness) {
+    return (relays &&
+        relays.filter((relay) => {
+            // Notify the liveness tracker that we've seen this relay
+            liveness.seen?.add(relay);
+            // Exclude unhealthy relays
+            return !unhealthy.includes(relay);
+        }));
+}
+/** Filters out unhealthy relays from an array of pointers */
+export function ignoreUnhealthyRelaysOnPointers(liveness) {
+    return (source) => source.pipe(
+    // Combine with the liveness observable
+    combineLatestWith(liveness.unhealthy$), 
+    // Filters out unhealthy relays from the pointers
+    map(([pointers, unhealthy]) => pointers.map((pointer) => {
+        if (!pointer.relays)
+            return pointer;
+        // Exclude unhealthy relays
+        return { ...pointer, relays: filterRelays(pointer.relays, unhealthy, liveness) };
+    })));
+}
+/** Filters out unhealthy relays from the inboxes and outboxes */
+export function ignoreUnhealthyMailboxes(liveness) {
+    return (source) => source.pipe(
+    // Combine with the liveness observable
+    combineLatestWith(liveness.unhealthy$), 
+    // Filters out unhealthy relays from the inboxes and outboxes
+    map(([mailboxes, unhealthy]) => {
+        if (!mailboxes.inboxes && !mailboxes.outboxes)
+            return mailboxes;
+        return {
+            ...mailboxes,
+            inboxes: filterRelays(mailboxes.inboxes, unhealthy, liveness),
+            outboxes: filterRelays(mailboxes.outboxes, unhealthy, liveness),
+        };
+    }));
+}
+/** Filters out unhealthy relays from an array of relays */
+export function ignoreUnhealthyRelays(liveness) {
+    return (source) => source.pipe(
+    // Combine with the liveness observable
+    combineLatestWith(liveness.unhealthy$), 
+    // Filters out unhealthy relays from the array
+    map(([relays, unhealthy]) => filterRelays(relays, unhealthy, liveness)));
+}

package/dist/pool.d.ts

@@ -4,7 +4,7 @@ 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 { FilterInput, IPool, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
+import type { CountResponse, FilterInput, IPool, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     groups$: BehaviorSubject<Map<string, RelayGroup>>;
@@ -37,6 +37,8 @@ export declare class RelayPool implements IPool {
     request(relays: string[], filters: Parameters<RelayGroup["request"]>[0], opts?: Parameters<RelayGroup["request"]>[1]): Observable<NostrEvent>;
     /** Open a subscription to multiple relays */
     subscription(relays: string[], filters: Parameters<RelayGroup["subscription"]>[0], options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** Count events on multiple relays */
+    count(relays: string[], filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relays and an event store */
     sync(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/dist/pool.js

@@ -112,6 +112,10 @@ export class RelayPool {
     subscription(relays, filters, options) {
         return this.group(relays).subscription(filters, options);
     }
+    /** Count events on multiple relays */
+    count(relays, filters, id) {
+        return this.group(relays).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);

package/dist/relay.d.ts

@@ -4,7 +4,7 @@ import { RelayInformation } from "nostr-tools/nip11";
 import { BehaviorSubject, MonoTypeOperatorFunction, Observable, RepeatConfig, RetryConfig, Subject } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { type NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
-import { AuthSigner, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { AuthSigner, CountResponse, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** Flags for the negentropy sync type */
 export declare enum SyncDirection {
     RECEIVE = 1,
@@ -104,6 +104,8 @@ export declare class Relay implements IRelay {
     send(message: any): void;
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Create a COUNT observable that emits a single count response */
+    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
     /** 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 */
@@ -118,6 +120,8 @@ export declare class Relay implements IRelay {
     protected customRepeatOperator<T extends unknown = unknown>(times: undefined | boolean | number | RepeatConfig | undefined): MonoTypeOperatorFunction<T>;
     /** Internal operator for creating the timeout() operator */
     protected customTimeoutOperator<T extends unknown = unknown>(timeout: undefined | boolean | number, defaultTimeout: number): MonoTypeOperatorFunction<T>;
+    /** Internal operator for handling auth-required errors from REQ/COUNT operations */
+    protected handleAuthRequiredForReq(operation: "REQ" | "COUNT"): MonoTypeOperatorFunction<any>;
     /** 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 */

package/dist/relay.js

@@ -7,6 +7,7 @@ import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, fin
 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 };
 /** Flags for the negentropy sync type */
 export var SyncDirection;
@@ -294,21 +295,11 @@ export class Relay {
                 throw new ReqCloseError(message[2]);
             else
                 return message[2];
-        }), catchError((error) => {
-            // Set REQ auth required if the REQ is closed with auth-required
-            if (error instanceof ReqCloseError &&
-                error.message.startsWith("auth-required") &&
-                !this.receivedAuthRequiredForReq.value) {
-                this.log("Auth required for REQ");
-                this.receivedAuthRequiredForReq.next(true);
-            }
-            // Pass the error through
-            return throwError(() => error);
-        }), 
+        }), this.handleAuthRequiredForReq("REQ"), 
         // mark events as from relays
         markFromRelay(this.url), 
         // if no events are seen in 10s, emit EOSE
-        // TODO: this should emit EOSE event if events are seen, the timeout should be for only the EOSE message
+        // TODO: this timeout should only emit EOSE after the last event is seen and no EOSE has been sent in (timeout ms)
         timeout({
             first: this.eoseTimeout,
             with: () => merge(of("EOSE"), NEVER),
@@ -318,6 +309,38 @@ export class Relay {
         // Wait for auth if required and make sure to start the watch tower
         return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable));
     }
+    /** Create a COUNT observable that emits a single count response */
+    count(filters, id = nanoid()) {
+        // Create an observable that filters responses from the relay to just the ones for this COUNT
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "COUNT" || m[0] === "CLOSED") && m[1] === id), 
+        // Singleton (prevents duplicate subscriptions)
+        share());
+        // Send the COUNT message and listen for response
+        const observable = defer(() => {
+            // Send the COUNT message when subscription starts
+            this.socket.next(Array.isArray(filters) ? ["COUNT", id, ...filters] : ["COUNT", id, filters]);
+            // Merge with watch tower to keep connection alive
+            return merge(this.watchTower, messages);
+        }).pipe(
+        // Map the messages to count responses or throw an error
+        map((message) => {
+            if (message[0] === "COUNT")
+                return message[2];
+            else
+                throw new ReqCloseError(message[2]);
+        }), this.handleAuthRequiredForReq("COUNT"), 
+        // Complete on first value (COUNT responses are single-shot)
+        take(1), 
+        // Add timeout
+        timeout({
+            first: this.eoseTimeout,
+            with: () => throwError(() => new Error("COUNT timeout")),
+        }), 
+        // Only create one upstream subscription
+        share());
+        // Start the watch tower and wait for auth if required
+        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") {
         const messages = defer(() => {
@@ -338,7 +361,7 @@ export class Relay {
         take(1), 
         // listen for OK auth-required
         tap(({ ok, message }) => {
-            if (ok === false && message?.startsWith("auth-required") && !this.receivedAuthRequiredForEvent.value) {
+            if (ok === false && message?.startsWith(AUTH_REQUIRED_PREFIX) && !this.receivedAuthRequiredForEvent.value) {
                 this.log("Auth required for publish");
                 this.receivedAuthRequiredForEvent.next(true);
             }
@@ -414,6 +437,20 @@ export class Relay {
         else
             return simpleTimeout(timeout ?? defaultTimeout);
     }
+    /** Internal operator for handling auth-required errors from REQ/COUNT operations */
+    handleAuthRequiredForReq(operation) {
+        return catchError((error) => {
+            // Set auth required if the operation is closed with auth-required
+            if (error instanceof ReqCloseError &&
+                error.message.startsWith(AUTH_REQUIRED_PREFIX) &&
+                !this.receivedAuthRequiredForReq.value) {
+                this.log(`Auth required for ${operation}`);
+                this.receivedAuthRequiredForReq.next(true);
+            }
+            // Pass the error through
+            return throwError(() => error);
+        });
+    }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
@@ -440,7 +477,7 @@ export class Relay {
     publish(event, opts) {
         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:"))
+            if (result.ok === false && result.message?.startsWith(AUTH_REQUIRED_PREFIX))
                 return throwError(() => new Error(result.message));
             return of(result);
         }), 

package/dist/types.d.ts

@@ -12,6 +12,9 @@ export type PublishResponse = {
     message?: string;
     from: string;
 };
+export type CountResponse = {
+    count: number;
+};
 export type MultiplexWebSocket<T = any> = Pick<WebSocketSubject<T>, "multiplex">;
 /** Options for the publish method on the pool and relay */
 export type PublishOptions = {
@@ -65,6 +68,9 @@ export interface IRelay extends MultiplexWebSocket {
     challenge$: Observable<string | null>;
     authenticated$: Observable<boolean>;
     notices$: Observable<string[]>;
+    open$: Observable<Event>;
+    close$: Observable<CloseEvent>;
+    closing$: Observable<void>;
     error$: Observable<Error | null>;
     readonly connected: boolean;
     readonly authenticated: boolean;
@@ -74,6 +80,8 @@ export interface IRelay extends MultiplexWebSocket {
     close(): void;
     /** Send a REQ message */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
+    /** Send a COUNT message */
+    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
     /** Send an EVENT message */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Send an AUTH message */
@@ -110,6 +118,8 @@ export interface IGroup {
     request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
     subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Count events on the relays and an event store */
+    count(filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relay and an event store */
     sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }
@@ -137,6 +147,8 @@ export interface IPool extends IPoolSignals {
     request(relays: string[], filters: Parameters<IGroup["request"]>[0], opts?: Parameters<IGroup["request"]>[1]): Observable<NostrEvent>;
     /** Open a subscription to relays with retries */
     subscription(relays: string[], filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** Count events on the relays and an event store */
+    count(relays: string[], filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relay and an event store */
     sync(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/package.json

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