applesauce-relay 0.0.0-next-20250808173123 → 0.0.0-next-20250815164532

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

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

package/dist/__tests__/auth.test.js

@@ -0,0 +1,111 @@
+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 server;
+let relay;
+beforeEach(async () => {
+    server = new WS("wss://test", { jsonProtocol: true });
+    relay = new Relay("wss://test");
+    // Create a persistent subscription to keep the connection open
+    // @ts-expect-error
+    subscribeSpyTo(relay.socket);
+});
+afterEach(async () => {
+    server.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 server.nextMessage;
+        expect(firstEventMessage).toEqual(["EVENT", mockEvent]);
+        // Send auth-required response
+        server.send(["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(server.messages.length).toBe(1);
+        // Send AUTH challenge
+        server.send(["AUTH", "challenge-string"]);
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        const authMessage = await server.nextMessage;
+        expect(authMessage).toEqual(["AUTH", authEvent]);
+        // Send successful auth response
+        server.send(["OK", authEvent.id, true, ""]);
+        // Now the second EVENT should be sent
+        const secondEventMessage = await server.nextMessage;
+        expect(secondEventMessage).toEqual(["EVENT", mockEvent]);
+        // Send OK response for second event
+        server.send(["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"), { expectErrors: true });
+        // Verify REQ was sent
+        const firstReqMessage = await server.nextMessage;
+        expect(firstReqMessage).toEqual(["REQ", "sub1", ...filters]);
+        // Send auth-required response
+        server.send(["CLOSED", "sub1", "auth-required: need to authenticate"]);
+        // Consume the client CLOSE message for sub1
+        await server.nextMessage;
+        // Create second REQ subscription - this should not send REQ yet
+        subscribeSpyTo(relay.req(filters, "sub2"), { expectErrors: true });
+        // Should not have received any messages
+        expect(server.messages).not.toContain(["REQ", "sub2", ...filters]);
+        // Send AUTH challenge
+        server.send(["AUTH", "challenge-string"]);
+        // Send auth event
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        const authMessage = await server.nextMessage;
+        expect(authMessage).toEqual(["AUTH", authEvent]);
+        // Send successful auth response
+        server.send(["OK", authEvent.id, true, ""]);
+        // Now the second REQ should be sent
+        const secondReqMessage = await server.nextMessage;
+        expect(secondReqMessage).toEqual(["REQ", "sub2", ...filters]);
+        // Send some events for the second subscription
+        server.send(["EVENT", "sub2", mockEvent]);
+        server.send(["EOSE", "sub2"]);
+    });
+});
+describe("auth", () => {
+    it("should set authenticated state after successful AUTH challenge response", async () => {
+        // Send AUTH challenge
+        server.send(["AUTH", "challenge-string"]);
+        // Send auth event response
+        const authEvent = { ...mockEvent, id: "auth-id" };
+        subscribeSpyTo(relay.auth(authEvent));
+        // Verify AUTH was sent
+        await expect(server).toReceiveMessage(["AUTH", authEvent]);
+        // Send successful auth response
+        server.send(["OK", authEvent.id, true, ""]);
+        expect(relay.authenticated).toBe(true);
+    });
+});

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__/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,106 @@
+import { describe, it, expect, beforeEach, afterEach, vi } 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";
+import { of } from "rxjs";
+let mockRelay1;
+let mockRelay2;
+let relay1;
+let relay2;
+let group;
+let mockEvent;
+beforeEach(async () => {
+    // Create mock relays
+    mockRelay1 = new WS("wss://relay1.test", { jsonProtocol: true });
+    mockRelay2 = new WS("wss://relay2.test", { jsonProtocol: true });
+    // Mock empty information document
+    vi.spyOn(Relay, "fetchInformationDocument").mockImplementation(() => of(null));
+    // Create relays
+    relay1 = new Relay("wss://relay1.test");
+    relay2 = new Relay("wss://relay2.test");
+    // Create group
+    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 make requests to multiple relays", async () => {
+        group.req([{ kinds: [1] }], "test-sub").subscribe();
+        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
+        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
+    });
+    it("should emit events from all relays", async () => {
+        const spy = subscribeSpyTo(group.req([{ kinds: [1] }], "test-sub"));
+        await expect(mockRelay1).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
+        await expect(mockRelay2).toReceiveMessage(["REQ", "test-sub", { kinds: [1] }]);
+        mockRelay1.send(["EVENT", "test-sub", { ...mockEvent, id: "1" }]);
+        mockRelay2.send(["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(["EOSE", "test-sub"]);
+        expect(spy.getValues()).not.toContain("EOSE");
+        mockRelay2.send(["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(["EVENT", "test-sub", mockEvent]);
+        mockRelay2.send(["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();
+        await expect(mockRelay1).toReceiveMessage(["EVENT", mockEvent]);
+        await expect(mockRelay2).toReceiveMessage(["EVENT", mockEvent]);
+    });
+    it("should emit OK messages from all relays", async () => {
+        const spy = subscribeSpyTo(group.event(mockEvent));
+        mockRelay1.send(["OK", mockEvent.id, true, ""]);
+        mockRelay2.send(["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(["OK", mockEvent.id, true, ""]);
+        expect(spy.receivedComplete()).toBe(false);
+        mockRelay2.send(["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(["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`;
+}