@qntx/nostr 0.0.1 → 0.2.0

package/dist/testing.mjs

@@ -0,0 +1,957 @@
+import { c as isRecord, i as bytesToHex, l as normalizeURL } from "./util-LfQirgDk.mjs";
+import { t as Kind } from "./kind-Cxwhhkx8.mjs";
+import { m as validateSignedEvent, t as compareEventsDesc, y as isTag } from "./event-D8Nfoh4K.mjs";
+import { r as finalizeEvent, s as verifyEvent, t as Keys } from "./key-Bbtys6o7.mjs";
+import { t as EventBuilder } from "./builder-CyrGKRVP.mjs";
+import { a as matchFilter } from "./filter-BQl3GlHt.mjs";
+import { decrypt, encrypt, getConversationKey } from "./nips/nip44.mjs";
+import { decodeNip46Request, encodeNip46Response } from "./nips/nip46.mjs";
+import { Negentropy, storageFromEvents } from "./nips/nip77.mjs";
+import { t as MemoryEventStore } from "./memory-C2EVx0_O.mjs";
+//#region src/testing/relay-core.ts
+/** Wire filters are trusted as NIP-01 filters once they are records. */
+function isFilter(value) {
+	return isRecord(value);
+}
+function searchMatch(filter, event) {
+	if (filter.search === void 0) return true;
+	return event.content.toLowerCase().includes(filter.search.toLowerCase());
+}
+function subMatches(filters, event) {
+	return filters.some((f) => matchFilter(f, event) && searchMatch(f, event));
+}
+/** Put outcomes that made the event part of the relay's live stream. */
+function isLivePut(result) {
+	return result === "accepted" || result === "replaced" || result === "deleted" || result === "ephemeral";
+}
+function mayReadKinds(filters, readKinds) {
+	return filters.some((f) => f.kinds === void 0 || f.kinds.some((k) => readKinds.includes(k)));
+}
+/**
+* Transport-agnostic fake relay: one NIP-01/42/45/50/77 session state machine per connection,
+* storage via {@link MemoryEventStore}. No timers except `latencyMs`; no global state.
+*/
+var FakeRelayCore = class {
+	url;
+	#opts;
+	#store = new MemoryEventStore();
+	#sessions = /* @__PURE__ */ new Set();
+	#mirror = /* @__PURE__ */ new Map();
+	#inbox = [];
+	#pending = Promise.resolve();
+	constructor(url, opts = {}) {
+		this.url = normalizeURL(url);
+		this.#opts = opts;
+	}
+	configure(opts) {
+		this.#opts = {
+			...this.#opts,
+			...opts
+		};
+	}
+	seed(events) {
+		for (const event of events) this.#mirror.set(event.id, event);
+		this.#pending = (async () => {
+			await this.#pending;
+			for (const event of events) await this.#store.put(event);
+			await this.#refreshMirror();
+		})();
+	}
+	events() {
+		return [...this.#mirror.values()];
+	}
+	inject(event) {
+		this.#pending = (async () => {
+			await this.#pending;
+			const result = await this.#store.put(event);
+			await this.#refreshMirror();
+			if (isLivePut(result)) this.#deliver(event);
+		})();
+	}
+	disconnect() {
+		const sessions = [...this.#sessions];
+		this.#sessions.clear();
+		for (const session of sessions) session.transport.close();
+	}
+	closeSubscriptions(reason) {
+		for (const session of this.#sessions) {
+			for (const id of session.subs.keys()) this.#send(session, [
+				"CLOSED",
+				id,
+				reason
+			]);
+			session.subs.clear();
+			session.negs.clear();
+		}
+	}
+	clientMessages() {
+		return this.#inbox;
+	}
+	/** Attach a transport; returns a handle for {@link handleMessage}/detach. */
+	connect(transport) {
+		const session = {
+			transport,
+			subs: /* @__PURE__ */ new Map(),
+			negs: /* @__PURE__ */ new Map(),
+			authed: false,
+			queue: Promise.resolve()
+		};
+		this.#sessions.add(session);
+		if (this.#opts.auth) this.#send(session, ["AUTH", this.#opts.auth.challenge]);
+		return session;
+	}
+	detach(session) {
+		this.#sessions.delete(session);
+	}
+	/** Feed a raw client→relay frame. Messages of one session are handled in order. */
+	handleMessage(session, raw) {
+		session.queue = (async () => {
+			try {
+				await session.queue;
+				await this.#handle(session, raw);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				try {
+					this.#send(session, ["NOTICE", `error: ${message}`]);
+				} catch {}
+			}
+		})();
+	}
+	async #refreshMirror() {
+		const all = await this.#store.query([{}]);
+		this.#mirror = new Map(all.map((e) => [e.id, e]));
+	}
+	#send(session, message) {
+		const payload = JSON.stringify(message);
+		const { latencyMs } = this.#opts;
+		if (latencyMs !== void 0 && latencyMs > 0) {
+			setTimeout(() => session.transport.send(payload), latencyMs);
+			return;
+		}
+		session.transport.send(payload);
+	}
+	#deliver(event) {
+		for (const session of this.#sessions) for (const [id, filters] of session.subs) if (subMatches(filters, event)) this.#send(session, [
+			"EVENT",
+			id,
+			event
+		]);
+	}
+	async #matched(filters) {
+		const keptPerFilter = await Promise.all(filters.map(async (filter) => {
+			const unbounded = { ...filter };
+			delete unbounded.limit;
+			const rows = (await this.#store.query([unbounded])).filter((event) => searchMatch(filter, event));
+			rows.sort(compareEventsDesc);
+			return filter.limit === void 0 ? rows : rows.slice(0, filter.limit);
+		}));
+		const seen = /* @__PURE__ */ new Map();
+		for (const kept of keptPerFilter) for (const event of kept) if (!seen.has(event.id)) seen.set(event.id, event);
+		const matched = [...seen.values()];
+		matched.sort(compareEventsDesc);
+		return matched;
+	}
+	async #handle(session, raw) {
+		await this.#pending;
+		let msg;
+		try {
+			msg = JSON.parse(raw);
+		} catch {
+			this.#send(session, ["NOTICE", "error: invalid message"]);
+			return;
+		}
+		if (!Array.isArray(msg)) {
+			this.#send(session, ["NOTICE", "error: invalid message"]);
+			return;
+		}
+		const items = msg;
+		const [type] = items;
+		if (typeof type !== "string") {
+			this.#send(session, ["NOTICE", "error: invalid message"]);
+			return;
+		}
+		this.#inbox.push(msg);
+		switch (type) {
+			case "EVENT": {
+				const [, rawEvent] = items;
+				if (!isRecord(rawEvent) || typeof rawEvent["id"] !== "string") {
+					this.#send(session, ["NOTICE", "invalid: malformed event"]);
+					return;
+				}
+				const event = rawEvent;
+				if (this.#opts.rateLimited === true) {
+					this.#send(session, [
+						"OK",
+						event.id,
+						false,
+						"rate-limited: slow down"
+					]);
+					return;
+				}
+				if (this.#opts.auth?.writes === true && !session.authed) {
+					this.#send(session, [
+						"OK",
+						event.id,
+						false,
+						"auth-required: login first"
+					]);
+					return;
+				}
+				if (!verifyEvent(event)) {
+					this.#send(session, [
+						"OK",
+						event.id,
+						false,
+						"invalid: signature or id"
+					]);
+					return;
+				}
+				const result = await this.#store.put(event);
+				await this.#refreshMirror();
+				if (result === "rejected") {
+					this.#send(session, [
+						"OK",
+						event.id,
+						false,
+						"invalid: a newer version of this event exists"
+					]);
+					return;
+				}
+				if (result === "invalid") {
+					this.#send(session, [
+						"OK",
+						event.id,
+						false,
+						"invalid: malformed event"
+					]);
+					return;
+				}
+				if (result === "duplicate") {
+					this.#send(session, [
+						"OK",
+						event.id,
+						true,
+						"duplicate: already have this event"
+					]);
+					return;
+				}
+				this.#send(session, [
+					"OK",
+					event.id,
+					true,
+					""
+				]);
+				this.#deliver(event);
+				return;
+			}
+			case "REQ": {
+				const [, id] = items;
+				const filters = items.slice(2);
+				if (typeof id !== "string" || filters.length === 0 || !filters.every(isFilter)) {
+					this.#send(session, ["NOTICE", "error: invalid REQ"]);
+					return;
+				}
+				const readKinds = this.#opts.auth?.readKinds;
+				if (readKinds !== void 0 && !session.authed && mayReadKinds(filters, readKinds)) {
+					this.#send(session, [
+						"CLOSED",
+						id,
+						"auth-required: we only serve to authed users"
+					]);
+					return;
+				}
+				session.subs.set(id, filters);
+				const matched = await this.#matched(filters);
+				if (this.#opts.eoseBeforeEvents === true) this.#send(session, ["EOSE", id]);
+				for (const event of matched) this.#send(session, [
+					"EVENT",
+					id,
+					event
+				]);
+				if (this.#opts.eoseBeforeEvents !== true) this.#send(session, ["EOSE", id]);
+				return;
+			}
+			case "CLOSE": {
+				const [, id] = items;
+				if (typeof id === "string") session.subs.delete(id);
+				return;
+			}
+			case "COUNT": {
+				const [, id] = items;
+				const filters = items.slice(2);
+				if (typeof id !== "string" || !filters.every(isFilter)) {
+					this.#send(session, ["NOTICE", "error: invalid COUNT"]);
+					return;
+				}
+				const matched = await this.#matched(filters);
+				this.#send(session, [
+					"COUNT",
+					id,
+					{ count: matched.length }
+				]);
+				return;
+			}
+			case "AUTH": {
+				const { auth } = this.#opts;
+				const [, rawAuth] = items;
+				if (!validateSignedEvent(rawAuth)) {
+					this.#send(session, [
+						"OK",
+						"0".repeat(64),
+						false,
+						"error: invalid auth event"
+					]);
+					return;
+				}
+				const challengeTag = rawAuth.tags.find((t) => t[0] === "challenge")?.[1];
+				const relayTag = rawAuth.tags.find((t) => t[0] === "relay")?.[1];
+				let relayOk = false;
+				if (relayTag !== void 0) try {
+					relayOk = normalizeURL(relayTag) === this.url;
+				} catch {}
+				if (auth !== void 0 && rawAuth.kind === Kind.ClientAuth && verifyEvent(rawAuth) && challengeTag === auth.challenge && relayOk) {
+					session.authed = true;
+					this.#send(session, [
+						"OK",
+						rawAuth.id,
+						true,
+						""
+					]);
+					return;
+				}
+				this.#send(session, [
+					"OK",
+					rawAuth.id,
+					false,
+					"error: invalid auth event"
+				]);
+				return;
+			}
+			case "NEG-OPEN": {
+				if (items.length === 5) {
+					this.#send(session, [
+						"NEG-ERR",
+						items[1],
+						"error: obsolete 5-element NEG-OPEN"
+					]);
+					return;
+				}
+				const [, id, rawFilter, negMessage] = items;
+				if (items.length !== 4 || typeof id !== "string" || !isFilter(rawFilter) || typeof negMessage !== "string") {
+					const badId = typeof id === "string" ? id : "";
+					this.#send(session, [
+						"NEG-ERR",
+						badId,
+						"error: invalid NEG-OPEN"
+					]);
+					return;
+				}
+				const matched = await this.#matched([rawFilter]);
+				const neg = new Negentropy(storageFromEvents(matched));
+				let opened;
+				try {
+					opened = neg.reconcile(negMessage).nextMessage ?? void 0;
+				} catch {
+					this.#send(session, [
+						"NEG-ERR",
+						id,
+						"error: invalid negentropy message"
+					]);
+					return;
+				}
+				session.negs.set(id, neg);
+				this.#send(session, [
+					"NEG-MSG",
+					id,
+					opened ?? bytesToHex(new Uint8Array([97]))
+				]);
+				return;
+			}
+			case "NEG-MSG": {
+				const [, id, negMessage] = items;
+				if (items.length !== 3 || typeof id !== "string" || typeof negMessage !== "string") return;
+				const handle = session.negs.get(id);
+				if (handle === void 0) {
+					this.#send(session, [
+						"NEG-ERR",
+						id,
+						"closed: unknown subscription"
+					]);
+					return;
+				}
+				let next;
+				try {
+					next = handle.reconcile(negMessage).nextMessage ?? void 0;
+				} catch {
+					session.negs.delete(id);
+					this.#send(session, [
+						"NEG-ERR",
+						id,
+						"error: invalid negentropy message"
+					]);
+					return;
+				}
+				this.#send(session, [
+					"NEG-MSG",
+					id,
+					next ?? bytesToHex(new Uint8Array([97]))
+				]);
+				return;
+			}
+			case "NEG-CLOSE": {
+				const [, id] = items;
+				if (typeof id === "string") session.negs.delete(id);
+				return;
+			}
+			default: this.#send(session, ["NOTICE", `error: unsupported ${type}`]);
+		}
+	}
+};
+//#endregion
+//#region src/testing/network.ts
+/**
+* In-process fake relay network. `new websocketImplementation(url)` opens a socket bound to the
+* network's relay for that URL; `send` is dispatched to the relay session directly (no polling).
+*/
+function createFakeRelayNetwork(defaults = {}) {
+	const cores = /* @__PURE__ */ new Map();
+	const coreFor = (url, opts) => {
+		const key = normalizeURL(url);
+		let core = cores.get(key);
+		if (!core) {
+			core = new FakeRelayCore(key, {
+				...defaults,
+				...opts
+			});
+			cores.set(key, core);
+		} else if (opts) core.configure(opts);
+		return core;
+	};
+	class FakeSocket {
+		static OPEN = 1;
+		static CONNECTING = 0;
+		static CLOSING = 2;
+		static CLOSED = 3;
+		url;
+		/** Client→relay frames, for tests that inspect wire traffic. */
+		sent = [];
+		readyState = FakeSocket.CONNECTING;
+		#listeners = /* @__PURE__ */ new Map();
+		#session;
+		#queuedSends = [];
+		#core;
+		constructor(url) {
+			this.url = url;
+			this.#core = coreFor(url);
+			queueMicrotask(() => this.#open());
+		}
+		#open() {
+			if (this.readyState !== FakeSocket.CONNECTING) return;
+			this.readyState = FakeSocket.OPEN;
+			const transport = {
+				send: (data) => this.#emit("message", { data }),
+				close: () => this.#terminate()
+			};
+			this.#emit("open", {});
+			this.#session = this.#core.connect(transport);
+			const queued = this.#queuedSends;
+			this.#queuedSends = [];
+			for (const data of queued) this.#core.handleMessage(this.#session, data);
+		}
+		send(data) {
+			if (this.readyState !== FakeSocket.OPEN) return;
+			this.sent.push(data);
+			if (this.#session) this.#core.handleMessage(this.#session, data);
+			else this.#queuedSends.push(data);
+		}
+		close() {
+			this.#terminate();
+		}
+		#terminate() {
+			if (this.readyState === FakeSocket.CLOSING || this.readyState === FakeSocket.CLOSED) {
+				this.readyState = FakeSocket.CLOSED;
+				return;
+			}
+			this.readyState = FakeSocket.CLOSED;
+			const session = this.#session;
+			this.#session = void 0;
+			if (session) this.#core.detach(session);
+			this.#emit("close", {});
+		}
+		addEventListener(type, listener) {
+			let set = this.#listeners.get(type);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				this.#listeners.set(type, set);
+			}
+			set.add(listener);
+		}
+		removeEventListener(type, listener) {
+			this.#listeners.get(type)?.delete(listener);
+		}
+		#emit(type, ev) {
+			for (const listener of this.#listeners.get(type) ?? []) listener(ev);
+		}
+	}
+	return {
+		websocketImplementation: FakeSocket,
+		relay: coreFor,
+		close() {
+			for (const core of cores.values()) core.disconnect();
+			cores.clear();
+		}
+	};
+}
+//#endregion
+//#region src/testing/serve.ts
+/**
+* Serve the fake relay on a real WebSocket port via the optional `ws` peer dependency (dynamic
+* import — `@qntx/nostr/testing` never requires `ws` unless you serve). `port: 0` picks an
+* ephemeral port.
+*/
+async function serveFakeRelay(opts = {}) {
+	const { port = 0, host = "127.0.0.1", ...relayOpts } = opts;
+	const { WebSocketServer } = await import("ws");
+	const wss = new WebSocketServer({
+		port,
+		host
+	});
+	await new Promise((resolve, reject) => {
+		wss.once("listening", () => resolve());
+		wss.once("error", (err) => reject(err));
+	});
+	const address = wss.address();
+	const url = `ws://${host}:${typeof address === "object" && address !== null ? address.port : port}`;
+	const core = new FakeRelayCore(url, relayOpts);
+	wss.on("connection", (socket) => {
+		const session = core.connect({
+			send: (data) => socket.send(data),
+			close: () => socket.close()
+		});
+		socket.on("message", (data) => {
+			core.handleMessage(session, String(data));
+		});
+		socket.on("close", () => core.detach(session));
+		socket.on("error", () => core.detach(session));
+	});
+	return {
+		url,
+		relay: core,
+		close: async () => new Promise((resolve) => {
+			core.disconnect();
+			for (const client of wss.clients) client.terminate();
+			wss.close(() => resolve());
+		})
+	};
+}
+//#endregion
+//#region src/testing/conformance.ts
+const ALICE_SK = "0000000000000000000000000000000000000000000000000000000000000101";
+const BOB_SK = "0000000000000000000000000000000000000000000000000000000000000102";
+function alice() {
+	return Keys.fromSecretKey(ALICE_SK);
+}
+function bob() {
+	return Keys.fromSecretKey(BOB_SK);
+}
+function note(keys, content, createdAt, tags = []) {
+	return new EventBuilder(1, content).tags(tags).createdAt(createdAt).signWithKeys(keys);
+}
+function replaceable(keys, kind, content, createdAt) {
+	return new EventBuilder(kind, content).createdAt(createdAt).signWithKeys(keys);
+}
+function addressable(keys, kind, d, content, createdAt) {
+	return new EventBuilder(kind, content).tags([["d", d]]).createdAt(createdAt).signWithKeys(keys);
+}
+function fail(message) {
+	throw new Error(`EventStore conformance: ${message}`);
+}
+function eq(got, want, what) {
+	if (JSON.stringify(got) !== JSON.stringify(want)) fail(`${what}: expected ${JSON.stringify(want)}, got ${JSON.stringify(got)}`);
+}
+function ids(events) {
+	return events.map((e) => e.id);
+}
+/**
+* Framework-agnostic {@link EventStore} conformance cases. Each `run` throws on failure; register
+* them with the test framework of your choice: `for (const c of eventStoreConformanceCases)
+* test(c.name, () => c.run(store()))`.
+*/
+const eventStoreConformanceCases = [
+	{
+		name: "put accepted then duplicate",
+		async run(store) {
+			const e = note(alice(), "hello", 1);
+			eq(await store.put(e), "accepted", "first put");
+			eq(await store.put(e), "duplicate", "second put");
+			eq(await store.get(e.id), e, "get after put");
+			eq(await store.putMany([note(alice(), "a", 2), note(alice(), "b", 3)]), ["accepted", "accepted"], "putMany results");
+		}
+	},
+	{
+		name: "ephemeral event returns ephemeral and is not stored",
+		async run(store) {
+			const e = replaceable(alice(), 20001, "ephemeral", 1);
+			eq(await store.put(e), "ephemeral", "put ephemeral");
+			eq(await store.get(e.id), void 0, "ephemeral not retrievable");
+			eq(await store.query([{ kinds: [20001] }]), [], "ephemeral not queryable");
+			eq(await store.count([{ kinds: [20001] }]), 0, "ephemeral not counted");
+		}
+	},
+	{
+		name: "replaceable event keeps newest and rejects stale",
+		async run(store) {
+			const older = replaceable(alice(), 0, "old", 1);
+			const newer = replaceable(alice(), 0, "new", 2);
+			eq(await store.put(older), "accepted", "first replaceable");
+			eq(await store.put(newer), "replaced", "newer replaces");
+			eq(await store.put(older), "rejected", "stale replaceable rejected");
+			eq(await store.get(older.id), void 0, "replaced event gone");
+			eq(ids(await store.query([{
+				kinds: [0],
+				authors: [alice().publicKey]
+			}])), [newer.id], "newest kept");
+		}
+	},
+	{
+		name: "addressable event replaces by address",
+		async run(store) {
+			const v1 = addressable(alice(), 30001, "x", "v1", 1);
+			const v2 = addressable(alice(), 30001, "x", "v2", 2);
+			const other = addressable(alice(), 30001, "y", "other", 3);
+			eq(await store.put(v1), "accepted", "first addressable");
+			eq(await store.put(v2), "replaced", "same address replaced");
+			eq(await store.put(v1), "rejected", "stale addressable rejected");
+			eq(await store.put(other), "accepted", "different address independent");
+			eq(await store.get(v1.id), void 0, "v1 gone");
+			eq(ids(await store.query([{
+				kinds: [30001],
+				authors: [alice().publicKey]
+			}])).sort(), [other.id, v2.id].sort(), "independent addresses");
+		}
+	},
+	{
+		name: "deletion removes same-author e-tag targets only",
+		async run(store) {
+			const mine = note(alice(), "mine", 1);
+			const theirs = note(bob(), "theirs", 1);
+			await store.put(mine);
+			await store.put(theirs);
+			const delForeign = EventBuilder.deletion([theirs.id]).createdAt(2).signWithKeys(alice());
+			eq(await store.put(delForeign), "deleted", "kind 5 accepted");
+			eq(await store.get(theirs.id), theirs, "other author's event survives");
+			const delMine = EventBuilder.deletion([mine.id]).createdAt(3).signWithKeys(alice());
+			eq(await store.put(delMine), "deleted", "kind 5 accepted");
+			eq(await store.get(mine.id), void 0, "own event deleted");
+			eq(await store.query([{ ids: [mine.id] }]), [], "deleted event not queryable");
+			eq(await store.put(mine), "duplicate", "deleted event cannot be re-put");
+		}
+	},
+	{
+		name: "deletion removes addressable via a tag and tombstones re-put",
+		async run(store) {
+			const target = addressable(alice(), 30001, "z", "target", 1);
+			await store.put(target);
+			const coord = `30001:${alice().publicKey}:z`;
+			const del = EventBuilder.deletion([{ address: coord }], "").createdAt(2).signWithKeys(alice());
+			eq(await store.put(del), "deleted", "a-tag deletion");
+			eq(await store.get(target.id), void 0, "addressable deleted");
+			const stillCovered = addressable(alice(), 30001, "z", "covered", 1);
+			eq(await store.put(stillCovered), "duplicate", "tombstoned address rejects re-put");
+			eq(await store.query([{
+				kinds: [30001],
+				authors: [alice().publicKey]
+			}]), [], "none left");
+			const after = addressable(alice(), 30001, "z", "after", 3);
+			eq(await store.put(after), "accepted", "events newer than the deletion are kept");
+		}
+	},
+	{
+		name: "query orders newest first and applies limit",
+		async run(store) {
+			const a = note(alice(), "a", 1);
+			const b = note(alice(), "b", 3);
+			const c = note(alice(), "c", 2);
+			await store.putMany([
+				a,
+				b,
+				c
+			]);
+			eq(ids(await store.query([{
+				kinds: [1],
+				authors: [alice().publicKey]
+			}])), [
+				b.id,
+				c.id,
+				a.id
+			], "descending created_at");
+			eq(ids(await store.query([{
+				kinds: [1],
+				authors: [alice().publicKey],
+				limit: 2
+			}])), [b.id, c.id], "limit applies");
+		}
+	},
+	{
+		name: "query filters by kinds, authors, #e, #p, since, until",
+		async run(store) {
+			const target = note(bob(), "target", 1);
+			const tagged = note(alice(), "tagged", 2, [["e", target.id], ["p", bob().publicKey]]);
+			const plain = note(alice(), "plain", 3);
+			await store.putMany([
+				target,
+				tagged,
+				plain
+			]);
+			eq((await store.query([{ kinds: [1] }])).length, 3, "kind filter");
+			eq(ids(await store.query([{ authors: [bob().publicKey] }])), [target.id], "authors");
+			eq(ids(await store.query([{ "#e": [target.id] }])), [tagged.id], "#e");
+			eq(ids(await store.query([{ "#p": [bob().publicKey] }])), [tagged.id], "#p");
+			eq(ids(await store.query([{
+				kinds: [1],
+				since: 2
+			}])), [plain.id, tagged.id], "since");
+			eq(ids(await store.query([{
+				kinds: [1],
+				until: 2
+			}])), [tagged.id, target.id], "until");
+			eq(ids(await store.query([{ ids: [target.id, tagged.id] }])).sort(), [tagged.id, target.id].sort(), "ids filter");
+		}
+	},
+	{
+		name: "count matches query cardinality across overlapping filters",
+		async run(store) {
+			const a = note(alice(), "a", 1);
+			const b = note(bob(), "b", 2);
+			await store.putMany([a, b]);
+			eq(await store.count([{ kinds: [1] }]), 2, "count all");
+			eq(await store.count([
+				{ authors: [alice().publicKey] },
+				{ authors: [bob().publicKey] },
+				{ ids: [a.id] }
+			]), 2, "count dedupes union");
+			eq(await store.count([{ kinds: [2] }]), 0, "count none");
+		}
+	},
+	{
+		name: "negentropyItems sorted by created_at then id and respects limit",
+		async run(store) {
+			const a = note(alice(), "a", 2);
+			const b = note(alice(), "b", 1);
+			const c = note(bob(), "c", 3);
+			await store.putMany([
+				a,
+				b,
+				c
+			]);
+			eq((await store.negentropyItems({ kinds: [1] })).map((i) => i.id), [
+				b.id,
+				a.id,
+				c.id
+			], "created_at asc ordering");
+			eq((await store.negentropyItems({
+				kinds: [1],
+				limit: 2
+			})).map((i) => i.id), [a.id, c.id], "limit keeps newest two, presented ascending");
+			eq(await store.negentropyItems({ kinds: [2] }), [], "no match");
+			eq(await store.negentropyItems({ authors: [bob().publicKey] }), [{
+				id: c.id,
+				created_at: 3
+			}], "filter");
+		}
+	},
+	{
+		name: "outbox bounds roundtrip",
+		async run(store) {
+			eq(await store.getOutboxBound(alice().publicKey, 1), void 0, "unset bound");
+			await store.setOutboxBound(alice().publicKey, 1, {
+				oldest: 10,
+				newest: 20
+			});
+			eq(await store.getOutboxBound(alice().publicKey, 1), {
+				oldest: 10,
+				newest: 20
+			}, "bound read");
+			await store.setOutboxBound(alice().publicKey, 1, {
+				oldest: 5,
+				newest: 30
+			});
+			eq(await store.getOutboxBound(alice().publicKey, 1), {
+				oldest: 5,
+				newest: 30
+			}, "bound overwrite");
+		}
+	},
+	{
+		name: "remove deletes by id and tombstones",
+		async run(store) {
+			const a = note(alice(), "a", 1);
+			await store.put(a);
+			eq(await store.remove([a.id]), 1, "remove count");
+			eq(await store.get(a.id), void 0, "removed");
+			eq(await store.remove([a.id]), 0, "second remove is noop");
+			eq(await store.put(a), "duplicate", "removed id tombstoned");
+		}
+	},
+	{
+		name: "clear wipes events and bounds",
+		async run(store) {
+			const a = note(alice(), "a", 1);
+			await store.put(a);
+			await store.setOutboxBound(alice().publicKey, 1, {
+				oldest: 1,
+				newest: 1
+			});
+			await store.clear();
+			eq(await store.get(a.id), void 0, "event gone");
+			eq(await store.query([{ kinds: [1] }]), [], "query empty");
+			eq(await store.getOutboxBound(alice().publicKey, 1), void 0, "bound gone");
+			eq(await store.put(a), "accepted", "store usable after clear");
+		}
+	}
+];
+//#endregion
+//#region src/testing/nip46.ts
+/**
+* In-process NIP-46 remote signer: subscribes to kind:24133 requests on `relayUrl` and answers as a
+* bunker, encrypted to `clientPubkey` with NIP-44.
+*/
+function createFakeNip46Signer(opts) {
+	const bunkerKeys = opts.bunkerSk !== void 0 && opts.bunkerSk !== "" ? Keys.fromSecretKey(opts.bunkerSk) : Keys.generate();
+	const userKeys = opts.userSk !== void 0 && opts.userSk !== "" ? Keys.fromSecretKey(opts.userSk) : Keys.generate();
+	const convKey = getConversationKey(bunkerKeys.secretKey.bytes, opts.clientPubkey);
+	const handled = /* @__PURE__ */ new Set();
+	const authPending = /* @__PURE__ */ new Set();
+	const authMethods = new Set(opts.authUrlMethods ?? ["connect"]);
+	let closed = false;
+	const sockets = /* @__PURE__ */ new Set();
+	const listen = (relayUrl) => {
+		const ws = new opts.network.websocketImplementation(relayUrl);
+		ws.addEventListener("open", () => {
+			ws.send(JSON.stringify([
+				"REQ",
+				"fake-nip46-signer",
+				{
+					kinds: [Kind.NostrConnect],
+					"#p": [bunkerKeys.publicKey]
+				}
+			]));
+		});
+		ws.addEventListener("message", (ev) => onMessage(ev, ws));
+		sockets.add(ws);
+	};
+	const onMessage = (ev, ws) => {
+		if (typeof ev !== "object" || ev === null || !("data" in ev)) return;
+		const { data } = ev;
+		let msg;
+		try {
+			msg = JSON.parse(String(data));
+		} catch {
+			return;
+		}
+		if (!Array.isArray(msg) || msg[0] !== "EVENT") return;
+		const rawEvent = msg.at(2);
+		if (!isRecord(rawEvent)) return;
+		const { kind, pubkey, content, id } = rawEvent;
+		if (kind !== Kind.NostrConnect) return;
+		if (typeof pubkey !== "string" || typeof content !== "string" || typeof id !== "string") return;
+		if (pubkey !== opts.clientPubkey || handled.has(id)) return;
+		try {
+			const req = decodeNip46Request(decrypt(content, convKey));
+			if (opts.authUrl !== void 0 && opts.authUrl !== "" && authMethods.has(req.method) && !authPending.has(req.id)) {
+				authPending.add(req.id);
+				reply(ws, opts.clientPubkey, req.id, "auth_url", opts.authUrl);
+			}
+			handled.add(id);
+			opts.requests?.push({
+				method: req.method,
+				params: req.params
+			});
+			let result;
+			let error;
+			switch (opts.emptyMethods?.includes(req.method) === true ? "#empty" : req.method) {
+				case "connect":
+					result = opts.connectResult ?? "ack";
+					break;
+				case "get_public_key":
+					result = userKeys.publicKey;
+					break;
+				case "ping":
+					result = "pong";
+					break;
+				case "switch_relays":
+					result = opts.switchRelays === void 0 ? "null" : JSON.stringify(opts.switchRelays);
+					break;
+				case "logout":
+					result = "ack";
+					break;
+				case "sign_event": {
+					const rawTemplate = JSON.parse(req.params.at(0) ?? "null");
+					if (!isRecord(rawTemplate) || typeof rawTemplate["kind"] !== "number" || !Array.isArray(rawTemplate["tags"]) || !rawTemplate["tags"].every(isTag) || typeof rawTemplate["content"] !== "string" || typeof rawTemplate["created_at"] !== "number") throw new Error("invalid sign_event template");
+					result = JSON.stringify(finalizeEvent({
+						kind: rawTemplate["kind"],
+						tags: rawTemplate["tags"],
+						content: rawTemplate["content"],
+						created_at: rawTemplate["created_at"]
+					}, userKeys.secretKey));
+					break;
+				}
+				case "#empty": break;
+				default: error = `unsupported method ${req.method}`;
+			}
+			if (authPending.has(req.id) && opts.authReplyDelayMs !== void 0) {
+				const pendingId = req.id;
+				const pendingResult = result;
+				const pendingError = error;
+				setTimeout(() => reply(ws, opts.clientPubkey, pendingId, pendingResult, pendingError), opts.authReplyDelayMs);
+			} else reply(ws, opts.clientPubkey, req.id, result, error);
+		} catch {
+			handled.add(id);
+		}
+	};
+	const reply = (ws, clientPubkey, id, result, error) => {
+		if (closed) return;
+		const payload = (opts.encodeResponse ?? encodeNip46Response)({
+			id,
+			result,
+			error
+		});
+		const event = finalizeEvent({
+			kind: Kind.NostrConnect,
+			tags: [["p", clientPubkey]],
+			content: encrypt(payload, convKey),
+			created_at: Math.floor(Date.now() / 1e3)
+		}, bunkerKeys.secretKey);
+		ws.send(JSON.stringify(["EVENT", event]));
+	};
+	listen(opts.relayUrl);
+	return {
+		bunkerPubkey: bunkerKeys.publicKey,
+		userPublicKey: userKeys.publicKey,
+		confirmHandshake(secret) {
+			const payload = encodeNip46Response({
+				id: "handshake",
+				result: secret
+			});
+			const event = finalizeEvent({
+				kind: Kind.NostrConnect,
+				tags: [["p", opts.clientPubkey]],
+				content: encrypt(payload, convKey),
+				created_at: Math.floor(Date.now() / 1e3)
+			}, bunkerKeys.secretKey);
+			opts.network.relay(opts.relayUrl).inject(event);
+		},
+		attach(relayUrl) {
+			listen(relayUrl);
+		},
+		close() {
+			closed = true;
+			for (const ws of sockets) ws.close();
+			sockets.clear();
+		}
+	};
+}
+//#endregion
+export { createFakeNip46Signer, createFakeRelayNetwork, eventStoreConformanceCases, serveFakeRelay };
+
+//# sourceMappingURL=testing.mjs.map