applesauce-relay 0.0.0-next-20250505205231 → 0.0.0-next-20250526151506

package/dist/__tests__/exports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/exports.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "Relay",
+        "RelayGroup",
+        "RelayPool",
+        "ReqCloseError",
+        "completeOnEose",
+        "markFromRelay",
+        "onlyEvents",
+        "storeEvents",
+        "toEventStore",
+      ]
+    `);
+    });
+});

package/dist/__tests__/fake-user.d.ts

@@ -0,0 +1,10 @@
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import type { NostrEvent } from "nostr-tools";
+export declare class FakeUser extends SimpleSigner {
+    pubkey: string;
+    event(data?: Partial<NostrEvent>): NostrEvent;
+    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    profile(profile?: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    contacts(pubkeys?: string[]): import("nostr-tools").Event;
+    list(tags?: string[][], extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+}

package/dist/__tests__/fake-user.js

@@ -0,0 +1,31 @@
+import { unixNow } from "applesauce-core/helpers";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import { finalizeEvent, getPublicKey, kinds } from "nostr-tools";
+export class FakeUser extends SimpleSigner {
+    pubkey = getPublicKey(this.key);
+    event(data) {
+        return finalizeEvent({
+            kind: data?.kind ?? kinds.ShortTextNote,
+            content: data?.content || "",
+            created_at: data?.created_at ?? unixNow(),
+            tags: data?.tags || [],
+        }, this.key);
+    }
+    note(content = "Hello World", extra) {
+        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
+    }
+    profile(profile = {}, extra) {
+        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
+    }
+    contacts(pubkeys = []) {
+        return this.event({ kind: kinds.Contacts, tags: pubkeys.map((p) => ["p", p]) });
+    }
+    list(tags = [], extra) {
+        return this.event({
+            kind: kinds.Bookmarksets,
+            content: "",
+            tags: [["d", String(Math.round(Math.random() * 10000))], ...tags],
+            ...extra,
+        });
+    }
+}

package/dist/__tests__/relay.test.js

@@ -4,7 +4,7 @@ import { getSeenRelays } from "applesauce-core/helpers";
 import { WS } from "vitest-websocket-mock";
 import { Relay } from "../relay.js";
 import { filter } from "rxjs/operators";
-import { firstValueFrom, of, throwError, timer } from "rxjs";
+import { firstValueFrom, of, Subject, throwError, timer } from "rxjs";
 const defaultMockInfo = {
     name: "Test Relay",
     description: "Test Relay Description",
@@ -144,7 +144,7 @@ describe("req", () => {
         // Verify the second subscription received the event and EOSE
         expect(secondSub.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
     });
-    it("should wait for authentication if relay info document has limitations.auth_required = true", async () => {
+    it("should open connection and wait for authentication if relay info document has limitations.auth_required = true", async () => {
         // Mock the fetchInformationDocument method to return a document with auth_required = true
         vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of({
             name: "Auth Required Relay",
@@ -162,10 +162,20 @@ describe("req", () => {
         const sub = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
         // Wait 10ms to ensure the information document is fetched
         await new Promise((resolve) => setTimeout(resolve, 10));
+        // Wait for connection
+        await server.connected;
         // Verify no REQ message was sent yet (waiting for auth)
         expect(server).not.toHaveReceivedMessages(["REQ", "sub1", { kinds: [1] }]);
+        // Send AUTH challenge
+        server.send(["AUTH", "challenge"]);
+        // Send auth response
+        subscribeSpyTo(relay.auth(mockEvent));
+        // Verify the auth event was sent
+        await expect(server.nextMessage).resolves.toEqual(["AUTH", mockEvent]);
+        // Accept auth
+        server.send(["OK", mockEvent.id, true, ""]);
         // Simulate successful authentication
-        relay.authenticated$.next(true);
+        expect(relay.authenticated).toBe(true);
         // Now the REQ should be sent
         await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
         // Send EVENT and EOSE to complete the subscription
@@ -208,6 +218,41 @@ describe("req", () => {
         relay.ready$.next(true);
         await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
     });
+    it("should wait for filters if filters are provided as an observable", async () => {
+        const filters = new Subject();
+        subscribeSpyTo(relay.req(filters, "sub1"));
+        // Wait 10sm and ensure no messages were sent yet
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(server.messagesToConsume.pendingItems.length).toBe(0);
+        // Send REQ message with filters
+        filters.next([{ kinds: [1] }]);
+        // Wait for the REQ message to be sent
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+    });
+    it("should update filters if filters are provided as an observable", async () => {
+        const filters = new Subject();
+        subscribeSpyTo(relay.req(filters, "sub1"));
+        // Send REQ message with filters
+        filters.next([{ kinds: [1] }]);
+        // Should send REQ message with new filters
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [1] }]);
+        // Send REQ message with filters
+        filters.next([{ kinds: [2] }]);
+        // Should send new REQ message with new filters
+        await expect(server).toReceiveMessage(["REQ", "sub1", { kinds: [2] }]);
+        // It should not send CLOSE message
+        await expect(server.messages).not.toContain(["CLOSE", "sub1"]);
+    });
+    it("should complete if filters are provided as an observable that completes", async () => {
+        const filters = new Subject();
+        const sub = subscribeSpyTo(relay.req(filters, "sub1"));
+        // Send REQ message with filters
+        filters.next([{ kinds: [1] }]);
+        // Complete the observable
+        filters.complete();
+        await sub.onComplete();
+        expect(sub.receivedComplete()).toBe(true);
+    });
 });
 describe("event", () => {
     it("should wait for authentication if relay responds with auth-required", async () => {

package/dist/group.d.ts

@@ -1,19 +1,19 @@
-import { Filter, NostrEvent } from "nostr-tools";
+import { type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
-import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions } from "./types.js";
+import { IGroup, IRelay, PublishResponse, SubscriptionResponse, PublishOptions, RequestOptions, SubscriptionOptions, FilterInput } from "./types.js";
 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 */
-    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an event to all relays */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Publish an event to all relays with retries ( default 3 retries ) */
     publish(event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
     /** Request events from all relays with retries ( default 3 retries ) */
-    request(filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    request(filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to all relays with retries ( default 3 retries ) */
-    subscription(filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

package/dist/operators/__tests__/exports.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/operators/__tests__/exports.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "completeOnEose",
+        "markFromRelay",
+        "onlyEvents",
+        "storeEvents",
+        "toEventStore",
+      ]
+    `);
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/operators/__tests__/to-event-store.test.js

@@ -0,0 +1,18 @@
+import { EventStore } from "applesauce-core";
+import { describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { of } from "rxjs";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { toEventStore } from "../to-event-store.js";
+const user = new FakeUser();
+describe("toEventStore", () => {
+    it("should remove duplicate events", () => {
+        const eventStore = new EventStore();
+        const event = user.note("original content");
+        const source = of(event, { ...event }, { ...event }, { ...event });
+        const spy = subscribeSpyTo(source.pipe(toEventStore(eventStore)));
+        expect(spy.getValuesLength()).toBe(1);
+        expect(spy.getValueAt(0).length).toBe(1);
+        expect(spy.getValueAt(0)[0]).toBe(event);
+    });
+});

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

@@ -1,5 +1,5 @@
 import { IEventStore } from "applesauce-core";
 import { MonoTypeOperatorFunction } from "rxjs";
 import { SubscriptionResponse } from "../types.js";
-/** Sends all events to the event store */
+/** Sends all events to the event store but does not remove duplicates */
 export declare function storeEvents(eventStore: IEventStore): MonoTypeOperatorFunction<SubscriptionResponse>;

package/dist/operators/store-events.js

@@ -1,5 +1,5 @@
 import { tap } from "rxjs";
-/** Sends all events to the event store */
+/** Sends all events to the event store but does not remove duplicates */
 export function storeEvents(eventStore) {
     return (source) => {
         return source.pipe(tap((event) => typeof event !== "string" && eventStore.add(event)));

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

@@ -2,5 +2,8 @@ import { OperatorFunction } from "rxjs";
 import { IEventStore } from "applesauce-core";
 import { NostrEvent } from "nostr-tools";
 import { SubscriptionResponse } from "../types.js";
-/** Adds all events to event store and returns a deduplicated timeline when EOSE is received */
+/**
+ * Adds all events to event store and returns a deduplicated timeline when EOSE is received
+ * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
+ */
 export declare function toEventStore(eventStore: IEventStore): OperatorFunction<SubscriptionResponse, NostrEvent[]>;

package/dist/operators/to-event-store.js

@@ -1,19 +1,15 @@
-import { scan } from "rxjs";
-import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { mapEventsToStore, mapEventsToTimeline } from "applesauce-core/observable";
 import { completeOnEose } from "./complete-on-eose.js";
-/** Adds all events to event store and returns a deduplicated timeline when EOSE is received */
+/**
+ * Adds all events to event store and returns a deduplicated timeline when EOSE is received
+ * @deprecated use `mapEventsToStore` and `mapEventsToTimeline` instead
+ */
 export function toEventStore(eventStore) {
     return (source) => source.pipe(
     // Complete when there are not events
     completeOnEose(), 
+    // Save events to store and remove duplicates
+    mapEventsToStore(eventStore, true), 
     // Add the events to an array
-    scan((events, event) => {
-        // Get the current instance of this event
-        let e = eventStore.add(event);
-        // If its not in the timeline, add it
-        if (events.includes(e))
-            return events;
-        else
-            return insertEventIntoDescendingList(events, e);
-    }, []));
+    mapEventsToTimeline());
 }

package/dist/pool.d.ts

@@ -1,8 +1,8 @@
-import { NostrEvent, type Filter } from "nostr-tools";
+import { type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { RelayGroup } from "./group.js";
 import { Relay, RelayOptions } from "./relay.js";
-import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { IPool, PublishResponse, PublishOptions, RequestOptions, SubscriptionOptions, SubscriptionResponse, FilterInput } from "./types.js";
 export declare class RelayPool implements IPool {
     options?: RelayOptions | undefined;
     groups$: BehaviorSubject<Map<string, RelayGroup>>;
@@ -18,13 +18,13 @@ export declare class RelayPool implements IPool {
     /** Create a group of relays */
     group(relays: string[]): RelayGroup;
     /** Make a REQ to multiple relays that does not deduplicate events */
-    req(relays: string[], filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Send an EVENT message to multiple relays */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Publish an event to multiple relays */
     publish(relays: string[], event: NostrEvent, opts?: PublishOptions): Observable<PublishResponse>;
     /** Request events from multiple relays */
-    request(relays: string[], filters: Filter | Filter[], opts?: RequestOptions): Observable<NostrEvent>;
+    request(relays: string[], filters: FilterInput, opts?: RequestOptions): Observable<NostrEvent>;
     /** Open a subscription to multiple relays */
-    subscription(relays: string[], filters: Filter | Filter[], opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
+    subscription(relays: string[], filters: FilterInput, opts?: SubscriptionOptions): Observable<SubscriptionResponse>;
 }

package/dist/relay.d.ts

@@ -3,7 +3,7 @@ import { type Filter, type NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable } from "rxjs";
 import { WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
 import { RelayInformation } from "nostr-tools/nip11";
-import { AuthSigner, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
+import { AuthSigner, FilterInput, IRelay, PublishOptions, PublishResponse, RequestOptions, SubscriptionOptions, SubscriptionResponse } from "./types.js";
 /** An error that is thrown when a REQ is closed from the relay side */
 export declare class ReqCloseError extends Error {
 }
@@ -61,12 +61,12 @@ export declare class Relay implements IRelay {
     protected authRequiredForReq: Observable<boolean>;
     protected authRequiredForEvent: Observable<boolean>;
     protected resetState(): void;
-    /** An internal observable that is responsible for watching all messages and updating state */
+    /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     protected watchTower: Observable<never>;
     constructor(url: string, opts?: RelayOptions);
     /** Set ready = false and start the reconnect timer */
     protected startReconnectTimer(error: Error | CloseEvent): void;
-    /** Wait for ready and authenticated */
+    /** Wait for authentication state, make connection and then wait for authentication if required */
     protected waitForAuth<T extends unknown = unknown>(requireAuth: Observable<boolean>, observable: Observable<T>): Observable<T>;
     /** Wait for the relay to be ready to accept connections */
     protected waitForReady<T extends unknown = unknown>(observable: Observable<T>): Observable<T>;
@@ -74,7 +74,7 @@ export declare class Relay implements IRelay {
     /** Send a message to the relay */
     next(message: any): void;
     /** Create a REQ observable that emits events or "EOSE" or errors */
-    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** 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 */

package/dist/relay.js

@@ -2,7 +2,7 @@ import { logger } from "applesauce-core";
 import { simpleTimeout } from "applesauce-core/observable";
 import { nanoid } from "nanoid";
 import { nip42 } from "nostr-tools";
-import { BehaviorSubject, catchError, combineLatest, defer, filter, from, ignoreElements, map, merge, mergeMap, NEVER, of, retry, scan, share, shareReplay, Subject, switchMap, take, tap, throwError, timeout, timer, } from "rxjs";
+import { BehaviorSubject, catchError, combineLatest, defer, endWith, filter, finalize, from, ignoreElements, isObservable, map, merge, mergeMap, mergeWith, NEVER, of, 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";
@@ -85,7 +85,7 @@ export class Relay {
         if (this.receivedAuthRequiredForEvent.value)
             this.receivedAuthRequiredForEvent.next(false);
     }
-    /** An internal observable that is responsible for watching all messages and updating state */
+    /** An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay */
     watchTower;
     constructor(url, opts) {
         this.url = url;
@@ -190,11 +190,13 @@ export class Relay {
             .pipe(take(1))
             .subscribe(() => this.ready$.next(true));
     }
-    /** Wait for ready and authenticated */
+    /** Wait for authentication state, make connection and then wait for authentication if required */
     waitForAuth(
     // NOTE: require BehaviorSubject so it always has a value
     requireAuth, observable) {
         return combineLatest([requireAuth, this.authenticated$]).pipe(
+        // Once the auth state is known, make a connection and watch for auth challenges
+        mergeWith(this.watchTower), 
         // wait for auth not required or authenticated
         filter(([required, authenticated]) => !required || authenticated), 
         // complete after the first value so this does not repeat
@@ -225,10 +227,24 @@ export class Relay {
     }
     /** Create a REQ observable that emits events or "EOSE" or errors */
     req(filters, id = nanoid()) {
-        const request = this.socket.multiplex(() => (Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters]), () => ["CLOSE", id], (message) => (message[0] === "EVENT" || message[0] === "CLOSED" || message[0] === "EOSE") && message[1] === id);
-        // Start the watch tower with the observable
-        const withWatchTower = merge(this.watchTower, request);
-        const observable = withWatchTower.pipe(
+        // Convert filters input into an observable, if its a normal value merge it with NEVER so it never completes
+        const input = isObservable(filters) ? filters : merge(of(filters), NEVER);
+        // Create an observable that completes when the upstream observable completes
+        const complete = input.pipe(ignoreElements(), endWith(null));
+        // Create an observable that filters responses from the relay to just the ones for this REQ
+        const messages = this.socket.pipe(filter((m) => Array.isArray(m) && (m[0] === "EVENT" || m[0] === "CLOSED" || m[0] === "EOSE") && m[1] === id));
+        // Create an observable that controls sending the filters and closing the REQ
+        const control = input.pipe(
+        // Send the filters when they change
+        tap((filters) => this.socket.next(Array.isArray(filters) ? ["REQ", id, ...filters] : ["REQ", id, filters])), 
+        // Close the req when unsubscribed
+        finalize(() => this.socket.next(["CLOSE", id])), 
+        // Once filters have been sent, switch to listening for messages
+        switchMap(() => messages));
+        // Start the watch tower with the observables
+        const observable = merge(this.watchTower, control).pipe(
+        // Complete the subscription when the input is completed
+        takeUntil(complete), 
         // Map the messages to events, EOSE, or throw an error
         map((message) => {
             if (message[0] === "EOSE")
@@ -270,10 +286,8 @@ export class Relay {
             // format OK message
             map((m) => ({ ok: m[2], message: m[3], from: this.url })));
         });
-        // Start the watch tower with the observable
-        const withWatchTower = merge(this.watchTower, base);
-        // Add complete operators
-        const observable = withWatchTower.pipe(
+        // Start the watch tower and add complete operators
+        const observable = merge(this.watchTower, base).pipe(
         // complete on first value
         take(1), 
         // listen for OK auth-required

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import { type EventTemplate, type Filter, type NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { WebSocketSubject } from "rxjs/webSocket";
 export type SubscriptionResponse = NostrEvent | "EOSE";
@@ -28,11 +28,13 @@ export type SubscriptionOptions = {
 export type AuthSigner = {
     signEvent: (event: EventTemplate) => NostrEvent | Promise<NostrEvent>;
 };
+/** The type of input the REQ method accepts */
+export type FilterInput = Filter | Filter[] | Observable<Filter | Filter[]>;
 export interface Nip01Actions {
     /** Send an EVENT message */
     event(event: NostrEvent): Observable<PublishResponse>;
     /** Send a REQ message */
-    req(filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
 }
 export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
     url: string;
@@ -52,12 +54,12 @@ export interface IRelay extends MultiplexWebSocket, Nip01Actions, IRelayState {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message with retries */
-    request(filters: Filter | Filter[], opts?: {
+    request(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: Filter | Filter[], opts?: {
+    subscription(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;
@@ -68,12 +70,12 @@ export interface IGroup extends Nip01Actions {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message with retries */
-    request(filters: Filter | Filter[], opts?: {
+    request(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription with retries */
-    subscription(filters: Filter | Filter[], opts?: {
+    subscription(filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;
@@ -82,7 +84,7 @@ export interface IPool {
     /** Send an EVENT message */
     event(relays: string[], event: NostrEvent): Observable<PublishResponse>;
     /** Send a REQ message */
-    req(relays: string[], filters: Filter | Filter[], id?: string): Observable<SubscriptionResponse>;
+    req(relays: string[], filters: FilterInput, id?: string): Observable<SubscriptionResponse>;
     /** Get or create a relay */
     relay(url: string): IRelay;
     /** Create a relay group */
@@ -92,12 +94,12 @@ export interface IPool {
         retries?: number;
     }): Observable<PublishResponse>;
     /** Send a REQ message to relays with retries */
-    request(relays: string[], filters: Filter | Filter[], opts?: {
+    request(relays: string[], filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<NostrEvent>;
     /** Open a subscription to relays with retries */
-    subscription(relays: string[], filters: Filter | Filter[], opts?: {
+    subscription(relays: string[], filters: FilterInput, opts?: {
         id?: string;
         retries?: number;
     }): Observable<SubscriptionResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250505205231",
+  "version": "0.0.0-next-20250526151506",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,13 +54,14 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "^1.0.0",
+    "applesauce-core": "0.0.0-next-20250526151506",
     "nanoid": "^5.0.9",
-    "nostr-tools": "^2.10.4",
+    "nostr-tools": "^2.13",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
+    "applesauce-signers": "0.0.0-next-20250526151506",
     "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
     "vitest": "^3.1.1",