applesauce-relay 0.0.0-next-20250404095409 → 0.0.0-next-20250411160531

package/README.md

@@ -2,8 +2,6 @@
 
 `applesauce-relay` is a nostr relay communication framework built on top of [RxJS](https://rxjs.dev/)
 
-> ⚠️ **Alpha Software Warning**: This package is in early alpha stage. It contains bugs, is not fully tested, and may undergo significant changes. Use with caution in production environments.
-
 ## Installation
 
 ```bash
@@ -15,10 +13,10 @@ npm install applesauce-relay
 - [x] NIP-01
 - [x] Client negentropy sync
 - [x] Relay pool and groups
-- [ ] Handle reconnects
-- [ ] Write tests
-- [ ] Handle NIP-11 limitations
-- [ ] Add documentation to docs
+- [x] Write tests
+- [ ] Reconnection logic
+- [ ] NIP-11 limitations
+- [ ] NIP-45 COUNT
 
 ## Examples
 

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

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

package/dist/__tests__/auth.test.js

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { WS } from "vitest-websocket-mock";
+import { Relay } from "../relay.js";
+let mockServer;
+let relay;
+beforeEach(async () => {
+    mockServer = new WS("wss://test");
+    relay = new Relay("wss://test");
+    // Create a persistent subscription to keep the connection open
+    // @ts-expect-error
+    subscribeSpyTo(relay.socket);
+});
+afterEach(async () => {
+    mockServer.close();
+    // Wait for server to close to prevent memory leaks
+    await WS.clean();
+});
+const mockEvent = {
+    kind: 1,
+    id: "00007641c9c3e65a71843933a44a18060c7c267a4f9169efa3735ece45c8f621",
+    pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+    created_at: 1743712795,
+    tags: [["nonce", "13835058055282167643", "16"]],
+    content: "This is just stupid: https://codestr.fiatjaf.com/",
+    sig: "5a57b5a12bba4b7cf0121077b1421cf4df402c5c221376c076204fc4f7519e28ce6508f26ddc132c406ccfe6e62cc6db857b96c788565cdca9674fe9a0710ac2",
+};
+describe("event", () => {
+    it("should wait for auth before sending EVENT if auth-required received", async () => {
+        // Create first event subscription
+        const spy1 = subscribeSpyTo(relay.event(mockEvent));
+        // Verify EVENT was sent
+        const firstEventMessage = await mockServer.nextMessage;
+        expect(JSON.parse(firstEventMessage)).toEqual(["EVENT", mockEvent]);
+        // Send auth-required response
+        mockServer.send(JSON.stringify(["OK", mockEvent.id, false, "auth-required: need to authenticate"]));
+        // Create second event subscription - this should not send EVENT yet
+        const spy2 = subscribeSpyTo(relay.event(mockEvent));
+        // Should not have received any messages
+        expect(mockServer.messages.length).toBe(1);
+        // Send AUTH challenge
+        mockServer.send(JSON.stringify(["AUTH", "challenge-string"]));
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        const authMessage = await mockServer.nextMessage;
+        expect(JSON.parse(authMessage)).toEqual(["AUTH", authEvent]);
+        // Send successful auth response
+        mockServer.send(JSON.stringify(["OK", authEvent.id, true, ""]));
+        // Now the second EVENT should be sent
+        const secondEventMessage = await mockServer.nextMessage;
+        expect(JSON.parse(secondEventMessage)).toEqual(["EVENT", mockEvent]);
+        // Send OK response for second event
+        mockServer.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy1.getLastValue()).toEqual({
+            ok: false,
+            message: "auth-required: need to authenticate",
+            from: "wss://test",
+        });
+        expect(spy2.getLastValue()).toEqual({ ok: true, message: "", from: "wss://test" });
+    });
+});
+describe("req", () => {
+    it("should wait for auth before sending REQ if auth-required received", async () => {
+        // Create first REQ subscription
+        const filters = [{ kinds: [1], limit: 10 }];
+        subscribeSpyTo(relay.req(filters, "sub1"));
+        // Verify REQ was sent
+        const firstReqMessage = await mockServer.nextMessage;
+        expect(JSON.parse(firstReqMessage)).toEqual(["REQ", "sub1", ...filters]);
+        // Send auth-required response
+        mockServer.send(JSON.stringify(["CLOSED", "sub1", "auth-required: need to authenticate"]));
+        // Consume the client CLOSE message for sub1
+        await mockServer.nextMessage;
+        // Create second REQ subscription - this should not send REQ yet
+        subscribeSpyTo(relay.req(filters, "sub2"));
+        // Should not have received any messages
+        expect(mockServer.messages).not.toContain(JSON.stringify(["REQ", "sub2", ...filters]));
+        // Send AUTH challenge
+        mockServer.send(JSON.stringify(["AUTH", "challenge-string"]));
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        const authMessage = await mockServer.nextMessage;
+        expect(JSON.parse(authMessage)).toEqual(["AUTH", authEvent]);
+        // Send successful auth response
+        mockServer.send(JSON.stringify(["OK", authEvent.id, true, ""]));
+        // Now the second REQ should be sent
+        const secondReqMessage = await mockServer.nextMessage;
+        expect(JSON.parse(secondReqMessage)).toEqual(["REQ", "sub2", ...filters]);
+        // Send some events for the second subscription
+        mockServer.send(JSON.stringify(["EVENT", "sub2", mockEvent]));
+        mockServer.send(JSON.stringify(["EOSE", "sub2"]));
+    });
+});
+describe("auth", () => {
+    it("should set authenticated state after successful AUTH challenge response", async () => {
+        // Send AUTH challenge
+        mockServer.send(JSON.stringify(["AUTH", "challenge-string"]));
+        // Send auth event response
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        const authMessage = await mockServer.nextMessage;
+        expect(JSON.parse(authMessage)).toEqual(["AUTH", authEvent]);
+        // Send successful auth response
+        mockServer.send(JSON.stringify(["OK", authEvent.id, true, ""]));
+        expect(relay.authenticated).toBe(true);
+    });
+});

package/dist/__tests__/faker.d.ts

@@ -0,0 +1,19 @@
+import * as Nostr from "nostr-typedef";
+export declare const faker: {
+    filter(filter?: Nostr.Filter): Nostr.Filter;
+    filters(): Nostr.Filter[];
+    event<const K extends number>(event?: Partial<Nostr.Event<K>>): Nostr.Event<K>;
+    AUTH(event?: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Nostr.ToRelayMessage.AUTH;
+    CLOSE(subId: string): Nostr.ToRelayMessage.CLOSE;
+    COUNT(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.COUNT;
+    EVENT(event?: Partial<Nostr.Event>): Nostr.ToRelayMessage.EVENT;
+    REQ(subId: string, filters?: Nostr.Filter[]): Nostr.ToRelayMessage.REQ;
+    toClientMessage: {
+        AUTH(message?: string): Nostr.ToClientMessage.AUTH;
+        COUNT(subId: string, count?: number): Nostr.ToClientMessage.COUNT;
+        EOSE(subId: string): Nostr.ToClientMessage.EOSE;
+        EVENT(subId: string, event?: Partial<Nostr.Event>): Nostr.ToClientMessage.EVENT;
+        NOTICE(message?: string): Nostr.ToClientMessage.NOTICE;
+        OK(eventId: string, succeeded: boolean, message?: string): Nostr.ToClientMessage.OK;
+    };
+};

package/dist/__tests__/faker.js

@@ -0,0 +1,56 @@
+import { kinds } from "nostr-tools";
+export const faker = {
+    filter(filter) {
+        return filter ?? { kinds: [0] };
+    },
+    filters() {
+        return [faker.filter()];
+    },
+    event(event) {
+        return {
+            id: "*",
+            content: "*",
+            created_at: 0,
+            kind: 0,
+            pubkey: "*",
+            sig: "*",
+            tags: [],
+            ...event,
+        };
+    },
+    AUTH(event) {
+        return ["AUTH", { ...faker.event(event), kind: kinds.ClientAuth }];
+    },
+    CLOSE(subId) {
+        return ["CLOSE", subId];
+    },
+    COUNT(subId, filters) {
+        return ["COUNT", subId, ...(filters ?? faker.filters())];
+    },
+    EVENT(event) {
+        return ["EVENT", faker.event(event)];
+    },
+    REQ(subId, filters) {
+        return ["REQ", subId, ...(filters ?? faker.filters())];
+    },
+    toClientMessage: {
+        AUTH(message) {
+            return ["AUTH", message ?? "*"];
+        },
+        COUNT(subId, count) {
+            return ["COUNT", subId, { count: count ?? 0 }];
+        },
+        EOSE(subId) {
+            return ["EOSE", subId];
+        },
+        EVENT(subId, event) {
+            return ["EVENT", subId, faker.event(event)];
+        },
+        NOTICE(message) {
+            return ["NOTICE", message ?? "*"];
+        },
+        OK(eventId, succeeded, message) {
+            return ["OK", eventId, succeeded, message ?? "*"];
+        },
+    },
+};

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

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

package/dist/__tests__/group.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { WS } from "vitest-websocket-mock";
+import { Relay } from "../relay.js";
+import { RelayGroup } from "../group.js";
+let mockRelay1;
+let mockRelay2;
+let relay1;
+let relay2;
+let group;
+let mockEvent;
+beforeEach(async () => {
+    mockRelay1 = new WS("wss://relay1.test");
+    mockRelay2 = new WS("wss://relay2.test");
+    relay1 = new Relay("wss://relay1.test");
+    relay2 = new Relay("wss://relay2.test");
+    group = new RelayGroup([relay1, relay2]);
+    mockEvent = {
+        kind: 1,
+        id: "test-id",
+        pubkey: "test-pubkey",
+        created_at: 1234567890,
+        tags: [],
+        content: "test content",
+        sig: "test-sig",
+    };
+});
+afterEach(async () => {
+    mockRelay1.close();
+    mockRelay2.close();
+    await WS.clean();
+});
+describe("req", () => {
+    it("should trigger connections to multiple relays", async () => {
+        group.req([{ kinds: [1] }], "test-sub").subscribe();
+        const req1 = await mockRelay1.nextMessage;
+        const req2 = await mockRelay2.nextMessage;
+        expect(JSON.parse(req1)).toEqual(["REQ", "test-sub", { kinds: [1] }]);
+        expect(JSON.parse(req2)).toEqual(["REQ", "test-sub", { kinds: [1] }]);
+    });
+    it("should emit events from all relays", async () => {
+        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
+        mockRelay1.send(JSON.stringify(["EVENT", "test-sub", { ...mockEvent, id: "1" }]));
+        mockRelay2.send(JSON.stringify(["EVENT", "test-sub", { ...mockEvent, id: "2" }]));
+        expect(spy.getValues()).toEqual([expect.objectContaining({ id: "1" }), expect.objectContaining({ id: "2" })]);
+    });
+    it("should only emit EOSE once all relays have emitted EOSE", async () => {
+        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
+        mockRelay1.send(JSON.stringify(["EOSE", "test-sub"]));
+        expect(spy.getValues()).not.toContain("EOSE");
+        mockRelay2.send(JSON.stringify(["EOSE", "test-sub"]));
+        expect(spy.getValues()).toContain("EOSE");
+    });
+    it("should ignore relays that have an error", async () => {
+        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
+        mockRelay1.error();
+        mockRelay2.send(JSON.stringify(["EVENT", "test-sub", mockEvent]));
+        mockRelay2.send(JSON.stringify(["EOSE", "test-sub"]));
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should emit EOSE if all relays error", async () => {
+        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
+        mockRelay1.error();
+        mockRelay2.error();
+        expect(spy.getValues()).toEqual(["EOSE"]);
+    });
+});
+describe("event", () => {
+    it("should send EVENT to all relays in the group", async () => {
+        group.event(mockEvent).subscribe();
+        const event1 = await mockRelay1.nextMessage;
+        const event2 = await mockRelay2.nextMessage;
+        expect(JSON.parse(event1)).toEqual(["EVENT", mockEvent]);
+        expect(JSON.parse(event2)).toEqual(["EVENT", mockEvent]);
+    });
+    it("should emit OK messages from all relays", async () => {
+        const spy = subscribeSpyTo(group.event(mockEvent));
+        mockRelay1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        mockRelay2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.getValues()).toEqual([
+            expect.objectContaining({ ok: true, from: "wss://relay1.test", message: "" }),
+            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
+        ]);
+    });
+    it("should complete when all relays have sent OK messages", async () => {
+        const spy = subscribeSpyTo(group.event(mockEvent));
+        mockRelay1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.receivedComplete()).toBe(false);
+        mockRelay2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.receivedComplete()).toBe(true);
+    });
+    it("should handle relay errors and still complete", async () => {
+        const spy = subscribeSpyTo(group.event(mockEvent));
+        mockRelay1.error();
+        mockRelay2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.getValues()).toEqual([
+            expect.objectContaining({ ok: false, from: "wss://relay1.test", message: "Unknown error" }),
+            expect.objectContaining({ ok: true, from: "wss://relay2.test", message: "" }),
+        ]);
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});

package/dist/__tests__/matchers.d.ts

@@ -0,0 +1,60 @@
+import Nostr from "nostr-typedef";
+declare module "vitest" {
+    interface Assertion<T = any> extends CustomMatchers {
+    }
+    interface AsymmetricMatchersContaining extends CustomMatchers {
+    }
+}
+interface CustomMatchers {
+    beToRelayAUTH(): void;
+    beToRelayAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): void;
+    beToRelayCLOSE(): void;
+    beToRelayCLOSE(subId: string): void;
+    beToRelayCOUNT(): void;
+    beToRelayCOUNT(subId: string): void;
+    beToRelayCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
+    beToRelayEVENT(): void;
+    beToRelayEVENT(event: Partial<Nostr.Event>): void;
+    beToRelayREQ(): void;
+    beToRelayREQ(subId: string): void;
+    beToRelayREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): void;
+    beToClientAUTH(): void;
+    beToClientAUTH(challengeMessage: string): void;
+    beToClientCOUNT(): void;
+    beToClientCOUNT(subId: string): void;
+    beToClientCOUNT(expected: [subId: string, count: number]): void;
+    beToClientEOSE(): void;
+    beToClientEOSE(subId: string): void;
+    beToClientEVENT(): void;
+    beToClientEVENT(subId: string): void;
+    beToClientEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): void;
+    beToClientNOTICE(): void;
+    beToClientNOTICE(message: string): void;
+    beToClientOK(expected: [eventId: string, succeeded: boolean, message?: string]): void;
+    toReceiveAUTH(): Promise<void>;
+    toReceiveAUTH(event: Partial<Nostr.Event<Nostr.Kind.ClientAuthentication>>): Promise<void>;
+    toReceiveCLOSE(): Promise<void>;
+    toReceiveCLOSE(subId: string): Promise<void>;
+    toReceiveCOUNT(): Promise<void>;
+    toReceiveCOUNT(subId: string): Promise<void>;
+    toReceiveCOUNT(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
+    toReceiveEVENT(): Promise<void>;
+    toReceiveEVENT(event: Partial<Nostr.Event>): Promise<void>;
+    toReceiveREQ(): Promise<void>;
+    toReceiveREQ(subId: string): Promise<void>;
+    toReceiveREQ(expected: [subId: string, ...filters: Nostr.Filter[]]): Promise<void>;
+    toSeeAUTH(): Promise<void>;
+    toSeeAUTH(challengeMessage: string): Promise<void>;
+    toSeeCOUNT(): Promise<void>;
+    toSeeCOUNT(subId: string): Promise<void>;
+    toSeeCOUNT(expected: [subId: string, count: number]): Promise<void>;
+    toSeeEOSE(): Promise<void>;
+    toSeeEOSE(subId: string): Promise<void>;
+    toSeeEVENT(): Promise<void>;
+    toSeeEVENT(subId: string): Promise<void>;
+    toSeeEVENT(expected: [subId: string, event: Partial<Nostr.Event>]): Promise<void>;
+    toSeeNOTICE(): Promise<void>;
+    toSeeNOTICE(message: string): Promise<void>;
+    toSeeOK(expected: [eventId: string, succeeded: boolean, message?: string]): Promise<void>;
+}
+export {};

package/dist/__tests__/matchers.js

@@ -0,0 +1,177 @@
+import { expect } from "vitest";
+import { deriveToReceiveMessage } from "vitest-websocket-mock";
+import { TimeoutError, withTimeout } from "./utils.js";
+const beToRelayAUTH = function (actual, event) {
+    const pass = isNostrMessage("AUTH", actual) && (event === undefined || matchEvent(actual[1], event, this.equals.bind(this)));
+    return {
+        message: message("a to-relay-AUTH message", ["AUTH", event ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToRelayCLOSE = function (actual, subId) {
+    const pass = isNostrMessage("CLOSE", actual) && (subId === undefined || actual[1] === subId);
+    return {
+        message: message("a to-relay-CLOSE message", ["CLOSE", subId ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToRelayCOUNT = function (actual, pred) {
+    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
+    const filters = typeof pred === "object" && pred !== undefined ? pred.slice(1) : null;
+    const pass = isNostrMessage("COUNT", actual) &&
+        (subId === null || actual[1] === subId) &&
+        (filters === null || this.equals(actual.slice(2), filters));
+    return {
+        message: message("a to-relay-COUNT message", ["COUNT", subId ?? "*", ...(filters === null ? ["*"] : filters)], this, actual, pass),
+        pass,
+    };
+};
+const beToRelayEVENT = function (actual, event) {
+    const pass = isNostrMessage("EVENT", actual) && (event === undefined || matchEvent(actual[1], event, this.equals.bind(this)));
+    return {
+        message: message("a to-relay-EVENT message", ["EVENT", event ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToRelayREQ = function (actual, pred) {
+    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
+    const filters = typeof pred === "object" && pred !== undefined ? pred.slice(1) : null;
+    const pass = isNostrMessage("REQ", actual) &&
+        (subId === null || actual[1] === subId) &&
+        (filters === null || this.equals(actual.slice(2), filters));
+    return {
+        message: message("a to-relay-REQ message", ["REQ", subId ?? "*", ...(filters === null ? ["*"] : filters)], this, actual, pass),
+        pass,
+    };
+};
+const beToClientAUTH = function (actual, challengeMessage) {
+    const pass = isNostrMessage("AUTH", actual) && (challengeMessage === undefined || actual[1] === challengeMessage);
+    return {
+        message: message("a to-client-AUTH message", ["AUTH", challengeMessage ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToClientCOUNT = function (actual, pred) {
+    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
+    const count = typeof pred === "object" && pred !== undefined ? pred[1] : null;
+    const pass = isNostrMessage("COUNT", actual) &&
+        (subId === null || actual[1] === subId) &&
+        (count === null || this.equals(actual[2], { count }));
+    return {
+        message: message("a to-client-COUNT message", ["COUNT", subId ?? "*", count === null ? "*" : { count }], this, actual, pass),
+        pass,
+    };
+};
+const beToClientEOSE = function (actual, subId) {
+    const pass = isNostrMessage("EOSE", actual) && (subId === undefined || actual[1] === subId);
+    return {
+        message: message("a to-client-EOSE message", ["COUNT", subId ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToClientEVENT = function (actual, pred) {
+    const subId = typeof pred === "string" ? pred : pred !== undefined ? pred[0] : null;
+    const event = typeof pred === "object" && pred !== undefined ? pred[1] : null;
+    const pass = isNostrMessage("EVENT", actual) &&
+        (subId === null || actual[1] === subId) &&
+        (event === null || matchEvent(actual[2], event, this.equals.bind(this)));
+    return {
+        message: message("a to-client-EVENT message", ["EVENT", subId ?? "*", event ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToClientNOTICE = function (actual, noticeMessage) {
+    const pass = isNostrMessage("NOTICE", actual) && (noticeMessage === undefined || actual[1] === noticeMessage);
+    return {
+        message: message("a to-client-NOTICE message", ["EVENT", noticeMessage ?? "*"], this, actual, pass),
+        pass,
+    };
+};
+const beToClientOK = function (actual, expected) {
+    const pass = isNostrMessage("OK", actual) &&
+        (expected === undefined ||
+            (actual[1] === expected[0] &&
+                actual[2] === expected[1] &&
+                (expected[2] === undefined || actual[3] === expected[2])));
+    return {
+        message: message("a to-client-OK message", ["OK", ...(expected ?? ["*", "*", "*"])], this, actual, pass),
+        pass,
+    };
+};
+const toReceiveAUTH = deriveToReceiveMessage("toReceiveAUTH", beToRelayAUTH);
+const toReceiveCLOSE = deriveToReceiveMessage("toReceiveCLOSE", beToRelayCLOSE);
+const toReceiveCOUNT = deriveToReceiveMessage("toReceiveCOUNT", beToRelayCOUNT);
+const toReceiveEVENT = deriveToReceiveMessage("toReceiveEVENT", beToRelayEVENT);
+const toReceiveREQ = deriveToReceiveMessage("toReceiveREQ", beToRelayREQ);
+const toSeeAUTH = clientMathcer("toSeeAUTH", beToClientAUTH);
+const toSeeCOUNT = clientMathcer("toSeeCOUNT", beToClientCOUNT);
+const toSeeEOSE = clientMathcer("toSeeEOSE", beToClientEOSE);
+const toSeeEVENT = clientMathcer("toSeeEVENT", beToClientEVENT);
+const toSeeNOTICE = clientMathcer("toSeeNOTICE", beToClientNOTICE);
+const toSeeOK = clientMathcer("toSeeOK", beToClientOK);
+expect.extend({
+    beToRelayAUTH,
+    beToRelayCLOSE,
+    beToRelayCOUNT,
+    beToRelayEVENT,
+    beToRelayREQ,
+    beToClientAUTH,
+    beToClientCOUNT,
+    beToClientEOSE,
+    beToClientEVENT,
+    beToClientNOTICE,
+    beToClientOK,
+    toReceiveAUTH,
+    toReceiveCLOSE,
+    toReceiveCOUNT,
+    toReceiveEVENT,
+    toReceiveREQ,
+    toSeeAUTH,
+    toSeeCOUNT,
+    toSeeEOSE,
+    toSeeEVENT,
+    toSeeNOTICE,
+    toSeeOK,
+});
+function clientMathcer(name, fn) {
+    return async function (spy, pred, options) {
+        if (spy.__createClientSpy) {
+            try {
+                return await withTimeout(async () => fn.call(this, await spy.next(), pred, options));
+            }
+            catch (err) {
+                if (err instanceof TimeoutError) {
+                    return {
+                        pass: this.isNot,
+                        message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "ClientSpy", "expected") +
+                            "\n\n" +
+                            `Client spy was waiting for the next message from the relay, but timed out.`,
+                    };
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        else {
+            return {
+                pass: this.isNot,
+                message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "ClientSpy", "expected") +
+                    "\n\n" +
+                    `Mathcer \`${name}\` must be used for ClientSpy, but now being used for:\n\n` +
+                    `${this.utils.printReceived(spy)}\n`,
+            };
+        }
+    };
+}
+function isNostrMessage(type, message) {
+    return Array.isArray(message) && message[0] === type;
+}
+function matchEvent(received, expected, equal) {
+    const eventKeys = ["id", "sig", "kind", "tags", "pubkey", "content", "created_at"];
+    const isEvent = (x) => typeof x === "object" && x !== null && eventKeys.every((key) => key in x);
+    return (isEvent(received) && eventKeys.every((key) => expected[key] === undefined || equal(received[key], expected[key])));
+}
+function message(entityName, expected, state, actual, pass) {
+    return () => `It was expected ${pass ? "not " : ""}to be ${entityName}, like this:\n\n${state.utils.printExpected(expected)}\n\nbut got:\n\n${state.utils.printReceived(actual)}\n`;
+}

package/dist/__tests__/mock.d.ts

@@ -0,0 +1,84 @@
+import { CloseOptions } from "mock-socket";
+import Nostr from "nostr-typedef";
+import { WS } from "vitest-websocket-mock";
+export interface MockServerSocket {
+    id: number;
+    send(message: unknown): void;
+    close(options?: CloseOptions): void;
+}
+export interface MockServerBehavior {
+    onOpen?(socket: MockServerSocket): void;
+    onMessage?(socket: MockServerSocket, message: string): void;
+    onClose?(socket: MockServerSocket): void;
+    onError?(socket: MockServerSocket, error: Error): void;
+}
+interface MockServer extends WS {
+    getSockets: (count: number, options?: {
+        timeout?: number;
+    }) => Promise<MockServerSocket[]>;
+    getSocket: (index: number) => Promise<MockServerSocket>;
+    getSocketsSync: () => MockServerSocket[];
+}
+export declare function createMockServer(url: string, behavior: MockServerBehavior): MockServer;
+export interface MockRelay extends MockServer {
+    /**
+     * Pop the latest message that has not yet been consumed.
+     * If such a message does not yet exist, it waits for the message
+     * until it times out.
+     *
+     * The default timeout is 1000 miliseconds.
+     */
+    next: (timeout?: number) => Promise<Nostr.ToRelayMessage.Any>;
+    /**
+     * Pop the latest `count` messages that have not yet been consumed.
+     * If such a message does not yet exist, it waits for the message
+     * until it times out.
+     *
+     * The default timeout is 1000 miliseconds.
+     */
+    nexts: (count: number, timeout?: number) => Promise<Nostr.ToRelayMessage.Any[]>;
+    /**
+     * Send messages of any format from the given socket mock.
+     * If `socket` is omitted, it will be sent from all active socket mocks.
+     *
+     * If the message is a string, as-is string will be sent,
+     * otherwise JSON strigify will be attempted.
+     *
+     * Note that the messages sent by this method are outside
+     * the management of the mock relay.
+     * This means that if, for example, you use this method to send an OK message,
+     * the mock relay will not know about it.
+     * Therefore, subsequent calls to emitOK() may send a duplicate OK message.
+     * */
+    emit(message: unknown, socket?: MockServerSocket): string;
+    /**
+     * Send COUNT messages from all socket mocks
+     * holding active COUNT subscriptions (in other words,
+     * subscriptions that have not yet responded with COUNT)
+     * with the given subId.
+     */
+    emitCOUNT(subId: string, count?: number): Nostr.ToClientMessage.COUNT;
+    /**
+     * Send EOSE messages from all socket mocks
+     * holding active REQ subscriptions (in other words,
+     * subscriptions that have not yet been CLOSE'd)
+     * with the given subId.
+     */
+    emitEOSE(subId: string): Nostr.ToClientMessage.EOSE;
+    /**
+     * Send EVENT messages from all socket mocks
+     * holding active REQ subscriptions (in other words,
+     * subscriptions that have not yet been CLOSE'd)
+     * with the given subId.
+     */
+    emitEVENT(subId: string, event?: Partial<Nostr.Event>): Nostr.ToClientMessage.EVENT;
+    /**
+     * Send OK messages from all socket mocks
+     * holding active EVENT (in other words, an EVENT
+     * that has not yet returned an OK message)
+     * with the given eventId.
+     */
+    emitOK(eventId: string, succeeded: boolean, message?: string): Nostr.ToClientMessage.OK;
+}
+export declare function createMockRelay(url: string): MockRelay;
+export {};

package/dist/__tests__/mock.js

@@ -0,0 +1,181 @@
+import { WS } from "vitest-websocket-mock";
+import { faker } from "./faker.js";
+import { withTimeout } from "./utils.js";
+export function createMockServer(url, behavior) {
+    const server = new WS(url, { jsonProtocol: true });
+    const sockets = [];
+    let resolvers = [];
+    let nextId = 1;
+    server.on("connection", (_socket) => {
+        const socket = {
+            id: nextId++,
+            send(message) {
+                if (_socket.readyState !== WebSocket.OPEN) {
+                    return;
+                }
+                _socket.send(typeof message === "string" ? message : `${JSON.stringify(message)}`);
+            },
+            close(options) {
+                _socket.close(options);
+            },
+        };
+        sockets.push(socket);
+        resolvers.filter(([count]) => count <= sockets.length).forEach(([, resolve]) => resolve([...sockets]));
+        resolvers = resolvers.filter(([count]) => count > sockets.length);
+        behavior.onOpen?.(socket);
+        _socket.on("message", (message) => {
+            if (typeof message !== "string") {
+                throw new Error("Unexpected type message");
+            }
+            behavior.onMessage?.(socket, message);
+        });
+        _socket.on("close", () => {
+            behavior.onClose?.(socket);
+        });
+        _socket.on("error", (error) => {
+            behavior.onError?.(socket, error);
+        });
+    });
+    const getSockets = async (count, options) => {
+        const promise = new Promise((resolve) => {
+            if (sockets.length >= count) {
+                resolve([...sockets]);
+            }
+            else {
+                resolvers.push([count, resolve]);
+            }
+        });
+        return withTimeout(promise, `Mock relay was waiting for ${count} connections to be established, but timed out.`, options?.timeout);
+    };
+    const getSocket = async (index) => {
+        const sockets = await getSockets(index + 1);
+        return sockets[index];
+    };
+    return Object.assign(server, {
+        getSockets,
+        getSocket,
+        getSocketsSync: () => [...sockets],
+    });
+}
+function relayBehavior() {
+    const reqs = new Map();
+    const counts = new Map();
+    const events = new Map();
+    const sockets = new Set();
+    return {
+        onOpen(socket) {
+            sockets.add(socket);
+        },
+        onMessage(socket, rawMessage) {
+            const message = JSON.parse(rawMessage);
+            switch (message[0]) {
+                case "CLOSE": {
+                    const subId = message[1];
+                    reqs.get(socket)?.delete(subId);
+                    break;
+                }
+                case "COUNT": {
+                    if (!counts.has(socket)) {
+                        counts.set(socket, new Set());
+                    }
+                    const subId = message[1];
+                    counts.get(socket)?.add(subId);
+                    break;
+                }
+                case "EVENT": {
+                    if (!events.has(socket)) {
+                        events.set(socket, new Set());
+                    }
+                    const eventId = message[1].id;
+                    events.get(socket)?.add(eventId);
+                    break;
+                }
+                case "REQ": {
+                    if (!reqs.has(socket)) {
+                        reqs.set(socket, new Set());
+                    }
+                    const subId = message[1];
+                    reqs.get(socket)?.add(subId);
+                    break;
+                }
+            }
+        },
+        onClose(socket) {
+            reqs.delete(socket);
+            counts.delete(socket);
+            events.delete(socket);
+            sockets.delete(socket);
+        },
+        emit(message, socket) {
+            const toBeSent = typeof message === "string" ? message : `${JSON.stringify(message)}`;
+            if (socket) {
+                socket.send(toBeSent);
+            }
+            else {
+                for (const socket of sockets) {
+                    socket.send(toBeSent);
+                }
+            }
+            return toBeSent;
+        },
+        emitCOUNT(subId, count) {
+            const toBeSent = faker.toClientMessage.COUNT(subId, count);
+            for (const [socket, subIds] of counts.entries()) {
+                if (subIds.has(subId)) {
+                    socket.send(toBeSent);
+                }
+                subIds.delete(subId);
+            }
+            return toBeSent;
+        },
+        emitEOSE(subId) {
+            const toBeSent = faker.toClientMessage.EOSE(subId);
+            for (const [socket, subIds] of reqs.entries()) {
+                if (subIds.has(subId)) {
+                    socket.send(toBeSent);
+                }
+            }
+            return toBeSent;
+        },
+        emitEVENT(subId, event) {
+            const toBeSent = faker.toClientMessage.EVENT(subId, event);
+            for (const [socket, subIds] of reqs.entries()) {
+                if (subIds.has(subId)) {
+                    socket.send(toBeSent);
+                }
+            }
+            return toBeSent;
+        },
+        emitOK(eventId, succeeded, message) {
+            const toBeSent = faker.toClientMessage.OK(eventId, succeeded, message);
+            for (const [socket, eventIds] of events.entries()) {
+                if (eventIds.has(eventId)) {
+                    socket.send(toBeSent);
+                }
+                eventIds.delete(eventId);
+            }
+            return toBeSent;
+        },
+    };
+}
+export function createMockRelay(url) {
+    const behavior = relayBehavior();
+    const server = createMockServer(url, behavior);
+    const { emit, emitCOUNT, emitEOSE, emitEVENT, emitOK } = behavior;
+    const timeoutMessage = "Mock relay was waiting for the next message from the client, but timed out.";
+    return Object.assign(server, {
+        next: (timeout) => withTimeout(server.nextMessage, timeoutMessage, timeout),
+        nexts: (count, timeout) => withTimeout(async () => {
+            const messages = [];
+            for (let i = 0; i < count; i++) {
+                messages.push((await server.nextMessage));
+            }
+            return messages;
+        }, timeoutMessage, timeout),
+        emit,
+        emitCOUNT,
+        emitEOSE,
+        emitEVENT,
+        emitOK,
+    });
+}

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

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

package/dist/__tests__/pool.test.js

@@ -0,0 +1,81 @@
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { WS } from "vitest-websocket-mock";
+import { RelayPool } from "../pool.js";
+let pool;
+let mockServer1;
+let mockServer2;
+let mockEvent;
+beforeEach(async () => {
+    // Create mock WebSocket servers
+    mockServer1 = new WS("wss://relay1.example.com");
+    mockServer2 = new WS("wss://relay2.example.com");
+    pool = new RelayPool();
+    mockEvent = {
+        kind: 1,
+        id: "test-id",
+        pubkey: "test-pubkey",
+        created_at: 1743712795,
+        tags: [],
+        content: "test content",
+        sig: "test-sig",
+    };
+});
+afterEach(async () => {
+    mockServer1.close();
+    mockServer2.close();
+    // Clean up WebSocket mocks
+    await WS.clean();
+});
+test("creates new relay connections", () => {
+    const url = "wss://relay1.example.com";
+    const relay = pool.relay(url);
+    expect(relay).toBeDefined();
+    expect(pool.relays.get(url)).toBe(relay);
+});
+test("returns existing relay connection if already exists", () => {
+    const url = "wss://relay1.example.com";
+    const relay1 = pool.relay(url);
+    const relay2 = pool.relay(url);
+    expect(relay1).toBe(relay2);
+    expect(pool.relays.size).toBe(1);
+});
+test("creates relay group with multiple relays", () => {
+    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
+    const group = pool.group(urls);
+    expect(group).toBeDefined();
+    expect(pool.groups.get(urls.sort().join(","))).toBe(group);
+});
+test("req method sends subscription to multiple relays", async () => {
+    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
+    const filters = { kinds: [1] };
+    const spy = subscribeSpyTo(pool.req(urls, filters));
+    // Verify REQ was sent to both relays
+    const req1 = await mockServer1.nextMessage;
+    const req2 = await mockServer2.nextMessage;
+    // Both messages should be REQ messages with the same filter
+    expect(JSON.parse(req1)[0]).toBe("REQ");
+    expect(JSON.parse(req2)[0]).toBe("REQ");
+    expect(JSON.parse(req1)[2]).toEqual(filters);
+    expect(JSON.parse(req2)[2]).toEqual(filters);
+    // Send EVENT from first relay
+    mockServer1.send(JSON.stringify(["EVENT", JSON.parse(req1)[1], mockEvent]));
+    // Send EOSE from both relays
+    mockServer1.send(JSON.stringify(["EOSE", JSON.parse(req1)[1]]));
+    mockServer2.send(JSON.stringify(["EOSE", JSON.parse(req2)[1]]));
+    expect(spy.getValues()).toContainEqual(expect.objectContaining(mockEvent));
+});
+test("event method publishes to multiple relays", async () => {
+    const urls = ["wss://relay1.example.com", "wss://relay2.example.com"];
+    const spy = subscribeSpyTo(pool.event(urls, mockEvent));
+    // Verify EVENT was sent to both relays
+    const event1 = await mockServer1.nextMessage;
+    const event2 = await mockServer2.nextMessage;
+    expect(JSON.parse(event1)).toEqual(["EVENT", mockEvent]);
+    expect(JSON.parse(event2)).toEqual(["EVENT", mockEvent]);
+    // Send OK responses from both relays
+    mockServer1.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+    mockServer2.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+    expect(spy.getValues()).toContainEqual({ ok: true, from: "wss://relay1.example.com", message: "" });
+    expect(spy.getValues()).toContainEqual({ ok: true, from: "wss://relay2.example.com", message: "" });
+});

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

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

package/dist/__tests__/relay.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { getSeenRelays } from "applesauce-core/helpers";
+import { WS } from "vitest-websocket-mock";
+import { Relay } from "../relay.js";
+let mockRelay;
+let relay;
+beforeEach(async () => {
+    mockRelay = new WS("wss://test");
+    relay = new Relay("wss://test");
+});
+afterEach(async () => {
+    mockRelay.close();
+    // Wait for server to close to prevent memory leaks
+    await WS.clean();
+});
+const mockEvent = {
+    kind: 1,
+    id: "00007641c9c3e65a71843933a44a18060c7c267a4f9169efa3735ece45c8f621",
+    pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+    created_at: 1743712795,
+    tags: [["nonce", "13835058055282167643", "16"]],
+    content: "This is just stupid: https://codestr.fiatjaf.com/",
+    sig: "5a57b5a12bba4b7cf0121077b1421cf4df402c5c221376c076204fc4f7519e28ce6508f26ddc132c406ccfe6e62cc6db857b96c788565cdca9674fe9a0710ac2",
+};
+describe("req", () => {
+    it("should send REQ and CLOSE messages", async () => {
+        // Create subscription that completes after first EOSE
+        const sub = relay.req([{ kinds: [1] }], "sub1").subscribe();
+        // Verify REQ was sent
+        const reqMessage = await mockRelay.nextMessage;
+        expect(JSON.parse(reqMessage)).toEqual(["REQ", "sub1", { kinds: [1] }]);
+        // Send EOSE to complete subscription
+        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        // Complete the subscription
+        sub.unsubscribe();
+        // Verify CLOSE was sent
+        const closeMessage = await mockRelay.nextMessage;
+        expect(JSON.parse(closeMessage)).toEqual(["CLOSE", "sub1"]);
+    });
+    it("should emit nostr event and EOSE", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Send EVENT message
+        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        // Send EOSE message
+        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should ignore EVENT and EOSE messages that do not match subscription id", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Send EVENT message with wrong subscription id
+        mockRelay.send(JSON.stringify(["EVENT", "wrong_sub", mockEvent]));
+        // Send EOSE message with wrong subscription id
+        mockRelay.send(JSON.stringify(["EOSE", "wrong_sub"]));
+        // Send EVENT message with correct subscription id
+        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        // Send EOSE message with correct subscription id
+        mockRelay.send(JSON.stringify(["EOSE", "sub1"]));
+        expect(spy.getValues()).toEqual([expect.objectContaining(mockEvent), "EOSE"]);
+    });
+    it("should mark events with their source relay", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Send EVENT message
+        mockRelay.send(JSON.stringify(["EVENT", "sub1", mockEvent]));
+        // Get the received event
+        const receivedEvent = spy.getValues()[0];
+        // Verify the event was marked as seen from this relay
+        expect(getSeenRelays(receivedEvent)).toContain("wss://test");
+    });
+    it("should complete subscription when CLOSED message is received", async () => {
+        const spy = subscribeSpyTo(relay.req([{ kinds: [1] }], "sub1"));
+        // Send CLOSED message for the subscription
+        mockRelay.send(JSON.stringify(["CLOSED", "sub1", "reason"]));
+        // Verify the subscription completed
+        expect(spy.receivedComplete()).toBe(true);
+    });
+});
+describe("event", () => {
+    it("observable should complete when matching OK response received", async () => {
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        // Verify EVENT message was sent
+        const eventMessage = await mockRelay.nextMessage;
+        expect(JSON.parse(eventMessage)).toEqual(["EVENT", mockEvent]);
+        // Send matching OK response
+        mockRelay.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        await spy.onComplete();
+        expect(spy.receivedComplete()).toBe(true);
+    });
+    it("should ignore OK responses for different events", async () => {
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        // Send non-matching OK response
+        mockRelay.send(JSON.stringify(["OK", "different_id", true, ""]));
+        expect(spy.receivedComplete()).toBe(false);
+        // Send matching OK response
+        mockRelay.send(JSON.stringify(["OK", mockEvent.id, true, ""]));
+        expect(spy.receivedComplete()).toBe(true);
+    });
+    it("should send EVENT message to relay", async () => {
+        relay.event(mockEvent).subscribe();
+        const eventMessage = await mockRelay.nextMessage;
+        expect(JSON.parse(eventMessage)).toEqual(["EVENT", mockEvent]);
+    });
+    it("should complete with error if no OK received within 10s", async () => {
+        vi.useFakeTimers();
+        const spy = subscribeSpyTo(relay.event(mockEvent));
+        // Fast-forward time by 10 seconds
+        await vi.advanceTimersByTimeAsync(10000);
+        expect(spy.receivedComplete()).toBe(true);
+        expect(spy.getLastValue()).toEqual({ ok: false, from: "wss://test", message: "Timeout" });
+    });
+});
+describe("notice$", () => {
+    it("should accumulate notices in notices$ state", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        // Send multiple NOTICE messages
+        mockRelay.send(JSON.stringify(["NOTICE", "Notice 1"]));
+        mockRelay.send(JSON.stringify(["NOTICE", "Notice 2"]));
+        mockRelay.send(JSON.stringify(["NOTICE", "Notice 3"]));
+        // Verify the notices state contains all messages
+        expect(relay.notices$.value).toEqual(["Notice 1", "Notice 2", "Notice 3"]);
+    });
+    it("should ignore non-NOTICE messages", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        mockRelay.send(JSON.stringify(["NOTICE", "Important notice"]));
+        mockRelay.send(JSON.stringify(["OTHER", "other message"]));
+        // Verify only NOTICE messages are in the state
+        expect(relay.notices$.value).toEqual(["Important notice"]);
+    });
+});
+describe("challenge$", () => {
+    it("should set challenge$ when AUTH message received", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        // Send AUTH message with challenge string
+        mockRelay.send(JSON.stringify(["AUTH", "challenge-string-123"]));
+        // Verify challenge$ was set
+        expect(relay.challenge$.value).toBe("challenge-string-123");
+    });
+    it("should ignore non-AUTH messages", async () => {
+        subscribeSpyTo(relay.req({ kinds: [1] }));
+        mockRelay.send(JSON.stringify(["NOTICE", "Not a challenge"]));
+        mockRelay.send(JSON.stringify(["OTHER", "other message"]));
+        // Verify challenge$ remains null
+        expect(relay.challenge$.value).toBe(null);
+    });
+});

package/dist/__tests__/spy.d.ts

@@ -0,0 +1,7 @@
+import Nostr from "nostr-typedef";
+export interface ClientSpy {
+    __createClientSpy: true;
+    next: () => Promise<Nostr.ToClientMessage.Any>;
+    dispose: () => void;
+}
+export declare function createClientSpy(addOnMessageListener: (listener: (message: Nostr.ToClientMessage.Any) => void) => void): ClientSpy;

package/dist/__tests__/spy.js

@@ -0,0 +1,65 @@
+export function createClientSpy(addOnMessageListener) {
+    let queue = { type: "empty" };
+    addOnMessageListener((message) => {
+        switch (queue.type) {
+            case "empty": {
+                queue = {
+                    type: "message",
+                    items: [message],
+                };
+                break;
+            }
+            case "message": {
+                queue.items.push(message);
+                break;
+            }
+            case "resolver": {
+                const item = queue.items.shift();
+                if (item) {
+                    const resolve = item[0];
+                    resolve(message);
+                }
+                if (queue.items.length <= 0) {
+                    queue = { type: "empty" };
+                }
+            }
+        }
+    });
+    return {
+        __createClientSpy: true,
+        next: () => new Promise((resolve, reject) => {
+            switch (queue.type) {
+                case "empty": {
+                    queue = {
+                        type: "resolver",
+                        items: [[resolve, reject]],
+                    };
+                    break;
+                }
+                case "message": {
+                    const msg = queue.items.shift();
+                    if (msg) {
+                        resolve(msg);
+                    }
+                    if (queue.items.length <= 0) {
+                        queue = { type: "empty" };
+                    }
+                    break;
+                }
+                case "resolver": {
+                    queue.items.push([resolve, reject]);
+                    break;
+                }
+            }
+        }),
+        dispose: () => {
+            if (queue.type === "resolver") {
+                for (const item of queue.items) {
+                    const reject = item[1];
+                    reject(new Error());
+                }
+            }
+            queue = { type: "empty" };
+        },
+    };
+}

package/dist/__tests__/utils.d.ts

@@ -0,0 +1,3 @@
+export declare class TimeoutError extends Error {
+}
+export declare function withTimeout<T>(task: Promise<T> | (() => Promise<T>), message?: string, timeout?: number): Promise<T>;

package/dist/__tests__/utils.js

@@ -0,0 +1,8 @@
+export class TimeoutError extends Error {
+}
+export function withTimeout(task, message, timeout = 1000) {
+    return Promise.race([
+        typeof task === "function" ? task() : task,
+        new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(message)), timeout)),
+    ]);
+}

package/dist/group.js

@@ -1,6 +1,7 @@
-import { catchError, combineLatest, EMPTY, filter, map, merge, of } from "rxjs";
+import { catchError, endWith, ignoreElements, merge, of } from "rxjs";
 import { nanoid } from "nanoid";
 import { onlyEvents } from "./operators/only-events.js";
+import { completeOnEose } from "./operators/complete-on-eose.js";
 export class RelayGroup {
     relays;
     constructor(relays) {
@@ -11,14 +12,16 @@ export class RelayGroup {
             ...acc,
             [relay.url]: relay.req(filters, id).pipe(
             // Ignore connection errors
-            catchError(() => EMPTY)),
+            catchError(() => of("EOSE"))),
         }), {});
         // Create stream of events only
         const events = merge(...Object.values(requests)).pipe(onlyEvents());
         // Create stream that emits EOSE when all relays have sent EOSE
-        const eose = combineLatest(
+        const eose = merge(
         // Create a new map of requests that only emits EOSE
-        Object.fromEntries(Object.entries(requests).map(([url, observable]) => [url, observable.pipe(filter((m) => m === "EOSE"))]))).pipe(map(() => "EOSE"));
+        ...Object.values(requests).map((observable) => observable.pipe(completeOnEose(), ignoreElements()))).pipe(
+        // When all relays have sent EOSE, emit EOSE
+        endWith("EOSE"));
         // Merge events and the single EOSE stream
         return merge(events, eose);
     }

package/dist/relay.d.ts

@@ -22,6 +22,10 @@ export declare class Relay implements IRelay {
     get challenge(): string | null;
     get notices(): string[];
     get authenticated(): boolean;
+    /** If an EOSE message is not seen in this time, emit one locally  */
+    eoseTimeout: number;
+    /** How long to wait for an OK message from the relay */
+    eventTimeout: number;
     protected authRequiredForReq: BehaviorSubject<boolean>;
     protected authRequiredForPublish: BehaviorSubject<boolean>;
     protected resetState(): void;

package/dist/relay.js

@@ -28,6 +28,10 @@ export class Relay {
     get authenticated() {
         return this.authenticated$.value;
     }
+    /** If an EOSE message is not seen in this time, emit one locally  */
+    eoseTimeout = 10_000;
+    /** How long to wait for an OK message from the relay */
+    eventTimeout = 10_000;
     authRequiredForReq = new BehaviorSubject(false);
     authRequiredForPublish = new BehaviorSubject(false);
     resetState() {
@@ -116,18 +120,19 @@ export class Relay {
     }
     /** Create a REQ observable that emits events | "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] === "CLOSE" || message[0] === "EOSE") && message[1] === id)
-            .pipe(
-        // listen for CLOSE auth-required
+        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(
+        // listen for CLOSED auth-required
         tap((m) => {
-            if (m[0] === "CLOSE" && m[1].startsWith("auth-required") && !this.authRequiredForReq.value) {
+            if (m[0] === "CLOSED" && m[2] && m[2].startsWith("auth-required") && !this.authRequiredForReq.value) {
                 this.log("Auth required for REQ");
                 this.authRequiredForReq.next(true);
             }
         }), 
         // complete when CLOSE is sent
-        takeWhile((m) => m[0] !== "CLOSE"), 
+        takeWhile((m) => m[0] !== "CLOSED"), 
         // pick event out of EVENT messages
         map((message) => {
             if (message[0] === "EOSE")
@@ -140,11 +145,11 @@ export class Relay {
         // if no events are seen in 10s, emit EOSE
         // TODO: this should emit EOSE event if events are seen, the timeout should be for only the EOSE message
         timeout({
-            first: 10_000,
+            first: this.eoseTimeout,
             with: () => merge(of("EOSE"), NEVER),
         }));
         // Wait for auth if required and make sure to start the watch tower
-        return this.waitForAuth(this.authRequiredForReq, merge(this.watchTower, request));
+        return this.waitForAuth(this.authRequiredForReq, observable);
     }
     /** send an Event message and always return an observable of PublishResponse that completes or errors */
     event(event, verb = "EVENT") {
@@ -167,6 +172,11 @@ export class Relay {
                 this.log("Auth required for publish");
                 this.authRequiredForPublish.next(true);
             }
+        }), 
+        // if no message is seen in 10s, emit EOSE
+        timeout({
+            first: this.eventTimeout,
+            with: () => of({ ok: false, from: this.url, message: "Timeout" }),
         }));
         // skip wait for auth if verb is AUTH
         if (verb === "AUTH")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-relay",
-  "version": "0.0.0-next-20250404095409",
+  "version": "0.0.0-next-20250411160531",
   "description": "nostr relay communication framework built on rxjs",
   "type": "module",
   "main": "dist/index.js",
@@ -54,16 +54,17 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.7.1",
-    "applesauce-core": "0.0.0-next-20250404095409",
+    "applesauce-core": "0.0.0-next-20250411160531",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
+    "@hirez_io/observer-spy": "^2.2.0",
+    "@vitest/expect": "^3.1.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.5",
-    "vitest-nostr": "^0.4.1",
-    "vitest-websocket-mock": "^0.4.0"
+    "vitest": "^3.1.1",
+    "vitest-websocket-mock": "^0.5.0"
   },
   "funding": {
     "type": "lightning",