applesauce-relay 0.0.0-next-20251117143754 → 0.0.0-next-20251203172109

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, 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) */
@@ -47,7 +46,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 +54,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 { completeOnEose } from "./operators/complete-on-eose.js";
 import { onlyEvents } from "./operators/only-events.js";
 import { reverseSwitchMap } from "./operators/reverse-switch-map.js";
@@ -124,9 +125,7 @@ export class RelayGroup {
                 upstream.set(relay, observable);
             }
             return merge(...observables);
-        }), 
-        // Ensure a single upstream
-        share());
+        }));
     }
     /**
      * Make a request to all relays
@@ -137,7 +136,9 @@ export class RelayGroup {
     }
     /** Send an event to all relays */
     event(event) {
-        return this.internalPublish((relay) => relay.event(event));
+        return this.internalPublish((relay) => relay.event(event)).pipe(
+        // Ensure a single upstream subscription
+        share());
     }
     /** Negentropy sync events with the relays and an event store */
     async negentropy(store, filter, reconcile, opts) {

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/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,11 +1,11 @@
-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, SubscriptionResponse } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     relays$: BehaviorSubject<Map<string, Relay>>;
@@ -26,7 +26,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 +38,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>;
 }

package/dist/pool.js

@@ -1,4 +1,6 @@
-import { createFilterMap, isFilterEqual, normalizeURL, } from "applesauce-core/helpers";
+import { isFilterEqual } from "applesauce-core/helpers/filter";
+import { createFilterMap } from "applesauce-core/helpers/relay-selection";
+import { normalizeURL } from "applesauce-core/helpers/url";
 import { BehaviorSubject, distinctUntilChanged, isObservable, map, of, Subject } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay } from "./relay.js";

package/dist/relay.d.ts

@@ -1,11 +1,10 @@
-import { IAsyncEventStoreRead, IEventStoreRead, logger } from "applesauce-core";
-import { type FilterWithAnd } from "applesauce-core/helpers";
-import { type NostrEvent } from "nostr-tools";
-import { RelayInformation } from "nostr-tools/nip11";
+import { logger } from "applesauce-core";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { Filter } from "applesauce-core/helpers/filter";
 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, CountResponse, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { AuthSigner, CountResponse, FilterInput, IRelay, NegentropyReadStore, NegentropySyncStore, PublishOptions, PublishResponse, RelayInformation, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** Flags for the negentropy sync type */
 export declare enum SyncDirection {
     RECEIVE = 1,
@@ -106,13 +105,13 @@ export declare class Relay implements IRelay {
     /** 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: FilterWithAnd | FilterWithAnd[], id?: string): Observable<CountResponse>;
+    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 */
     auth(event: NostrEvent): Promise<PublishResponse>;
     /** Negentropy sync event ids with the relay and an event store */
-    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    negentropy(store: NegentropyReadStore, 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 */
@@ -130,7 +129,7 @@ export declare class Relay implements IRelay {
     /** 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: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(store: NegentropySyncStore, 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 */

package/dist/relay.js

@@ -1,8 +1,8 @@
 import { logger } from "applesauce-core";
-import { ensureHttpURL } from "applesauce-core/helpers";
-import { simpleTimeout } from "applesauce-core/observable";
+import { ensureHttpURL } from "applesauce-core/helpers/url";
+import { mapEventsToStore, simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
-import { nip42 } from "nostr-tools";
+import { makeAuthEvent } from "nostr-tools/nip42";
 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";
@@ -166,8 +166,15 @@ export class Relay {
         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));
+        this.authRequiredForRead$ = this.receivedAuthRequiredForReq;
+        this.authRequiredForPublish$ = this.receivedAuthRequiredForEvent;
+        // Log when auth is required
+        this.authRequiredForRead$
+            .pipe(filter((r) => r === true), take(1))
+            .subscribe(() => this.log("Auth required for REQ"));
+        this.authRequiredForPublish$
+            .pipe(filter((r) => r === true), take(1))
+            .subscribe(() => this.log("Auth required for EVENT"));
         // Update the notices state
         const listenForNotice = this.socket.pipe(
         // listen for NOTICE messages
@@ -320,9 +327,7 @@ export class Relay {
     /** 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());
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "COUNT" || m[0] === "CLOSED") && m[1] === id));
         // Send the COUNT message and listen for response
         const observable = defer(() => {
             // Send the COUNT message when subscription starts
@@ -343,11 +348,10 @@ export class Relay {
         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));
+        // Use share() to prevent multiple subscriptions from creating duplicate COUNT messages
+        return this.waitForReady(this.waitForAuth(this.authRequiredForRead$, observable)).pipe(share());
     }
     /** Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
@@ -378,14 +382,13 @@ export class Relay {
         timeout({
             first: this.eventTimeout,
             with: () => of({ ok: false, from: this.url, message: "Timeout" }),
-        }), 
-        // Only create one upstream subscription
-        share());
+        }));
         // skip wait for auth if verb is AUTH
+        // Use share() to prevent multiple subscriptions from creating duplicate EVENT messages
         if (verb === "AUTH")
-            return this.waitForReady(observable);
+            return this.waitForReady(observable).pipe(share());
         else
-            return this.waitForReady(this.waitForAuth(this.authRequiredForPublish$, observable));
+            return this.waitForReady(this.waitForAuth(this.authRequiredForPublish$, observable)).pipe(share());
     }
     /** send and AUTH message */
     auth(event) {
@@ -407,7 +410,7 @@ export class Relay {
     authenticate(signer) {
         if (!this.challenge)
             throw new Error("Have not received authentication challenge");
-        const p = signer.signEvent(nip42.makeAuthEvent(this.url, this.challenge));
+        const p = signer.signEvent(makeAuthEvent(this.url, this.challenge));
         const start = p instanceof Promise ? from(p) : of(p);
         return lastValueFrom(start.pipe(switchMap((event) => this.auth(event))));
     }
@@ -492,9 +495,7 @@ 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()));
+        this.customTimeoutOperator(opts?.timeout, this.publishTimeout)));
     }
     /** Negentropy sync events with the relay and an event store */
     sync(store, filter, direction = SyncDirection.RECEIVE) {
@@ -524,7 +525,15 @@ export class Relay {
                 }
                 // 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))));
+                    await lastValueFrom(this.req({ ids: need }).pipe(
+                    // Complete when EOSE is received
+                    completeOnEose(), 
+                    // Add events to the store if its writable
+                    Reflect.has(store, "add")
+                        ? mapEventsToStore(store)
+                        : identity, 
+                    // Pass events to observer
+                    tap((event) => observer.next(event))));
                 }
             }, { signal: controller.signal })
                 // Complete the observable when the sync is complete

package/dist/types.d.ts

@@ -1,7 +1,7 @@
-import type { IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core";
-import type { FilterWithAnd } from "applesauce-core/helpers";
-import type { EventTemplate, NostrEvent } from "nostr-tools";
-import type { RelayInformation } from "nostr-tools/nip11";
+import type { IAsyncEventStoreActions, IAsyncEventStoreRead, IEventStoreRead } from "applesauce-core/event-store";
+import type { Filter } from "applesauce-core/helpers/filter";
+import type { EventTemplate, NostrEvent } from "applesauce-core/helpers/event";
+import type { RelayInformation as CoreRelayInformation } from "nostr-tools/nip11";
 import type { Observable, repeat, retry } from "rxjs";
 import type { WebSocketSubject } from "rxjs/webSocket";
 import type { GroupNegentropySyncOptions, GroupRequestOptions, GroupSubscriptionOptions } from "./group.js";
@@ -60,7 +60,17 @@ export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
 /** Filters that can be passed to request methods on the pool or relay */
-export type FilterInput = FilterWithAnd | FilterWithAnd[] | Observable<FilterWithAnd | FilterWithAnd[]> | ((relay: IRelay) => FilterWithAnd | FilterWithAnd[] | Observable<FilterWithAnd | FilterWithAnd[]>);
+export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]> | ((relay: IRelay) => Filter | Filter[] | Observable<Filter | Filter[]>);
+export type RelayInformation = CoreRelayInformation & {
+    /** An array of attributes that describe the relay type/characteristics */
+    attributes?: string[];
+};
+/** A read only event store for negentropy sync */
+export type NegentropyReadStore = IEventStoreRead | IAsyncEventStoreRead | NostrEvent[];
+/** A writeable event store for negentropy sync */
+export type NegentropyWriteStore = (IAsyncEventStoreRead & IAsyncEventStoreActions) | (IEventStoreRead & IAsyncEventStoreActions);
+/** An event store that can be used for negentropy sync */
+export type NegentropySyncStore = NegentropyReadStore | NegentropyWriteStore;
 export interface IRelay extends MultiplexWebSocket {
     url: string;
     message$: Observable<any>;
@@ -82,13 +92,13 @@ export interface IRelay extends MultiplexWebSocket {
     /** Send a REQ message */
     req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send a COUNT message */
-    count(filters: FilterWithAnd | FilterWithAnd[], id?: string): Observable<CountResponse>;
+    count(filters: Filter | Filter[], id?: string): Observable<CountResponse>;
     /** Send an EVENT message */
     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: FilterWithAnd, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    negentropy(store: NegentropyReadStore, 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 */
@@ -98,7 +108,7 @@ export interface IRelay extends MultiplexWebSocket {
     /** 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: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(store: NegentropySyncStore, 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 */
@@ -113,7 +123,7 @@ export interface IGroup {
     /** Send an EVENT message */
     event(event: Parameters<IRelay["event"]>[0]): Observable<PublishResponse>;
     /** Negentropy sync event ids with the relays and an event store */
-    negentropy(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
+    negentropy(store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: NegentropySyncOptions): Promise<boolean>;
     /** Add a relay to the group */
     add(relay: IRelay): void;
     /** Remove a relay from the group */
@@ -127,9 +137,9 @@ export interface IGroup {
     /** Open a subscription with retries */
     subscription(filters: Parameters<IRelay["subscription"]>[0], opts?: GroupSubscriptionOptions): Observable<SubscriptionResponse>;
     /** Count events on the relays and an event store */
-    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 relay and an event store */
-    sync(store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(store: NegentropySyncStore, filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }
 /** Signals emitted by the pool */
 export interface IPoolSignals {
@@ -149,7 +159,7 @@ export interface IPool extends IPoolSignals {
     /** Send an EVENT message */
     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?: GroupNegentropySyncOptions): Promise<boolean>;
+    negentropy(relays: IPoolRelayInput, store: NegentropyReadStore, filter: Filter, reconcile: ReconcileFunction, opts?: GroupNegentropySyncOptions): Promise<boolean>;
     /** Send an EVENT message to relays with retries */
     publish(relays: IPoolRelayInput, event: Parameters<IGroup["publish"]>[0], opts?: Parameters<IGroup["publish"]>[1]): Promise<PublishResponse[]>;
     /** Send a REQ message to relays with retries */
@@ -157,7 +167,7 @@ export interface IPool extends IPoolSignals {
     /** Open a subscription to relays with retries */
     subscription(relays: IPoolRelayInput, filters: Parameters<IGroup["subscription"]>[0], opts?: Parameters<IGroup["subscription"]>[1]): Observable<SubscriptionResponse>;
     /** Count events on the relays and an event store */
-    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 relay and an event store */
-    sync(relays: IPoolRelayInput, store: IEventStoreRead | IAsyncEventStoreRead | NostrEvent[], filter: FilterWithAnd, direction?: SyncDirection): Observable<NostrEvent>;
+    sync(relays: IPoolRelayInput, store: NegentropySyncStore, filter: Filter, direction?: SyncDirection): Observable<NostrEvent>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20251117143754",
+  "version": "0.0.0-next-20251203172109",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -52,17 +52,17 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20251117143754",
+    "applesauce-core": "0.0.0-next-20251203172109",
     "nanoid": "^5.0.9",
-    "nostr-tools": "~2.17",
+    "nostr-tools": "~2.18",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "applesauce-signers": "^4.2.0",
+    "applesauce-signers": "0.0.0-next-20251203172109",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.2.4",
+    "vitest": "^4.0.15",
     "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {