applesauce-relay 4.4.2 → 5.1.0

package/README.md

@@ -22,7 +22,7 @@ npm install applesauce-relay
 
 ## Examples
 
-Read the [documentation](https://hzrd149.github.io/applesauce/overview/relays.html) for more detailed explanation of all methods
+Read the [documentation](https://applesauce.build/overview/relays.html) for more detailed explanation of all methods
 
 ### Single Relay
 

package/dist/group.d.ts

@@ -1,10 +1,9 @@
-import { type NostrEvent } from "nostr-tools";
+import { IAsyncEventStoreActions, IEventStoreActions } from "applesauce-core/event-store";
+import type { Filter, NostrEvent } from "applesauce-core/helpers";
 import { BehaviorSubject, MonoTypeOperatorFunction, Observable } from "rxjs";
-import { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreActions, IEventStoreRead } from "applesauce-core";
-import { type FilterWithAnd } from "applesauce-core/helpers";
 import { NegentropySyncOptions, type ReconcileFunction } from "./negentropy.js";
 import { SyncDirection } from "./relay.js";
-import { CountResponse, FilterInput, IGroup, IGroupRelayInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { CountResponse, FilterInput, IGroup, IGroupRelayInput, IRelay, NegentropyReadStore, NegentropySyncStore, PublishOptions, PublishResponse, RelayStatus, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** Options for negentropy sync on a group of relays */
 export type GroupNegentropySyncOptions = NegentropySyncOptions & {
     /** Whether to sync in parallel (default true) */
@@ -22,6 +21,8 @@ export type GroupRequestOptions = RequestOptions & {
 };
 export declare class RelayGroup implements IGroup {
     protected relays$: BehaviorSubject<IRelay[]> | Observable<IRelay[]>;
+    /** Observable of relay status for all relays in the group */
+    status$: Observable<Record<string, RelayStatus>>;
     get relays(): IRelay[];
     constructor(relays: IGroupRelayInput);
     /** Whether this group is controlled by an upstream observable */
@@ -47,7 +48,7 @@ export declare class RelayGroup implements IGroup {
     /** Send an event to all relays */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Negentropy sync events with the relays and an event store */
-    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
+    negentropy(store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Request events from all relays and complete on EOSE */
@@ -55,7 +56,7 @@ export declare class RelayGroup implements IGroup {
     /** 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: FilterWithAnd | FilterWithAnd[], id?: string): Observable<Record<string, CountResponse>>;
+    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: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(store: NegentropySyncStore | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/dist/group.js

@@ -1,6 +1,7 @@
+import { EventMemory } from "applesauce-core/event-store";
+import { filterDuplicateEvents } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
-import { BehaviorSubject, catchError, combineLatest, defaultIfEmpty, defer, endWith, filter, from, identity, ignoreElements, lastValueFrom, map, merge, of, scan, share, switchMap, take, takeWhile, toArray, } from "rxjs";
-import { EventMemory, filterDuplicateEvents, } from "applesauce-core";
+import { BehaviorSubject, catchError, combineLatest, defaultIfEmpty, defer, endWith, filter, from, identity, ignoreElements, lastValueFrom, map, merge, of, scan, share, shareReplay, startWith, switchMap, take, takeWhile, toArray, } from "rxjs";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { onlyEvents } from "./operators/only-events.js";
 import { reverseSwitchMap } from "./operators/reverse-switch-map.js";
@@ -10,6 +11,8 @@ function errorToPublishResponse(relay) {
 }
 export class RelayGroup {
     relays$ = new BehaviorSubject([]);
+    /** Observable of relay status for all relays in the group */
+    status$;
     get relays() {
         if (this.relays$ instanceof BehaviorSubject)
             return this.relays$.value;
@@ -17,6 +20,23 @@ export class RelayGroup {
     }
     constructor(relays) {
         this.relays$ = Array.isArray(relays) ? new BehaviorSubject(relays) : relays;
+        // Initialize status$ observable
+        this.status$ = this.relays$.pipe(switchMap((relays) => {
+            // If no relays, return empty record
+            if (relays.length === 0)
+                return of({});
+            // Merge all relay status streams
+            return merge(...relays.map((relay) => relay.status$)).pipe(
+            // Accumulate into a Record
+            scan((acc, status) => ({
+                ...acc,
+                [status.url]: status,
+            }), {}), 
+            // Start with initial empty state
+            startWith({}));
+        }), 
+        // Share the subscription
+        shareReplay(1));
     }
     /** Whether this group is controlled by an upstream observable */
     get controlled() {

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/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/sha256";
+import { sha256 } from "@noble/hashes/sha2";
 const PROTOCOL_VERSION = 0x61; // Version 1
 const ID_SIZE = 32;
 const FINGERPRINT_SIZE = 16;

package/dist/management.d.ts

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

package/dist/management.js

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

package/dist/negentropy.d.ts

@@ -1,5 +1,5 @@
 import { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
-import { type FilterWithAnd } from "applesauce-core/helpers";
+import { type Filter } from "applesauce-core/helpers";
 import { NegentropyStorageVector } from "./lib/negentropy.js";
 import { MultiplexWebSocket } from "./types.js";
 /**
@@ -15,7 +15,7 @@ export type NegentropySyncOptions = {
     signal?: AbortSignal;
 };
 /** Creates a NegentropyStorageVector from an event store and filter */
-export declare function buildStorageFromFilter(store: IEventStoreRead | IAsyncEventStoreRead, filter: FilterWithAnd): Promise<NegentropyStorageVector>;
+export declare function buildStorageFromFilter(store: IEventStoreRead | IAsyncEventStoreRead, filter: Filter): Promise<NegentropyStorageVector>;
 /** Creates a NegentropyStorageVector from an array of items */
 export declare function buildStorageVector(items: {
     id: string;
@@ -28,4 +28,4 @@ export declare function buildStorageVector(items: {
  */
 export declare function negentropySync(storage: NegentropyStorageVector, socket: MultiplexWebSocket & {
     next: (msg: any) => void;
-}, filter: FilterWithAnd, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+}, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;

package/dist/operators/complete-on-eose.d.ts

@@ -1,5 +1,5 @@
 import { MonoTypeOperatorFunction, OperatorFunction } from "rxjs";
-import { NostrEvent } from "nostr-tools";
+import { NostrEvent } from "applesauce-core/helpers/event";
 import { SubscriptionResponse } from "../types.js";
 export declare function completeOnEose(includeEose: true): MonoTypeOperatorFunction<SubscriptionResponse>;
 export declare function completeOnEose(): OperatorFunction<SubscriptionResponse, NostrEvent>;

package/dist/operators/only-events.d.ts

@@ -1,5 +1,5 @@
 import { OperatorFunction } from "rxjs";
-import { NostrEvent } from "nostr-tools";
+import { NostrEvent } from "applesauce-core/helpers/event";
 import { SubscriptionResponse } from "../types.js";
 /** Filter subscription responses and only return the events */
 export declare function onlyEvents(): OperatorFunction<SubscriptionResponse, NostrEvent>;

package/dist/operators/to-event-store.d.ts

@@ -1,6 +1,6 @@
 import { OperatorFunction } from "rxjs";
 import { IEventStore } from "applesauce-core";
-import { NostrEvent } from "nostr-tools";
+import { NostrEvent } from "applesauce-core/helpers/event";
 import { SubscriptionResponse } from "../types.js";
 /**
  * Adds all events to event store and returns a deduplicated timeline when EOSE is received

package/dist/pool.d.ts

@@ -1,15 +1,19 @@
-import type { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
-import { FilterMap, OutboxMap, type FilterWithAnd } from "applesauce-core/helpers";
-import { Filter, type NostrEvent } from "nostr-tools";
+import type { NostrEvent } from "applesauce-core/helpers/event";
+import { Filter } from "applesauce-core/helpers/filter";
+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 { CountResponse, FilterInput, IPool, IPoolRelayInput, IRelay, PublishResponse, SubscriptionResponse } from "./types.js";
+import type { CountResponse, FilterInput, IPool, IPoolRelayInput, IRelay, NegentropyReadStore, NegentropySyncStore, PublishResponse, RelayStatus, SubscriptionResponse } from "./types.js";
 export declare class RelayPool implements IPool {
     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 */
+    ignoreOffline: boolean;
     /** A signal when a relay is added */
     add$: Subject<IRelay>;
     /** A signal when a relay is removed */
@@ -18,7 +22,7 @@ export declare class RelayPool implements IPool {
     /** Get or create a new relay connection */
     relay(url: string): Relay;
     /** Create a group of relays */
-    group(relays: IPoolRelayInput): RelayGroup;
+    group(relays: IPoolRelayInput, ignoreOffline?: boolean): RelayGroup;
     /** Removes a relay from the pool and defaults to closing the connection */
     remove(relay: string | IRelay, close?: boolean): void;
     /** Make a REQ to multiple relays that does not deduplicate events */
@@ -26,7 +30,7 @@ export declare class RelayPool implements IPool {
     /** Send an EVENT message to multiple relays */
     event(relays: IPoolRelayInput, event: NostrEvent): Observable<PublishResponse>;
     /** Negentropy sync event ids with the relays and an event store */
-    negentropy(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    negentropy(relays: IPoolRelayInput, store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Publish an event to multiple relays */
     publish(relays: IPoolRelayInput, event: Parameters<RelayGroup["publish"]>[0], opts?: Parameters<RelayGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Request events from multiple relays */
@@ -38,7 +42,7 @@ export declare class RelayPool implements IPool {
     /** Open a subscription for an {@link OutboxMap} and filter */
     outboxSubscription(outboxes: OutboxMap | Observable<OutboxMap>, filter: Omit<Filter, "authors">, options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
     /** Count events on multiple relays */
-    count(relays: IPoolRelayInput, filters: FilterWithAnd | FilterWithAnd[], id?: string): Observable<Record<string, CountResponse>>;
+    count(relays: IPoolRelayInput, filters: Filter | Filter[], id?: string): Observable<Record<string, CountResponse>>;
     /** Negentropy sync events with the relays and an event store */
-    sync(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(relays: IPoolRelayInput, store: NegentropySyncStore | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }