applesauce-relay 3.1.0 → 4.0.0

package/dist/group.d.ts

@@ -1,19 +1,44 @@
-import { type NostrEvent } from "nostr-tools";
+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 { SyncDirection } from "./relay.js";
+/** Options for negentropy sync on a group of relays */
+export type GroupNegentropySyncOptions = NegentropySyncOptions & {
+    /** Whether to sync in parallel (default true) */
+    parallel?: boolean;
+};
+/** Options for a subscription on a group of relays */
+export type GroupSubscriptionOptions = SubscriptionOptions & {
+    /** Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication */
+    eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
+};
+/** Options for a request on a group of relays */
+export type GroupRequestOptions = RequestOptions & {
+    /** Deduplicate events with an event store (default is a temporary instance of EventMemory), null will disable deduplication */
+    eventStore?: IEventStoreActions | IAsyncEventStoreActions | null;
+};
 export declare class RelayGroup implements IGroup {
     relays: IRelay[];
     constructor(relays: IRelay[]);
     /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
-    protected mergeEOSE(...requests: Observable<SubscriptionResponse>[]): Observable<import("nostr-tools").Event | "EOSE">;
-    /** Make a request to all relays */
+    protected mergeEOSE(requests: Observable<SubscriptionResponse>[], eventStore?: IEventStoreActions | IAsyncEventStoreActions | null): Observable<import("nostr-tools").Event | "EOSE">;
+    /**
+     * Make a request to all relays
+     * @note This does not deduplicate events
+     */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** 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: 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 with retries ( default 3 retries ) */
-    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */
-    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** 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,6 @@
 import { nanoid } from "nanoid";
-import { catchError, EMPTY, endWith, ignoreElements, merge, of } from "rxjs";
+import { catchError, 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";
 export class RelayGroup {
@@ -8,9 +9,13 @@ export class RelayGroup {
         this.relays = relays;
     }
     /** Takes an array of observables and only emits EOSE when all observables have emitted EOSE */
-    mergeEOSE(...requests) {
+    mergeEOSE(requests, eventStore = new EventMemory()) {
         // Create stream of events only
-        const events = merge(...requests).pipe(onlyEvents());
+        const events = merge(...requests).pipe(
+        // Ignore non event responses
+        onlyEvents(), 
+        // If an event store is provided, filter duplicate events
+        eventStore ? filterDuplicateEvents(eventStore) : identity);
         // Create stream that emits EOSE when all relays have sent EOSE
         const eose = merge(
         // Create a new map of requests that only emits EOSE
@@ -19,13 +24,16 @@ export class RelayGroup {
         endWith("EOSE"));
         return merge(events, eose);
     }
-    /** Make a request to all relays */
+    /**
+     * Make a request to all relays
+     * @note This does not deduplicate events
+     */
     req(filters, id = nanoid(8)) {
         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);
     }
     /** Send an event to all relays */
     event(event) {
@@ -33,6 +41,20 @@ export class RelayGroup {
         // Catch error and return as PublishResponse
         catchError((err) => of({ ok: false, from: relay.url, message: err?.message || "Unknown error" })))));
     }
+    /** Negentropy sync events with the relays and an event store */
+    async negentropy(store, filter, reconcile, opts) {
+        // Filter out relays that do not support NIP-77 negentropy sync
+        const supported = await Promise.all(this.relays.map(async (relay) => [relay, await relay.getSupported()]));
+        const relays = supported.filter(([_, supported]) => supported?.includes(77)).map(([relay]) => relay);
+        if (relays.length === 0)
+            throw new Error("No relays support NIP-77 negentropy sync");
+        // Non parallel sync is not supported yet
+        if (!opts?.parallel)
+            throw new Error("Negentropy sync must be parallel (for now)");
+        // Sync all the relays in parallel
+        await Promise.allSettled(relays.map((relay) => relay.negentropy(store, filter, reconcile, opts)));
+        return true;
+    }
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event, opts) {
         return Promise.all(this.relays.map((relay) => relay.publish(event, opts).catch(
@@ -43,12 +65,31 @@ export class RelayGroup {
     request(filters, opts) {
         return merge(...this.relays.map((relay) => relay.request(filters, opts).pipe(
         // Ignore individual connection errors
-        catchError(() => EMPTY))));
+        catchError(() => EMPTY)))).pipe(
+        // If an event store is provided, filter duplicate events
+        opts?.eventStore == null ? identity : filterDuplicateEvents(opts?.eventStore ?? new EventMemory()));
     }
     /** Open a subscription to all relays with retries ( default 3 retries ) */
     subscription(filters, opts) {
-        return this.mergeEOSE(...this.relays.map((relay) => relay.subscription(filters, opts).pipe(
+        return this.mergeEOSE(this.relays.map((relay) => relay.subscription(filters, opts).pipe(
         // Ignore individual connection errors
-        catchError(() => EMPTY))));
+        catchError(() => EMPTY))), 
+        // Pass event store so that duplicate events are removed
+        opts?.eventStore);
+    }
+    /** 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
+        return defer(async () => {
+            const supported = await Promise.all(this.relays.map(async (relay) => [relay, await relay.getSupported()]));
+            const relays = supported.filter(([_, supported]) => supported?.includes(77)).map(([relay]) => relay);
+            if (relays.length === 0)
+                throw new Error("No relays support NIP-77 negentropy sync");
+            return relays;
+        }).pipe(
+        // Once relays are selected, sync all the relays in parallel
+        switchMap((relays) => merge(...relays.map((relay) => relay.sync(store, filter, direction)))), 
+        // Only create one upstream subscription
+        share());
     }
 }

package/dist/lib/negentropy.d.ts

@@ -38,7 +38,7 @@ declare class Negentropy {
     constructor(storage: NegentropyStorageVector, frameSizeLimit?: number);
     _bound(timestamp: number, id?: Uint8Array): {
         timestamp: number;
-        id: Uint8Array<ArrayBuffer>;
+        id: Uint8Array<ArrayBufferLike>;
     };
     initiate<T extends Uint8Array | string>(): Promise<T>;
     setInitiator(): void;
@@ -55,7 +55,7 @@ declare class Negentropy {
     encodeBound(key: Item): WrappedBuffer;
     getMinimalBound(prev: Item, curr: Item): {
         timestamp: number;
-        id: Uint8Array<ArrayBuffer>;
+        id: Uint8Array<ArrayBufferLike>;
     };
 }
 export { Negentropy, NegentropyStorageVector };

package/dist/negentropy.d.ts

@@ -1,15 +1,31 @@
-import { IEventStoreRead } from "applesauce-core";
+import { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
 import { Filter } from "nostr-tools";
 import { MultiplexWebSocket } from "./types.js";
 import { NegentropyStorageVector } from "./lib/negentropy.js";
-export declare function buildStorageFromFilter(store: IEventStoreRead, filter: Filter): NegentropyStorageVector;
+/**
+ * A function that reconciles the storage vectors with a remote relay
+ * @param have - The ids that the local storage has
+ * @param need - The ids that the remote relay has
+ * @returns A promise that resolves when the reconciliation is complete
+ */
+export type ReconcileFunction = (have: string[], need: string[]) => Promise<void>;
+/** Options for the negentropy sync */
+export type NegentropySyncOptions = {
+    frameSizeLimit?: number;
+    signal?: AbortSignal;
+};
+/** Creates a NegentropyStorageVector from an event store and filter */
+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;
     created_at: number;
 }[]): NegentropyStorageVector;
+/**
+ * Sync the storage vectors with a remote relay
+ * @throws {Error} if the sync fails
+ * @returns true if the sync was successful, false if the sync was aborted
+ */
 export declare function negentropySync(storage: NegentropyStorageVector, socket: MultiplexWebSocket & {
     next: (msg: any) => void;
-}, filter: Filter, reconcile: (have: string[], need: string[]) => Promise<void>, opts?: {
-    frameSizeLimit?: number;
-    signal?: AbortSignal;
-}): Promise<boolean>;
+}, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;

package/dist/negentropy.js

@@ -3,13 +3,15 @@ import { map, share, firstValueFrom } from "rxjs";
 import { nanoid } from "nanoid";
 import { Negentropy, NegentropyStorageVector } from "./lib/negentropy.js";
 const log = logger.extend("negentropy");
-export function buildStorageFromFilter(store, filter) {
+/** Creates a NegentropyStorageVector from an event store and filter */
+export async function buildStorageFromFilter(store, filter) {
     const storage = new NegentropyStorageVector();
-    for (const event of store.getByFilters(filter))
+    for (const event of await store.getByFilters(filter))
         storage.insert(event.created_at, event.id);
     storage.seal();
     return storage;
 }
+/** Creates a NegentropyStorageVector from an array of items */
 export function buildStorageVector(items) {
     const storage = new NegentropyStorageVector();
     for (const item of items)
@@ -17,6 +19,11 @@ export function buildStorageVector(items) {
     storage.seal();
     return storage;
 }
+/**
+ * Sync the storage vectors with a remote relay
+ * @throws {Error} if the sync fails
+ * @returns true if the sync was successful, false if the sync was aborted
+ */
 export async function negentropySync(storage, socket, filter, reconcile, opts) {
     let id = nanoid();
     let ne = new Negentropy(storage, opts?.frameSizeLimit);
@@ -46,7 +53,7 @@ export async function negentropySync(storage, socket, filter, reconcile, opts) {
         return msg[2];
     }), share());
     // keep an additional subscription open while waiting for async operations
-    const sub = incoming.subscribe((m) => console.log(m));
+    const sub = incoming.subscribe((m) => log(m));
     try {
         while (msg && opts?.signal?.aborted !== true) {
             const received = await firstValueFrom(incoming);

package/dist/pool.d.ts

@@ -1,14 +1,20 @@
-import { type NostrEvent } from "nostr-tools";
-import { BehaviorSubject, Observable } from "rxjs";
+import type { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
+import { Filter, type NostrEvent } from "nostr-tools";
+import { BehaviorSubject, Observable, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
-import { Relay, RelayOptions } from "./relay.js";
-import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse, FilterInput, IRelay } from "./types.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";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     groups$: BehaviorSubject<Map<string, RelayGroup>>;
     get groups(): Map<string, RelayGroup>;
     relays$: BehaviorSubject<Map<string, Relay>>;
     get relays(): Map<string, Relay>;
+    /** A signal when a relay is added */
+    add$: Subject<IRelay>;
+    /** A signal when a relay is removed */
+    remove$: Subject<IRelay>;
     /** An array of relays to never connect to */
     blacklist: Set<string>;
     constructor(options?: RelayOptions | undefined);
@@ -23,10 +29,14 @@ export declare class RelayPool implements IPool {
     req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
+    /** Negentropy sync event ids with the relays and an event store */
+    negentropy(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Publish an event to multiple relays */
-    publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
+    publish(relays: string[], event: Parameters<RelayGroup["publish"]>[0], opts?: Parameters<RelayGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Request events from multiple relays */
-    request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
+    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: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(relays: string[], filters: Parameters<RelayGroup["subscription"]>[0], options?: Parameters<RelayGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** 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

@@ -1,7 +1,7 @@
-import { BehaviorSubject } from "rxjs";
+import { normalizeURL } from "applesauce-core/helpers";
+import { BehaviorSubject, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";
-import { normalizeURL } from "applesauce-core/helpers";
 export class RelayPool {
     options;
     groups$ = new BehaviorSubject(new Map());
@@ -12,10 +12,27 @@ export class RelayPool {
     get relays() {
         return this.relays$.value;
     }
+    /** A signal when a relay is added */
+    add$ = new Subject();
+    /** A signal when a relay is removed */
+    remove$ = new Subject();
     /** An array of relays to never connect to */
     blacklist = new Set();
     constructor(options) {
         this.options = options;
+        // Listen for relays being added and removed to emit connect / disconnect signals
+        // const listeners = new Map<IRelay, Subscription>();
+        // this.add$.subscribe((relay) =>
+        //   listeners.set(
+        //     relay,
+        //     relay.connected$.subscribe((conn) => (conn ? this.connect$.next(relay) : this.disconnect$.next(relay))),
+        //   ),
+        // );
+        // this.remove$.subscribe((relay) => {
+        //   const listener = listeners.get(relay);
+        //   if (listener) listener.unsubscribe();
+        //   listeners.delete(relay);
+        // });
     }
     filterBlacklist(urls) {
         return urls.filter((url) => !this.blacklist.has(url));
@@ -35,6 +52,7 @@ export class RelayPool {
         relay = new Relay(url, this.options);
         this.relays.set(url, relay);
         this.relays$.next(this.relays);
+        this.add$.next(relay);
         return relay;
     }
     /** Create a group of relays */
@@ -68,6 +86,7 @@ export class RelayPool {
             instance?.close();
         this.relays.delete(instance.url);
         this.relays$.next(this.relays);
+        this.remove$.next(instance);
     }
     /** Make a REQ to multiple relays that does not deduplicate events */
     req(relays, filters, id) {
@@ -77,6 +96,10 @@ export class RelayPool {
     event(relays, 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).negentropy(store, filter, reconcile, opts);
+    }
     /** Publish an event to multiple relays */
     publish(relays, event, opts) {
         return this.group(relays).publish(event, opts);
@@ -86,7 +109,11 @@ export class RelayPool {
         return this.group(relays).request(filters, opts);
     }
     /** Open a subscription to multiple relays */
-    subscription(relays, filters, opts) {
-        return this.group(relays).subscription(filters, opts);
+    subscription(relays, filters, options) {
+        return this.group(relays).subscription(filters, options);
+    }
+    /** 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

@@ -1,9 +1,16 @@
-import { logger } from "applesauce-core";
+import { IAsyncEventStoreRead, IEventStoreRead, logger } from "applesauce-core";
 import { type Filter, type NostrEvent } from "nostr-tools";
 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";
+/** Flags for the negentropy sync type */
+export declare enum SyncDirection {
+    RECEIVE = 1,
+    SEND = 2,
+    BOTH = 3
+}
 /** An error that is thrown when a REQ is closed from the relay side */
 export declare class ReqCloseError extends Error {
 }
@@ -14,6 +21,8 @@ export type RelayOptions = {
     eoseTimeout?: number;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout?: number;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout?: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive?: number;
 };
@@ -54,6 +63,8 @@ export declare class Relay implements IRelay {
     protected _nip11: RelayInformation | null;
     /** An observable that emits the limitations for the relay */
     limitations$: Observable<RelayInformation["limitation"] | null>;
+    /** An array of supported NIPs from the NIP-11 information document */
+    supported$: Observable<number[] | null>;
     /** An observable that emits when underlying websocket is opened */
     open$: Subject<Event>;
     /** An observable that emits when underlying websocket is closed */
@@ -70,6 +81,8 @@ export declare class Relay implements IRelay {
     eoseTimeout: number;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout: number;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout: number;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive: number;
     protected receivedAuthRequiredForReq: BehaviorSubject<boolean>;
@@ -95,20 +108,32 @@ export declare class Relay implements IRelay {
     event(event: NostrEvent, verb?: "EVENT" | "AUTH"): Observable<PublishResponse>;
     /** send and AUTH message */
     auth(event: NostrEvent): Promise<PublishResponse>;
+    /** Negentropy sync event ids with the relay and an event store */
+    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Authenticate with the relay using a signer */
     authenticate(signer: AuthSigner): Promise<PublishResponse>;
     /** Internal operator for creating the retry() operator */
     protected customRetryOperator<T extends unknown = unknown>(times: undefined | boolean | number | RetryConfig, base?: RetryConfig): MonoTypeOperatorFunction<T>;
     /** Internal operator for creating the repeat() operator */
     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>;
     /** 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): Promise<PublishResponse>;
+    /** Negentropy sync events with the relay and an event store */
+    sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
     /** Force close the connection */
     close(): void;
+    /** An async method that returns the NIP-11 information document for the relay */
+    getInformation(): Promise<RelayInformation | null>;
+    /** An async method that returns the NIP-11 limitations for the relay */
+    getLimitations(): Promise<RelayInformation["limitation"] | null>;
+    /** An async method that returns the supported NIPs for the relay */
+    getSupported(): Promise<number[] | null>;
     /** 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

@@ -3,11 +3,18 @@ import { ensureHttpURL } from "applesauce-core/helpers";
 import { simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { nip42 } from "nostr-tools";
-import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, of, repeat, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, firstValueFrom, from, identity, ignoreElements, isObservable, lastValueFrom, map, merge, mergeMap, mergeWith, NEVER, Observable, of, repeat, retry, scan, share, shareReplay, Subject, switchMap, take, takeUntil, tap, throwError, timeout, timer, } from "rxjs";
 import { webSocket } from "rxjs/webSocket";
 import { completeOnEose } from "./operators/complete-on-eose.js";
 import { markFromRelay } from "./operators/mark-from-relay.js";
 const DEFAULT_RETRY_CONFIG = { count: 10, delay: 1000, resetOnSuccess: true };
+/** Flags for the negentropy sync type */
+export var SyncDirection;
+(function (SyncDirection) {
+    SyncDirection[SyncDirection["RECEIVE"] = 1] = "RECEIVE";
+    SyncDirection[SyncDirection["SEND"] = 2] = "SEND";
+    SyncDirection[SyncDirection["BOTH"] = 3] = "BOTH";
+})(SyncDirection || (SyncDirection = {}));
 /** An error that is thrown when a REQ is closed from the relay side */
 export class ReqCloseError extends Error {
 }
@@ -48,6 +55,8 @@ export class Relay {
     _nip11 = null;
     /** An observable that emits the limitations for the relay */
     limitations$;
+    /** An array of supported NIPs from the NIP-11 information document */
+    supported$;
     /** An observable that emits when underlying websocket is opened */
     open$ = new Subject();
     /** An observable that emits when underlying websocket is closed */
@@ -77,6 +86,8 @@ export class Relay {
     eoseTimeout = 10_000;
     /** How long to wait for an OK message from the relay (default 10s) */
     eventTimeout = 10_000;
+    /** How long to wait for a publish to complete (default 30s) */
+    publishTimeout = 30_000;
     /** How long to keep the connection alive after nothing is subscribed (default 30s) */
     keepAlive = 30_000;
     // Subjects that track if an "auth-required" message has been received for REQ or EVENT
@@ -108,6 +119,8 @@ export class Relay {
             this.eoseTimeout = opts.eoseTimeout;
         if (opts?.eventTimeout !== undefined)
             this.eventTimeout = opts.eventTimeout;
+        if (opts?.publishTimeout !== undefined)
+            this.publishTimeout = opts.publishTimeout;
         if (opts?.keepAlive !== undefined)
             this.keepAlive = opts.keepAlive;
         // Create an observable that tracks boolean authentication state
@@ -145,11 +158,12 @@ export class Relay {
         }).pipe(
         // if the fetch fails, return null
         catchError(() => of(null)), 
-        // cache the result
-        shareReplay(1), 
         // update the internal state
-        tap((info) => (this._nip11 = info)));
-        this.limitations$ = this.information$.pipe(map((info) => info?.limitation));
+        tap((info) => (this._nip11 = info)), 
+        // cache the result
+        shareReplay(1));
+        this.limitations$ = this.information$.pipe(map((info) => (info ? info.limitation : null)));
+        this.supported$ = this.information$.pipe(map((info) => info && Array.isArray(info.supported_nips) ? info.supported_nips.filter((n) => typeof n === "number") : null));
         // Create observables that track if auth is required for REQ or EVENT
         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));
@@ -348,6 +362,16 @@ export class Relay {
         // update authenticated
         tap((result) => this.authenticationResponse$.next(result))));
     }
+    /** Negentropy sync event ids with the relay and an event store */
+    async negentropy(store, filter, reconcile, opts) {
+        // Check relay supports NIP-77 sync
+        if ((await this.getSupported())?.includes(77) === false)
+            throw new Error("Relay does not support NIP-77");
+        // Import negentropy functions dynamically
+        const { buildStorageVector, buildStorageFromFilter, negentropySync } = await import("./negentropy.js");
+        const storage = Array.isArray(store) ? buildStorageVector(store) : await buildStorageFromFilter(store, filter);
+        return negentropySync(storage, this.socket, filter, reconcile, opts);
+    }
     /** Authenticate with the relay using a signer */
     authenticate(signer) {
         if (!this.challenge)
@@ -378,6 +402,18 @@ export class Relay {
         else
             return repeat(times);
     }
+    /** Internal operator for creating the timeout() operator */
+    customTimeoutOperator(timeout, defaultTimeout) {
+        // Do nothing if disabled
+        if (timeout === false)
+            return identity;
+        // If true default to 30 seconds
+        else if (timeout === true)
+            return simpleTimeout(defaultTimeout);
+        // Otherwise use the timeout value or default to 30 seconds
+        else
+            return simpleTimeout(timeout ?? defaultTimeout);
+    }
     /** Creates a REQ that retries when relay errors ( default 3 retries ) */
     subscription(filters, opts) {
         return this.req(filters, opts?.id).pipe(
@@ -410,13 +446,60 @@ export class Relay {
         }), 
         // Retry the publish until it succeeds or the number of retries is reached
         this.customRetryOperator(opts?.retries ?? opts?.reconnect ?? true, DEFAULT_RETRY_CONFIG), 
+        // Add timeout for publishing
+        this.customTimeoutOperator(opts?.timeout, this.publishTimeout), 
         // Single subscription
         share()));
     }
+    /** Negentropy sync events with the relay and an event store */
+    sync(store, filter, direction = SyncDirection.RECEIVE) {
+        const getEvents = async (ids) => {
+            if (Array.isArray(store))
+                return store.filter((event) => ids.includes(event.id));
+            else
+                return store.getByFilters({ ids });
+        };
+        return new Observable((observer) => {
+            const controller = new AbortController();
+            this.negentropy(store, filter, async (have, need) => {
+                // NOTE: it may be more efficient to sync all the events later in a single batch
+                // 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))));
+                }
+                // Fetch missing events from the relay
+                if (direction & SyncDirection.RECEIVE && need.length > 0) {
+                    await lastValueFrom(this.req({ ids: need }).pipe(completeOnEose(), tap((event) => observer.next(event))));
+                }
+            }, { signal: controller.signal })
+                // Complete the observable when the sync is complete
+                .then(() => observer.complete())
+                // Error the observable when the sync fails
+                .catch((err) => observer.error(err));
+            // Cancel the sync when the observable is unsubscribed
+            return () => controller.abort();
+        }).pipe(
+        // Only create one upstream subscription
+        share());
+    }
     /** Force close the connection */
     close() {
         this.socket.unsubscribe();
     }
+    /** An async method that returns the NIP-11 information document for the relay */
+    async getInformation() {
+        return firstValueFrom(this.information$);
+    }
+    /** An async method that returns the NIP-11 limitations for the relay */
+    async getLimitations() {
+        return firstValueFrom(this.limitations$);
+    }
+    /** An async method that returns the supported NIPs for the relay */
+    async getSupported() {
+        return firstValueFrom(this.supported$);
+    }
     /** Static method to fetch the NIP-11 information document for a relay */
     static fetchInformationDocument(url) {
         return from(fetch(ensureHttpURL(url), { headers: { Accept: "application/nostr+json" } }).then((res) => res.json())).pipe(

package/dist/types.d.ts

@@ -1,6 +1,11 @@
-import { type EventTemplate, type Filter, type NostrEvent } from "nostr-tools";
-import { Observable, repeat, retry } from "rxjs";
-import { WebSocketSubject } from "rxjs/webSocket";
+import type { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import type { RelayInformation } from "nostr-tools/nip11";
+import type { Observable, repeat, retry } from "rxjs";
+import type { WebSocketSubject } from "rxjs/webSocket";
+import type { NegentropySyncOptions, ReconcileFunction } from "./negentropy.js";
+import type { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
+import type { SyncDirection } from "./relay.js";
+import type { GroupNegentropySyncOptions, GroupRequestOptions, GroupSubscriptionOptions } from "./group.js";
 export type SubscriptionResponse = NostrEvent | "EOSE";
 export type PublishResponse = {
     ok: boolean;
@@ -21,6 +26,8 @@ export type PublishOptions = {
      * @see https://rxjs.dev/api/index/function/retry
      */
     reconnect?: boolean | number | Parameters<typeof retry>[0];
+    /** Timeout for publish in milliseconds (default 30 seconds) */
+    timeout?: number | boolean;
 };
 /** Options for the request method on the pool and relay */
 export type RequestOptions = SubscriptionOptions;
@@ -58,6 +65,7 @@ export interface IRelay extends MultiplexWebSocket {
     challenge$: Observable<string | null>;
     authenticated$: Observable<boolean>;
     notices$: Observable<string[]>;
+    error$: Observable<Error | null>;
     readonly connected: boolean;
     readonly authenticated: boolean;
     readonly challenge: string | null;
@@ -70,6 +78,8 @@ export interface IRelay extends MultiplexWebSocket {
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Send an AUTH message */
     auth(event: NostrEvent): Promise<PublishResponse>;
+    /** Negentropy sync event ids with the relay and an event store */
+    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Authenticate with the relay using a signer */
     authenticate(signer: AuthSigner): Promise<PublishResponse>;
     /** Send an EVENT message with retries */
@@ -78,20 +88,37 @@ export interface IRelay extends MultiplexWebSocket {
     request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
     subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Negentropy sync events with the relay and an event store */
+    sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
+    /** Get the NIP-11 information document for the relay */
+    getInformation(): Promise<RelayInformation | null>;
+    /** Get the limitations for the relay */
+    getLimitations(): Promise<RelayInformation["limitation"] | null>;
+    /** Get the supported NIPs for the relay */
+    getSupported(): Promise<number[] | null>;
 }
 export interface IGroup {
     /** Send a REQ message */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message */
     event(event: NostrEvent): Observable<PublishResponse>;
+    /** Negentropy sync event ids with the relays and an event store */
+    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Send an EVENT message with retries */
     publish(event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
     /** Send a REQ message with retries */
-    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: GroupRequestOptions): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
+    /** Negentropy sync events with the relay and an event store */
+    sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
+}
+/** Signals emitted by the pool */
+export interface IPoolSignals {
+    add$: Observable<IRelay>;
+    remove$: Observable<IRelay>;
 }
-export interface IPool {
+export interface IPool extends IPoolSignals {
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */
@@ -102,10 +129,14 @@ export interface IPool {
     req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
+    /** Negentropy sync event ids with the relays and an event store */
+    negentropy(relays: string[], store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
     /** Send an EVENT message to relays with retries */
-    publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Promise<PublishResponse[]>;
+    publish(relays: string[], event: Parameters<IGroup["publish"]>[0], opts?: Parameters<IGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Send a REQ message to relays with retries */
-    request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
+    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: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(relays: string[], filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
+    /** 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,19 +1,17 @@
 {
   "name": "applesauce-relay",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
-    "nostr",
-    "applesauce"
+    "nostr"
   ],
   "author": "hzrd149",
   "license": "MIT",
   "files": [
-    "dist",
-    "applesauce"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -54,17 +52,17 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^3.1.0",
+    "applesauce-core": "^4.0.0",
     "nanoid": "^5.0.9",
-    "nostr-tools": "~2.15",
+    "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^3.1.0",
-    "@vitest/expect": "^3.1.1",
+    "applesauce-signers": "^4.0.0",
+    "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.2.3",
+    "vitest": "^3.2.4",
     "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
@@ -72,6 +70,7 @@
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",