import {

createStartAccountContext,

createPluginRuntimeMock,

expectStopPendingUntilAbort,

startAccountAndTrackLifecycle,

waitForStartedMocks,

} from "openclaw/plugin-sdk/channel-test-helpers";

import { afterEach, describe, expect, it, vi } from "vitest";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { getActiveNostrBuses, startNostrGatewayAccount } from "./gateway.js";

import { setNostrRuntime } from "./runtime.js";

import { buildResolvedNostrAccount } from "./test-fixtures.js";

const mocks = vi.hoisted(() => ({

}

describe("nostr gateway lifecycle", () => {

beforeEach(() => {

setNostrRuntime(createPluginRuntimeMock());

});

afterEach(() => {

mocks.startNostrBus.mockReset();

});

} | null,

subscribeMany: vi.fn(),

close: vi.fn(),

subscriptionClose: vi.fn(),

verifyEvent: vi.fn(() => true),

decrypt: vi.fn(() => "plaintext"),

publishProfile: vi.fn(async () => ({

mockState.subscribeMany(relays, filters, handlers);

mockState.handlers = handlers;

return {

close: vi.fn(),

close: mockState.subscriptionClose,

};

}

mockState.handlers = null;

mockState.subscribeMany.mockClear();

mockState.close.mockClear();

mockState.subscriptionClose.mockReset();

mockState.verifyEvent.mockClear();

mockState.verifyEvent.mockReturnValue(true);

mockState.decrypt.mockClear();

});

});

it("closes the relay pool after the active subscription closes", async () => {

let releaseClose = () => {};

const subscriptionClosed = new Promise<void>((resolve) => {

releaseClose = resolve;

});

mockState.subscriptionClose.mockImplementationOnce(async () => {

await subscriptionClosed;

});

const bus = await startNostrBus({

privateKey: TEST_HEX_PRIVATE_KEY,

relays: ["wss://relay.example"],

onMessage: vi.fn(async () => {}),

onMetric: () => {},

});

bus.close();

expect(mockState.subscriptionClose).toHaveBeenCalledWith("closed by caller");

expect(mockState.close).not.toHaveBeenCalled();

releaseClose();

await vi.waitFor(() => {

expect(mockState.close).toHaveBeenCalledWith(["wss://relay.example"]);

});

});

it("checks sender authorization after verify and before decrypt", async () => {

const onMessage = vi.fn(async () => {});

const authorizeSender = vi.fn(async () => "block" as const);

}

export interface NostrBusHandle {

/** Stop the bus and close connections */

/** Stop the bus and close relay connections */

close: () => void;

/** Get the bot's public key */

publicKey: string;

const dmFilter = { kinds: [4], "#p": [pk], since } satisfies Parameters<

typeof pool.subscribeMany

>[1];

const relayAbort = new AbortController();

const sub = pool.subscribeMany(relays, dmFilter, {

onevent: handleEvent,

oneose: () => {

}

onError?.(new Error(`Subscription closed: ${reason.join(", ")}`), "subscription");

},

abort: relayAbort.signal,

});

// Public sendDm function

return {

close: () => {

sub.close();

setTimeout(() => pool.close(relays), 0);

relayAbort.abort("closed by caller");

void Promise.resolve(sub.close("closed by caller"))

.catch((err) => onError?.(err as Error, "close subscription"))

.finally(() => {

pool.close(relays);

});

seen.stop();

perSenderRateLimiter.clear();

globalRateLimiter.clear();