`${count} ${word}${count === 1 ? "" : "s"}`;
const asDate = (seconds: number): string => new Date(seconds * 1000).toISOString().slice(0, 10);
@@ -125,6 +125,22 @@ export const Discussion = ({
const { before, after } = useMemo(() => split(roots, revisedAt), [roots, revisedAt]);
const since = roots[0]?.comment.createdAt ?? null;
+ /**
+ * A link from a notification names the comment it is about. The browser looks
+ * for that anchor when the page loads and does not find it: the conversation
+ * is fetched from the relays afterwards, and drawn later still. So the scroll
+ * is done here, once the record stands, and once per hash, or a reader who has
+ * scrolled away would be dragged back by the next event to arrive.
+ */
+ const { hash } = useLocation();
+ const jumped = useRef(null);
+ useEffect(() => {
+ const id = hash.slice(1);
+ if (!ready || id === "" || id === DISCUSSION_ID || jumped.current === hash) return;
+ jumped.current = hash;
+ document.getElementById(id)?.scrollIntoView({ block: "start" });
+ }, [hash, ready]);
+
return (
diff --git a/apps/web/app/lib/alerts.test.ts b/apps/web/app/lib/alerts.test.ts
new file mode 100644
index 0000000..bb35d34
--- /dev/null
+++ b/apps/web/app/lib/alerts.test.ts
@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+/** A fake with the one behaviour that matters: it can be written to and read back. */
+const fakeStorage = (broken = false): Storage => {
+ const held = new Map
- {children}
-
-);
-
/**
* The header's own control. The server renders it signed out, because the server
- * knows nobody, and it changes one tick after the page becomes interactive: the
- * slot it sits in is a fixed width so that nothing beside it moves when it does.
+ * knows nobody, and it changes one tick after the page becomes interactive. The
+ * width that keeps the rest of the line still while it does is reserved around
+ * this and the bell together, in `Shell`, rather than around this alone.
*/
export const Identity = () => {
const [open, setOpen] = useState(false);
@@ -63,7 +51,7 @@ export const Identity = () => {
const nsec = session.pubkey === null ? null : sessionNsec();
return (
-
+
{session.pubkey === null || npub === null ? (
Notifications
+ + {session.pubkey === null ? ( ++ Connect a key and this page fills with what was addressed to it: what people wrote, + marked or paid on your documents, and who else signs their name to one. +
+ ) : state.notices.length === 0 ? ( ++ {state.status === "ready" + ? "Nothing yet. This page stays empty until somebody answers something of yours." + : "Asking the relays."} +
+ ) : ( +-
+ {state.notices.map((notice) => (
+
+ ();
+
+ for (const event of events) {
+ if (event.kind !== REACTION_KIND && event.kind !== ZAP_RECEIPT_KIND) continue;
+ if (tagValue(event, "a") !== "") continue;
+ const targetId = tagValue(event, "e");
+ if (targetId !== "" && !held.has(targetId)) wanted.add(targetId);
+ }
+ return [...wanted];
+};
+
+/**
+ * What happened, which decides the sentence the row is drawn with.
+ *
+ * `comment` and `thread` both sit under a document of mine: the first answers
+ * the document, the second answers somebody else inside it. `reply` answers
+ * something I wrote, wherever it was written.
+ */
+export type NoticeKind = "comment" | "reply" | "thread" | "reaction" | "zap" | "copy";
+
+export type Notice = {
+ /** The event this is, which is what makes it one row however many relays served it. */
+ id: string;
+ kind: NoticeKind;
+ /** Who did it. On a zap that is who paid, not the server that signed the receipt. */
+ pubkey: string;
+ createdAt: number;
+ /** The document it happened under, which is where the row leads. */
+ document: { pubkey: string; identifier: string; coordinate: string };
+ /** What was answered, when it was something other than the document itself. */
+ targetId: string | null;
+ /**
+ * Whether `targetId` is a comment of mine rather than a document of mine. It
+ * decides both the sentence the row is drawn with and whether the link can
+ * name a place in the conversation or only the conversation.
+ */
+ onComment: boolean;
+ /** The words, the reaction's symbol, or the copy's title. */
+ content: string;
+ /** A NIP-30 custom emoji's image, on a reaction that named one. */
+ emojiUrl: string | null;
+ /** Satoshis, on a zap and nowhere else. */
+ sats: number | null;
+};
+
+export type NoticeScope = {
+ /** The reader these are addressed to. Nothing they did themselves is news to them. */
+ me: string;
+ /**
+ * Other keys' documents under one of my names, already reduced to one live
+ * revision per coordinate by whoever collected them.
+ */
+ copies?: Spec[];
+};
+
+/** Rebuilt rather than carried through, so one document has one spelling here. */
+const documentOf = (coordinate: string | null) => {
+ const pointer = coordinate === null ? null : parseCoordinate(coordinate);
+ return pointer === null
+ ? null
+ : {
+ pubkey: pointer.pubkey,
+ identifier: pointer.identifier,
+ coordinate: toCoordinate(pointer),
+ };
+};
+
+/**
+ * A comment is mine to hear about when it hangs from my document or when it
+ * answers me, and the two are told apart by which tag names me. A reply that
+ * names me in neither is somebody else's conversation, delivered because relays
+ * index tag values and do not check them.
+ */
+const noticeFromComment = (comment: Comment, me: string): Notice | null => {
+ if (comment.pubkey === me) return null;
+ const document = documentOf(comment.rootCoordinate);
+ if (document === null) return null;
+
+ const answersMe = tagValue(comment.event, "p") === me;
+ if (document.pubkey !== me && !answersMe) return null;
+
+ return {
+ id: comment.id,
+ kind: comment.parentId === null ? "comment" : answersMe ? "reply" : "thread",
+ pubkey: comment.pubkey,
+ createdAt: comment.createdAt,
+ document,
+ targetId: comment.parentId,
+ onComment: comment.parentId !== null,
+ content: comment.content,
+ emojiUrl: null,
+ sats: null,
+ };
+};
+
+/** A comment of mine, by id, so that what answers it can be attributed. */
+type MyComments = ReadonlyMap>;
+
+/**
+ * What a reaction or a zap was about, and whether it is mine to hear about.
+ *
+ * Anyone may put my key in a `p` tag, so that tag decides what a relay sends and
+ * never what is shown. The target decides that. A coordinate naming a document
+ * of mine is one I can see is mine; an event id is only mine once it has been
+ * fetched and turns out to be a comment I wrote. Anything else is somebody
+ * tagging me, and is dropped.
+ */
+const answered = (
+ target: { targetId: string | null; targetCoordinate: string | null },
+ me: string,
+ mine: MyComments,
+): { document: NonNullable>; onComment: boolean } | null => {
+ const named = documentOf(target.targetCoordinate);
+ if (named !== null && named.pubkey === me) return { document: named, onComment: false };
+
+ const comment = target.targetId === null ? undefined : mine.get(target.targetId);
+ return comment === undefined || comment === null ? null : { document: comment, onComment: true };
+};
+
+const noticeFromReaction = (
+ reaction: Reaction,
+ event: NostrEvent,
+ me: string,
+ mine: MyComments,
+): Notice | null => {
+ if (event.pubkey === me) return null;
+ const about = answered(reaction, me, mine);
+ if (about === null) return null;
+
+ return {
+ id: reaction.id,
+ kind: "reaction",
+ pubkey: reaction.pubkey,
+ createdAt: reaction.createdAt,
+ document: about.document,
+ targetId: reaction.targetId,
+ onComment: about.onComment,
+ content: reaction.symbol,
+ emojiUrl: reaction.emojiUrl,
+ sats: null,
+ };
+};
+
+/**
+ * A receipt is signed by the recipient's LNURL server, so the payer is only
+ * known through the request it echoed back. A receipt that carries no request
+ * names nobody, and a row that cannot say who paid is not worth a line.
+ */
+const noticeFromZap = (zap: ZapReceipt, me: string, mine: MyComments): Notice | null => {
+ if (zap.recipient !== me || zap.zapper === null || zap.zapper === me) return null;
+ const about = answered(zap, me, mine);
+ if (about === null) return null;
+
+ return {
+ id: zap.id,
+ kind: "zap",
+ pubkey: zap.zapper,
+ createdAt: zap.createdAt,
+ document: about.document,
+ targetId: zap.targetId,
+ onComment: about.onComment,
+ content: zap.comment,
+ emojiUrl: null,
+ sats: zap.amountSats,
+ };
+};
+
+const noticeFromCopy = (spec: Spec, me: string): Notice | null => {
+ if (spec.pubkey === me || spec.isEmpty) return null;
+ return {
+ id: spec.event.id,
+ kind: "copy",
+ pubkey: spec.pubkey,
+ createdAt: spec.createdAt,
+ document: {
+ pubkey: spec.pubkey,
+ identifier: spec.identifier,
+ coordinate: toCoordinate(spec),
+ },
+ targetId: null,
+ onComment: false,
+ content: spec.title,
+ emojiUrl: null,
+ sats: null,
+ };
+};
+
+/**
+ * A client that sent the same like twice is one reader and not two, which is the
+ * rule `tallyReactions` applies to a document's own tally. Everything else is
+ * one row per event: this site counts nothing that has a name attached to it.
+ */
+const collapsed = (notices: Notice[]): Notice[] => {
+ const kept = new Map();
+ for (const notice of notices) {
+ if (notice.kind !== "reaction") {
+ kept.set(notice.id, notice);
+ continue;
+ }
+ const key = `${notice.pubkey}:${notice.targetId ?? notice.document.coordinate}:${notice.content}`;
+ const current = kept.get(key);
+ if (current === undefined || notice.createdAt > current.createdAt) kept.set(key, notice);
+ }
+ return [...kept.values()];
+};
+
+const retracted = (deletions: Deletion[]) => {
+ const taken = retractions(deletions);
+ return (notice: Notice): boolean => taken.get(notice.id)?.has(notice.pubkey) === true;
+};
+
+/**
+ * Everything addressed to one key, newest first. Every check a relay could have
+ * skipped is made again here, where it costs a string compare: what a filter
+ * matched is a tag, and a tag is only what somebody wrote.
+ */
+export const sortNotices = (events: NostrEvent[], scope: NoticeScope): Notice[] => {
+ const notices: Notice[] = [];
+ const deletions: Deletion[] = [];
+ const seen = new Set();
+
+ // My own comments are never news, but they are what a reaction naming an id
+ // and nothing else has to be read against, so they are indexed before the
+ // pass that would otherwise throw them away.
+ const mine = new Map>();
+ for (const event of events) {
+ if (event.kind !== COMMENT_KIND || event.pubkey !== scope.me) continue;
+ const comment = parseComment(event);
+ if (comment !== null) mine.set(comment.id, documentOf(comment.rootCoordinate));
+ }
+
+ for (const event of events) {
+ if (seen.has(event.id)) continue;
+ seen.add(event.id);
+
+ if (event.kind === COMMENT_KIND) {
+ const comment = parseComment(event);
+ const notice = comment === null ? null : noticeFromComment(comment, scope.me);
+ if (notice !== null) notices.push(notice);
+ } else if (event.kind === REACTION_KIND) {
+ const reaction = parseReaction(event);
+ const notice = reaction === null ? null : noticeFromReaction(reaction, event, scope.me, mine);
+ if (notice !== null) notices.push(notice);
+ } else if (event.kind === ZAP_RECEIPT_KIND) {
+ const zap = parseZapReceipt(event);
+ const notice = zap === null ? null : noticeFromZap(zap, scope.me, mine);
+ if (notice !== null) notices.push(notice);
+ } else if (event.kind === DELETION_KIND) {
+ const deletion = parseDeletion(event);
+ if (deletion !== null) deletions.push(deletion);
+ }
+ }
+
+ for (const spec of scope.copies ?? []) {
+ const notice = noticeFromCopy(spec, scope.me);
+ if (notice !== null && !seen.has(notice.id)) {
+ seen.add(notice.id);
+ notices.push(notice);
+ }
+ }
+
+ const taken = retracted(deletions);
+ return collapsed(notices)
+ .filter((notice) => !taken(notice))
+ .sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+ .slice(0, MAX_NOTICES);
+};
+
+export type NoticeOptions = RelayOptions & {
+ /**
+ * More relays to ask, resolved by the caller while this is already running.
+ * A callback rather than a list: which relays reach a key is the app's policy,
+ * and waiting on that lookup would leave the reader with nothing meanwhile.
+ */
+ widen?: () => Promise;
+};
+
+const openNotices = (
+ known: string[],
+ filters: Filter[],
+ onEvent: (event: NostrEvent) => void,
+ options: NoticeOptions & { onEose?: () => void },
+): Subscription => {
+ const subscription = openWidening(known, filters, onEvent, options);
+ void (options.widen?.() ?? Promise.resolve([]))
+ .then((more) => subscription.widen(without(more, known), true))
+ .catch(() => {});
+ return subscription;
+};
+
+/**
+ * Everything addressed to one key, as it happens. `DISCUSSION_RELAYS` is asked
+ * first because that is where `writeRelays` sends a comment and where the other
+ * clients reading this kind of document send theirs.
+ */
+export const subscribeNotices = (
+ pubkey: string,
+ onEvent: (event: NostrEvent) => void,
+ options: NoticeOptions & { onEose?: () => void } = {},
+): Subscription =>
+ openNotices(
+ relaySet(options.relays ?? [...DISCUSSION_RELAYS, ...DEFAULT_RELAYS]),
+ notificationFilters(pubkey),
+ onEvent,
+ options,
+ );
+
+/**
+ * The same, for the names I publish under. A different relay set, because this
+ * is the one thing here nobody addresses to me: `READ_RELAYS` is where this site
+ * and its crawler look for documents, so it is where a copy of one is.
+ */
+export const subscribeCopies = (
+ identifiers: string[],
+ onEvent: (event: NostrEvent) => void,
+ options: NoticeOptions & { onEose?: () => void } = {},
+): Subscription =>
+ openNotices(
+ relaySet(options.relays ?? [...READ_RELAYS, ...DISCUSSION_RELAYS]),
+ copyFilters(identifiers),
+ onEvent,
+ options,
+ );
+
+/**
+ * The events a reaction or a zap named. Read from the relays that hold the
+ * conversations, since what is being asked for is a comment.
+ */
+export const subscribeNamed = (
+ ids: string[],
+ onEvent: (event: NostrEvent) => void,
+ options: NoticeOptions & { onEose?: () => void } = {},
+): Subscription =>
+ openNotices(
+ relaySet(options.relays ?? [...DISCUSSION_RELAYS, ...DEFAULT_RELAYS]),
+ namedFilters(ids),
+ onEvent,
+ options,
+ );
+
+/** Whether anything held is still standing, asked by the ids it would be taken back by. */
+export const subscribeRetractions = (
+ ids: string[],
+ onEvent: (event: NostrEvent) => void,
+ options: NoticeOptions & { onEose?: () => void } = {},
+): Subscription =>
+ openNotices(
+ relaySet(options.relays ?? [...DISCUSSION_RELAYS, ...DEFAULT_RELAYS]),
+ targetFilters(ids),
+ onEvent,
+ options,
+ );
diff --git a/packages/nostr/src/subscribe.ts b/packages/nostr/src/subscribe.ts
new file mode 100644
index 0000000..ed51ded
--- /dev/null
+++ b/packages/nostr/src/subscribe.ts
@@ -0,0 +1,71 @@
+import type { Filter } from "nostr-tools/filter";
+import type { NostrEvent } from "./event";
+import { type RelayOptions, relayPool } from "./pool";
+
+/** A filter with a thousand ids in it is refused by relays that bound their inputs. */
+export const MAX_IDS_PER_FILTER = 200;
+
+/** Values chunked into filters a relay will accept, in the order they were given. */
+export const inChunks = (values: T[], size = MAX_IDS_PER_FILTER): T[][] => {
+ const unique = [...new Set(values)];
+ const chunks: T[][] = [];
+ for (let index = 0; index < unique.length; index += size) {
+ chunks.push(unique.slice(index, index + size));
+ }
+ return chunks;
+};
+
+export type Subscription = { close: () => void };
+
+export type WideningSubscription = Subscription & {
+ /** Adds relays to a subscription already running, unless it has been closed. */
+ widen: (relays: string[], quiet: boolean) => void;
+};
+
+export const without = (relays: string[], already: string[]): string[] =>
+ relays.filter((relay) => !already.includes(relay));
+
+/**
+ * A subscription that can be told about more relays after it is running.
+ *
+ * Every reader here starts on the relays it already knows and learns about
+ * better ones a round trip later, from a NIP-65 list. Waiting for that list
+ * before subscribing would put a lookup on the critical path of something that
+ * should already be on screen, and the relays added afterwards send what they
+ * hold the moment they are asked, so nothing is lost by adding them late.
+ */
+export const openWidening = (
+ relays: string[],
+ filters: Filter[],
+ onEvent: (event: NostrEvent) => void,
+ options: RelayOptions & { onEose?: () => void } = {},
+): WideningSubscription => {
+ const pool = options.pool ?? relayPool();
+ const closers: { close: () => void }[] = [];
+ let closed = false;
+
+ const subscribe = (to: string[], onEose: (() => void) | undefined) => {
+ if (closed || to.length === 0) return;
+ for (const filter of filters) {
+ closers.push(
+ pool.subscribe(to, filter, {
+ onevent: (event) => onEvent(event as NostrEvent),
+ oneose: onEose,
+ }),
+ );
+ }
+ };
+
+ subscribe(relays, options.onEose);
+
+ return {
+ // The widening relays do not report an end of stored events: the caller was
+ // told what it asked for had arrived once already, and saying so again would
+ // put a page that has finished loading back into loading.
+ widen: (more, quiet) => subscribe(more, quiet ? undefined : options.onEose),
+ close: () => {
+ closed = true;
+ for (const closer of closers) closer.close();
+ },
+ };
+};
diff --git a/packages/nostr/test/discussion.test.ts b/packages/nostr/test/discussion.test.ts
index 999308c..8c986e1 100644
--- a/packages/nostr/test/discussion.test.ts
+++ b/packages/nostr/test/discussion.test.ts
@@ -4,6 +4,7 @@ import { finalizeEvent, generateSecretKey, getPublicKey } from "nostr-tools/pure
import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
import {
authorRelays,
+ DISCUSSION_RELAYS,
discussionFilters,
fetchDiscussion,
referenceFilters,
@@ -15,6 +16,7 @@ import { buildComment, COMMENT_KIND, threadComments } from "../src/nip22";
import { buildReaction, REACTION_KIND } from "../src/nip25";
import { clearRelayListCache } from "../src/nip65";
import { relaySet } from "../src/pool";
+import { DEFAULT_RELAYS } from "../src/relay";
import { discussionCase, discussionEvents } from "./fixtures";
const authorKey = generateSecretKey();
@@ -356,3 +358,44 @@ describe("the fixtures thread as the other clients thread them", () => {
expect(roots.length).toBeLessThan(events.length);
});
});
+
+describe("where a conversation is read from", () => {
+ /** Records what it was asked and answers nothing, so only the relay set is under test. */
+ const recordingPool = () => {
+ const asked: string[] = [];
+ return {
+ asked,
+ pool: {
+ querySync: async (relays: string[]) => {
+ asked.push(...relays);
+ return [];
+ },
+ } as unknown as SimplePool,
+ };
+ };
+
+ it("asks every relay this app sends a comment to", async () => {
+ const { asked, pool } = recordingPool();
+ await fetchDiscussion(
+ { coordinate: ROOT.coordinate, specEventId: SPEC_EVENT_ID },
+ { pool, outbox: false },
+ );
+
+ // `writeRelays` sends a comment to both lists. Reading only the first is how
+ // a comment ends up counted in a notification and missing from the page it
+ // is about, which is what this asserts can no longer happen.
+ // Compared through `relaySet`, which is what normalises them on the way out.
+ for (const relay of relaySet(DISCUSSION_RELAYS, DEFAULT_RELAYS)) {
+ expect(asked).toContain(relay);
+ }
+ });
+
+ it("lets a caller name its own relays instead, the way everything else here does", async () => {
+ const { asked, pool } = recordingPool();
+ await fetchDiscussion(
+ { coordinate: ROOT.coordinate, specEventId: SPEC_EVENT_ID },
+ { pool, outbox: false, relays: ["wss://only.example"] },
+ );
+ expect([...new Set(asked)]).toEqual(relaySet(["wss://only.example"]));
+ });
+});
diff --git a/packages/nostr/test/notifications.test.ts b/packages/nostr/test/notifications.test.ts
new file mode 100644
index 0000000..bd019a2
--- /dev/null
+++ b/packages/nostr/test/notifications.test.ts
@@ -0,0 +1,405 @@
+import { finalizeEvent, generateSecretKey, getPublicKey } from "nostr-tools/pure";
+import { describe, expect, it } from "vitest";
+import { toCoordinate } from "../src/address";
+import { type NostrEvent, SPEC_KIND } from "../src/event";
+import { buildComment, COMMENT_KIND } from "../src/nip22";
+import { buildReaction, buildRetraction, DELETION_KIND, REACTION_KIND } from "../src/nip25";
+import { buildZapRequest, ZAP_RECEIPT_KIND } from "../src/nip57";
+import {
+ copyFilters,
+ MAX_NOTICES,
+ type Notice,
+ namedFilters,
+ notificationFilters,
+ sortNotices,
+ targetFilters,
+ unnamedTargets,
+} from "../src/notifications";
+import { parseSpec, type Spec } from "../src/spec";
+import { MAX_IDS_PER_FILTER } from "../src/subscribe";
+
+const mySecret = generateSecretKey();
+const ME = getPublicKey(mySecret);
+
+const theirSecret = generateSecretKey();
+const THEM = getPublicKey(theirSecret);
+
+const thirdSecret = generateSecretKey();
+const THIRD = getPublicKey(thirdSecret);
+
+const MINE = { coordinate: `${SPEC_KIND}:${ME}:nip-07`, pubkey: ME };
+const THEIRS = { coordinate: `${SPEC_KIND}:${THEM}:nip-46`, pubkey: THEM };
+
+const sign = (
+ draft: { kind: number; content: string; tags: string[][] },
+ secret: Uint8Array,
+ at = 100,
+) => finalizeEvent({ ...draft, created_at: at }, secret) as NostrEvent;
+
+const comment = (
+ root: { coordinate: string; pubkey: string },
+ by: Uint8Array,
+ options: { parent?: { id: string; pubkey: string }; content?: string; at?: number } = {},
+) =>
+ sign(
+ buildComment({ root, parent: options.parent ?? null, content: options.content ?? "a note" }),
+ by,
+ options.at ?? 100,
+ );
+
+const reaction = (
+ target: { id: string; pubkey: string; kind: number; coordinate?: string },
+ by: Uint8Array,
+ options: { symbol?: string; at?: number } = {},
+) => sign(buildReaction(target, options.symbol ?? "+"), by, options.at ?? 100);
+
+/** A real invoice for 21 satoshis, so the amount is read rather than asserted. */
+const INVOICE_21_SATS =
+ "lnbc210n1pn2s396pp5w7lqvvmqxxwqmqjqxqyjqxqyjqxqyjqxqyjqxqyjqxqyjqxqyjqsdqqcqzzsxqyz5vqsp5usqfaketc5sg7g7fhqg9zqhqvqhqvqhqvqhqvqhqvqhqvqhqvqhqs9qyyssq";
+
+const serverSecret = generateSecretKey();
+
+const zap = (
+ by: Uint8Array,
+ target: { pubkey: string; coordinate?: string; eventId?: string },
+ at = 100,
+) => {
+ const request = sign(
+ buildZapRequest({ target, amountMsats: 21_000, relays: ["wss://nos.lol"] }),
+ by,
+ at,
+ );
+ return sign(
+ {
+ kind: ZAP_RECEIPT_KIND,
+ content: "",
+ tags: [
+ ["p", target.pubkey],
+ ["bolt11", INVOICE_21_SATS],
+ ["description", JSON.stringify(request)],
+ // Copied off the request, which is what NIP-57 asks a paying server to
+ // do and what the receipt is read by.
+ ...(target.coordinate ? [["a", target.coordinate]] : []),
+ ...(target.eventId ? [["e", target.eventId]] : []),
+ ],
+ },
+ serverSecret,
+ at,
+ );
+};
+
+const specEvent = (by: Uint8Array, identifier: string, content = "# A copy", at = 100) =>
+ sign(
+ {
+ kind: SPEC_KIND,
+ content,
+ tags: [
+ ["d", identifier],
+ ["title", "A copy"],
+ ],
+ },
+ by,
+ at,
+ );
+
+const asSpec = (event: NostrEvent): Spec => {
+ const spec = parseSpec(event);
+ if (spec === null) throw new Error("fixture is not a specification");
+ return spec;
+};
+
+const kinds = (notices: Notice[]) => notices.map((notice) => notice.kind);
+
+describe("notificationFilters", () => {
+ it("never asks for a zap receipt by the tag that names the payer", () => {
+ const zaps = notificationFilters(ME).filter((filter) =>
+ filter.kinds?.includes(ZAP_RECEIPT_KIND),
+ );
+ expect(zaps).toHaveLength(1);
+ expect(zaps[0]?.["#P"]).toBeUndefined();
+ expect(zaps[0]?.["#p"]).toEqual([ME]);
+ });
+
+ it("asks for comments both ways, since a reply under my document names me in `P` alone", () => {
+ const comments = notificationFilters(ME).filter((filter) =>
+ filter.kinds?.includes(COMMENT_KIND),
+ );
+ expect(comments.map((filter) => (filter["#p"] ? "#p" : "#P"))).toEqual(["#p", "#P"]);
+ });
+
+ it("gives each kind its own limit, so reactions cannot crowd out the rest", () => {
+ const filters = notificationFilters(ME);
+ const reactions = filters.find((filter) => filter.kinds?.includes(REACTION_KIND));
+ expect(filters.every((filter) => typeof filter.limit === "number")).toBe(true);
+ expect(reactions?.kinds).toEqual([REACTION_KIND]);
+ });
+});
+
+describe("copyFilters and targetFilters", () => {
+ const many = Array.from({ length: MAX_IDS_PER_FILTER + 5 }, (_, index) => `name-${index}`);
+
+ it("chunk what a relay would refuse in one filter", () => {
+ const filters = copyFilters(many);
+ expect(filters).toHaveLength(2);
+ expect(filters[0]?.["#d"]).toHaveLength(MAX_IDS_PER_FILTER);
+ expect(filters[1]?.["#d"]).toHaveLength(5);
+ });
+
+ it("drop a name repeated in the list", () => {
+ expect(copyFilters(["nip-07", "nip-07"])[0]?.["#d"]).toEqual(["nip-07"]);
+ });
+
+ it("ask only about deletions, not about the conversation around them", () => {
+ expect(targetFilters(["a".repeat(64)])).toEqual([
+ { kinds: [DELETION_KIND], "#e": ["a".repeat(64)] },
+ ]);
+ });
+});
+
+describe("sortNotices, comments", () => {
+ it("takes a comment on my document as a comment", () => {
+ const notices = sortNotices([comment(MINE, theirSecret)], { me: ME });
+ expect(kinds(notices)).toEqual(["comment"]);
+ expect(notices[0]?.pubkey).toBe(THEM);
+ expect(notices[0]?.document).toEqual({
+ pubkey: ME,
+ identifier: "nip-07",
+ coordinate: MINE.coordinate,
+ });
+ });
+
+ it("takes an answer to something I wrote as a reply, wherever it was written", () => {
+ const mine = comment(THEIRS, mySecret);
+ const notices = sortNotices(
+ [comment(THEIRS, thirdSecret, { parent: { id: mine.id, pubkey: ME } })],
+ {
+ me: ME,
+ },
+ );
+ expect(kinds(notices)).toEqual(["reply"]);
+ expect(notices[0]?.document.pubkey).toBe(THEM);
+ expect(notices[0]?.targetId).toBe(mine.id);
+ });
+
+ it("takes two other people talking under my document as a thread", () => {
+ const theirs = comment(MINE, theirSecret);
+ const notices = sortNotices(
+ [comment(MINE, thirdSecret, { parent: { id: theirs.id, pubkey: THEM } })],
+ { me: ME },
+ );
+ expect(kinds(notices)).toEqual(["thread"]);
+ expect(notices[0]?.pubkey).toBe(THIRD);
+ });
+
+ it("drops what I wrote myself", () => {
+ expect(sortNotices([comment(MINE, mySecret)], { me: ME })).toEqual([]);
+ });
+
+ it("drops a comment that names me in neither tag, which a relay cannot check", () => {
+ expect(sortNotices([comment(THEIRS, thirdSecret)], { me: ME })).toEqual([]);
+ });
+
+ it("drops a comment whose root coordinate is junk", () => {
+ const junk = sign(
+ {
+ kind: COMMENT_KIND,
+ content: "hello",
+ tags: [
+ ["A", "not-a-coordinate"],
+ ["p", ME],
+ ],
+ },
+ theirSecret,
+ );
+ expect(sortNotices([junk], { me: ME })).toEqual([]);
+ });
+});
+
+describe("sortNotices, reactions", () => {
+ const target = { id: "a".repeat(64), pubkey: ME, kind: SPEC_KIND, coordinate: MINE.coordinate };
+
+ it("takes a reaction to my document, with its symbol", () => {
+ const notices = sortNotices([reaction(target, theirSecret, { symbol: "🔥" })], { me: ME });
+ expect(kinds(notices)).toEqual(["reaction"]);
+ expect(notices[0]?.content).toBe("🔥");
+ });
+
+ it("drops a reaction to my own document from me", () => {
+ expect(sortNotices([reaction(target, mySecret)], { me: ME })).toEqual([]);
+ });
+
+ it("drops a reaction naming me on a document that is not mine", () => {
+ const theirs = {
+ id: "b".repeat(64),
+ pubkey: ME,
+ kind: SPEC_KIND,
+ coordinate: THEIRS.coordinate,
+ };
+ expect(sortNotices([reaction(theirs, theirSecret)], { me: ME })).toEqual([]);
+ });
+
+ it("drops a reaction that names only an event id, until its target is resolved", () => {
+ const onComment = { id: "c".repeat(64), pubkey: ME, kind: COMMENT_KIND };
+ expect(sortNotices([reaction(onComment, theirSecret)], { me: ME })).toEqual([]);
+ });
+
+ it("collapses the same like sent twice into one row, keeping the newer", () => {
+ const first = reaction(target, theirSecret, { at: 100 });
+ const second = reaction(target, theirSecret, { at: 200 });
+ const notices = sortNotices([first, second], { me: ME });
+ expect(notices).toHaveLength(1);
+ expect(notices[0]?.createdAt).toBe(200);
+ });
+
+ it("keeps two different symbols from the same key apart", () => {
+ const like = reaction(target, theirSecret, { symbol: "+" });
+ const fire = reaction(target, theirSecret, { symbol: "🔥" });
+ expect(sortNotices([like, fire], { me: ME })).toHaveLength(2);
+ });
+
+ it("keeps the same symbol from two keys apart", () => {
+ const one = reaction(target, theirSecret);
+ const two = reaction(target, thirdSecret);
+ expect(sortNotices([one, two], { me: ME })).toHaveLength(2);
+ });
+});
+
+describe("sortNotices, zaps", () => {
+ it("names who paid rather than the server that signed the receipt", () => {
+ const receipt = zap(theirSecret, { pubkey: ME, coordinate: MINE.coordinate });
+ const notices = sortNotices([receipt], { me: ME });
+ expect(kinds(notices)).toEqual(["zap"]);
+ expect(notices[0]?.pubkey).toBe(THEM);
+ expect(notices[0]?.sats).toBe(21);
+ });
+
+ it("drops a zap I sent myself", () => {
+ const receipt = zap(mySecret, { pubkey: ME, coordinate: MINE.coordinate });
+ expect(sortNotices([receipt], { me: ME })).toEqual([]);
+ });
+
+ it("drops a receipt addressed to somebody else", () => {
+ const receipt = zap(thirdSecret, { pubkey: THEM, coordinate: THEIRS.coordinate });
+ expect(sortNotices([receipt], { me: ME })).toEqual([]);
+ });
+});
+
+describe("sortNotices, retractions", () => {
+ it("drops a comment its own author asked to be forgotten", () => {
+ const written = comment(MINE, theirSecret);
+ const taken = sign(buildRetraction(written.id), theirSecret);
+ expect(sortNotices([written, taken], { me: ME })).toEqual([]);
+ });
+
+ it("keeps one somebody else asked to have forgotten", () => {
+ const written = comment(MINE, theirSecret);
+ const taken = sign(buildRetraction(written.id), thirdSecret);
+ expect(sortNotices([written, taken], { me: ME })).toHaveLength(1);
+ });
+});
+
+describe("sortNotices, copies", () => {
+ it("takes another key publishing under one of my names, and leads to their copy", () => {
+ const copy = asSpec(specEvent(theirSecret, "nip-07"));
+ const notices = sortNotices([], { me: ME, copies: [copy] });
+ expect(kinds(notices)).toEqual(["copy"]);
+ expect(notices[0]?.document).toEqual({
+ pubkey: THEM,
+ identifier: "nip-07",
+ coordinate: toCoordinate(copy),
+ });
+ });
+
+ it("drops my own document and a blank one", () => {
+ const own = asSpec(specEvent(mySecret, "nip-07"));
+ const blank = asSpec(specEvent(theirSecret, "nip-07", ""));
+ expect(sortNotices([], { me: ME, copies: [own, blank] })).toEqual([]);
+ });
+});
+
+describe("sortNotices, the whole list", () => {
+ it("takes the same event served by three relays as one row", () => {
+ const one = comment(MINE, theirSecret);
+ expect(sortNotices([one, one, one], { me: ME })).toHaveLength(1);
+ });
+
+ it("reads newest first, with the lower id breaking a tie", () => {
+ const old = comment(MINE, theirSecret, { at: 100, content: "old" });
+ const a = comment(MINE, theirSecret, { at: 200, content: "a" });
+ const b = comment(MINE, thirdSecret, { at: 200, content: "b" });
+ const [first, second, third] = sortNotices([old, a, b], { me: ME });
+
+ expect(third?.createdAt).toBe(100);
+ expect([first?.id, second?.id].sort()).toEqual([a.id, b.id].sort());
+ expect(first?.id).toBe(a.id < b.id ? a.id : b.id);
+ });
+
+ it("stops at what one page of news can be", () => {
+ const many = Array.from({ length: MAX_NOTICES + 10 }, (_, index) =>
+ comment(MINE, theirSecret, { at: 100 + index, content: `note ${index}` }),
+ );
+ expect(sortNotices(many, { me: ME })).toHaveLength(MAX_NOTICES);
+ });
+});
+
+describe("reactions and zaps that name only an event id", () => {
+ /** A comment I wrote on somebody else's document, which is what gets answered. */
+ const myComment = comment(THEIRS, mySecret, { content: "a point of mine" });
+ const onIt = { id: myComment.id, pubkey: ME, kind: COMMENT_KIND };
+
+ it("asks about an id nothing here explains", () => {
+ const events = [reaction(onIt, theirSecret)];
+ expect(unnamedTargets(events)).toEqual([myComment.id]);
+ });
+
+ it("stops asking once the event is held", () => {
+ expect(unnamedTargets([reaction(onIt, theirSecret), myComment])).toEqual([]);
+ });
+
+ it("asks nothing about a reaction that named a coordinate", () => {
+ const onDocument = {
+ id: "a".repeat(64),
+ pubkey: ME,
+ kind: SPEC_KIND,
+ coordinate: MINE.coordinate,
+ };
+ expect(unnamedTargets([reaction(onDocument, theirSecret)])).toEqual([]);
+ });
+
+ it("asks for the events themselves, chunked", () => {
+ expect(namedFilters([myComment.id])).toEqual([{ ids: [myComment.id] }]);
+ });
+
+ it("draws the reaction once the comment turns out to be mine", () => {
+ const notices = sortNotices([reaction(onIt, theirSecret), myComment], { me: ME });
+ expect(kinds(notices)).toEqual(["reaction"]);
+ // The document is the one my comment hangs from, which is somebody else's.
+ expect(notices[0]?.document.pubkey).toBe(THEM);
+ expect(notices[0]?.onComment).toBe(true);
+ expect(notices[0]?.targetId).toBe(myComment.id);
+ });
+
+ it("keeps dropping it when the comment turns out to be somebody else's", () => {
+ const theirComment = comment(THEIRS, thirdSecret);
+ const onTheirs = { id: theirComment.id, pubkey: ME, kind: COMMENT_KIND };
+ expect(sortNotices([reaction(onTheirs, theirSecret), theirComment], { me: ME })).toEqual([]);
+ });
+
+ it("does the same for a zap on a comment of mine", () => {
+ const receipt = zap(theirSecret, { pubkey: ME, eventId: myComment.id });
+ const notices = sortNotices([receipt, myComment], { me: ME });
+ expect(kinds(notices)).toEqual(["zap"]);
+ expect(notices[0]?.onComment).toBe(true);
+ expect(notices[0]?.sats).toBe(21);
+ });
+
+ it("marks a reaction on a document of mine as not being on a comment", () => {
+ const onDocument = {
+ id: "a".repeat(64),
+ pubkey: ME,
+ kind: SPEC_KIND,
+ coordinate: MINE.coordinate,
+ };
+ expect(sortNotices([reaction(onDocument, theirSecret)], { me: ME })[0]?.onComment).toBe(false);
+ });
+});
+
diff --git a/apps/web/app/routes/spec.tsx b/apps/web/app/routes/spec.tsx
index c2a0d78..2fa0b66 100644
--- a/apps/web/app/routes/spec.tsx
+++ b/apps/web/app/routes/spec.tsx
@@ -11,7 +11,7 @@ import { data, Link, redirect } from "react-router";
import { AnnotatedDoc } from "~/components/annotated-doc";
import { AuthorAvatar } from "~/components/author-avatar";
import { CopyButton } from "~/components/copy-button";
-import { DISCUSSION_ID, Discussion } from "~/components/discussion/discussion";
+import { Discussion } from "~/components/discussion/discussion";
import { EditLink } from "~/components/editor/edit-link";
import { Withdraw } from "~/components/editor/withdraw";
import { ErrorPage } from "~/components/error-page";
@@ -23,7 +23,7 @@ import { keyTextColor } from "~/lib/color";
import { NOT_FOUND_HEADERS, PAGE_HEADERS } from "~/lib/http";
import { useLiveRevision } from "~/lib/live-revision";
import { publicOrigin } from "~/lib/origin.server";
-import { eventPath, oembedPath, ogImagePath } from "~/lib/paths";
+import { DISCUSSION_ID, eventPath, oembedPath, ogImagePath } from "~/lib/paths";
import type { LinkPreview } from "~/lib/preview";
import { loadLinkPreviews } from "~/lib/preview.server";
import type { Author } from "~/lib/profile";
diff --git a/packages/nostr/src/discussion.ts b/packages/nostr/src/discussion.ts
index 4f9954d..b54f2f7 100644
--- a/packages/nostr/src/discussion.ts
+++ b/packages/nostr/src/discussion.ts
@@ -13,7 +13,9 @@ import {
} from "./nip25";
import { parseZapReceipt, ZAP_RECEIPT_KIND, type ZapReceipt } from "./nip57";
import { fetchRelayList, type RelayListOptions } from "./nip65";
-import { queryRelays, type RelayOptions, relayPool, relaySet } from "./pool";
+import { queryRelays, type RelayOptions, relaySet } from "./pool";
+import { DEFAULT_RELAYS } from "./relay";
+import { inChunks, openWidening, type Subscription, without } from "./subscribe";
/**
* Where a conversation about a specification is. `relay.ditto.pub` is the one
@@ -22,6 +24,9 @@ import { queryRelays, type RelayOptions, relayPool, relaySet } from "./pool";
* them means showing half a conversation and calling it the discussion.
* `relay.nmail.li` is this project's own, first in `DEFAULT_RELAYS` and the one
* the crawler mirrors to.
+ *
+ * This is where the other clients put a conversation. It is not the whole of
+ * where one is: see `CONVERSATION_RELAYS` below.
*/
export const DISCUSSION_RELAYS = [
"wss://relay.ditto.pub",
@@ -31,9 +36,6 @@ export const DISCUSSION_RELAYS = [
"wss://relay.nmail.li",
];
-/** A filter with a thousand ids in it is refused by relays that bound their inputs. */
-const MAX_IDS_PER_FILTER = 200;
-
/**
* `#A` alone catches every comment seen in the wild. The other three are asked
* for on the same subscription anyway: `#a` for the client that scopes a thread
@@ -63,17 +65,11 @@ export const discussionFilters = (coordinate: string, specEventId: string): Filt
* the comment it answers: asked for by coordinate it does not exist, and asked
* for by its parent it is an ordinary part of the conversation.
*/
-export const referenceFilters = (ids: string[]): Filter[] => {
- const unique = [...new Set(ids)];
- const filters: Filter[] = [];
- for (let index = 0; index < unique.length; index += MAX_IDS_PER_FILTER) {
- filters.push({
- kinds: [COMMENT_KIND, REACTION_KIND, ZAP_RECEIPT_KIND, DELETION_KIND],
- "#e": unique.slice(index, index + MAX_IDS_PER_FILTER),
- });
- }
- return filters;
-};
+export const referenceFilters = (ids: string[]): Filter[] =>
+ inChunks(ids).map((chunk) => ({
+ kinds: [COMMENT_KIND, REACTION_KIND, ZAP_RECEIPT_KIND, DELETION_KIND],
+ "#e": chunk,
+ }));
export type Discussion = {
comments: Comment[];
@@ -172,9 +168,22 @@ export type DiscussionOptions = RelayOptions &
outbox?: boolean;
};
+/**
+ * Everywhere a conversation about a document is looked for.
+ *
+ * `DEFAULT_RELAYS` belongs here and was missing, which was a hole this site dug
+ * itself: `writeRelays` sends a comment to both lists, and this read only the
+ * first. A comment that landed on a relay in the second and nowhere else, which
+ * is what happens when it was written from another client to a relay this
+ * project reads but nostrhub does not, was addressed to the author, delivered to
+ * the author, counted in the author's notifications, and invisible on the page
+ * it was about.
+ */
+export const CONVERSATION_RELAYS = relaySet(DISCUSSION_RELAYS, DEFAULT_RELAYS);
+
/** `options.relays` replaces the defaults, the way it does everywhere else here. */
const relaysFor = (pointer: DiscussionPointer, options: DiscussionOptions): string[] =>
- relaySet(options.relays ?? DISCUSSION_RELAYS, pointer.relays ?? []);
+ relaySet(options.relays ?? CONVERSATION_RELAYS, pointer.relays ?? []);
/**
* Both sides of the author's NIP-65 list, because a conversation about their
@@ -258,10 +267,7 @@ export const fetchDiscussion = async (
});
};
-const without = (relays: string[], already: string[]): string[] =>
- relays.filter((relay) => !already.includes(relay));
-
-export type DiscussionSubscription = { close: () => void };
+export type DiscussionSubscription = Subscription;
/**
* The conversation as it happens. A page holding this open sees a comment posted
@@ -269,9 +275,7 @@ export type DiscussionSubscription = { close: () => void };
* which is the whole argument for relays being the source of truth.
*
* Subscribing starts on the relays already known and widens to the author's own
- * once their list resolves, rather than waiting for it: the conversation should
- * be on screen while that lookup is still happening, and the relays it adds send
- * what they have the moment they are asked.
+ * once their list resolves, rather than waiting for it.
*
* The second pass is left to the caller: it depends on ids that arrive over
* time, and only the caller knows which of them it has already asked about.
@@ -284,7 +288,7 @@ export const subscribeDiscussion = (
const filters = discussionFilters(pointer.coordinate, pointer.specEventId);
const known = relaysFor(pointer, options);
- const subscription = open(known, filters, onEvent, options);
+ const subscription = openWidening(known, filters, onEvent, options);
void outboxOf(pointer, options).then((relays) =>
subscription.widen(without(relays, known), options.onEose === undefined),
);
@@ -307,50 +311,9 @@ export const subscribeReferences = (
const filters = referenceFilters(ids);
const known = relaysFor(pointer, options);
- const subscription = open(known, filters, onEvent, options);
+ const subscription = openWidening(known, filters, onEvent, options);
void outboxOf(pointer, options).then((relays) =>
subscription.widen(without(relays, known), true),
);
return subscription;
};
-
-type WideningSubscription = DiscussionSubscription & {
- /** Adds relays to a subscription already running, unless it has been closed. */
- widen: (relays: string[], quiet: boolean) => void;
-};
-
-const open = (
- relays: string[],
- filters: Filter[],
- onEvent: (event: NostrEvent) => void,
- options: DiscussionOptions & { onEose?: () => void },
-): WideningSubscription => {
- const pool = options.pool ?? relayPool();
- const closers: { close: () => void }[] = [];
- let closed = false;
-
- const subscribe = (to: string[], onEose: (() => void) | undefined) => {
- if (closed || to.length === 0) return;
- for (const filter of filters) {
- closers.push(
- pool.subscribe(to, filter, {
- onevent: (event) => onEvent(event as NostrEvent),
- oneose: onEose,
- }),
- );
- }
- };
-
- subscribe(relays, options.onEose);
-
- return {
- // The widening relays do not report an end of stored events: the caller was
- // told the conversation had arrived once already, and saying so again would
- // put a page that has finished loading back into loading.
- widen: (more, quiet) => subscribe(more, quiet ? undefined : options.onEose),
- close: () => {
- closed = true;
- for (const closer of closers) closer.close();
- },
- };
-};
diff --git a/packages/nostr/src/index.ts b/packages/nostr/src/index.ts
index 600ac72..7a0af46 100644
--- a/packages/nostr/src/index.ts
+++ b/packages/nostr/src/index.ts
@@ -44,6 +44,7 @@ export {
} from "./corpus";
export {
authorRelays,
+ CONVERSATION_RELAYS,
DISCUSSION_RELAYS,
type Discussion,
type DiscussionOptions,
@@ -155,6 +156,23 @@ export {
selectRelayLists,
writeRelaysOf,
} from "./nip65";
+export {
+ copyFilters,
+ MAX_NOTICES,
+ type Notice,
+ type NoticeKind,
+ type NoticeOptions,
+ type NoticeScope,
+ namedFilters,
+ notificationFilters,
+ sortNotices,
+ subscribeCopies,
+ subscribeNamed,
+ subscribeNotices,
+ subscribeRetractions,
+ targetFilters,
+ unnamedTargets,
+} from "./notifications";
export {
closeRelayPool,
queryRelays,
@@ -206,3 +224,11 @@ export {
toIdentifier,
withdrawSpec,
} from "./spec";
+export {
+ inChunks,
+ MAX_IDS_PER_FILTER,
+ openWidening,
+ type Subscription,
+ type WideningSubscription,
+ without,
+} from "./subscribe";
diff --git a/packages/nostr/src/notifications.ts b/packages/nostr/src/notifications.ts
new file mode 100644
index 0000000..dd41a97
--- /dev/null
+++ b/packages/nostr/src/notifications.ts
@@ -0,0 +1,420 @@
+import type { Filter } from "nostr-tools/filter";
+import { parseCoordinate, toCoordinate } from "./address";
+import { DISCUSSION_RELAYS } from "./discussion";
+import { type NostrEvent, SPEC_KIND, tagValue } from "./event";
+import { COMMENT_KIND, type Comment, parseComment } from "./nip22";
+import {
+ DELETION_KIND,
+ type Deletion,
+ parseDeletion,
+ parseReaction,
+ REACTION_KIND,
+ type Reaction,
+ retractions,
+} from "./nip25";
+import { parseZapReceipt, ZAP_RECEIPT_KIND, type ZapReceipt } from "./nip57";
+import { type RelayOptions, relaySet } from "./pool";
+import { DEFAULT_RELAYS, READ_RELAYS } from "./relay";
+import type { Spec } from "./spec";
+import { inChunks, openWidening, type Subscription, without } from "./subscribe";
+
+/** What one page of news can be before the rest is history rather than news. */
+export const MAX_NOTICES = 200;
+
+/**
+ * Four filters rather than one, and the reason is not only that a shared limit
+ * lets reactions, the loudest kind here, crowd the comments out of it.
+ *
+ * NIP-22 scopes a thread's root author with `P` and the author being answered
+ * with `p`, so a reply to somebody else's comment under my document names me in
+ * `P` alone: asked for by `p` it does not exist. NIP-57 spends the same tag on
+ * the opposite party. On a zap receipt `P` is who paid, so asking a relay for
+ * kind 9735 by `P` returns every zap I ever sent, addressed to me, as news.
+ */
+export const notificationFilters = (pubkey: string): Filter[] => [
+ { kinds: [COMMENT_KIND], "#p": [pubkey], limit: 100 },
+ { kinds: [COMMENT_KIND], "#P": [pubkey], limit: 100 },
+ { kinds: [REACTION_KIND], "#p": [pubkey], limit: 200 },
+ { kinds: [ZAP_RECEIPT_KIND], "#p": [pubkey], limit: 100 },
+];
+
+/** Who else publishes under the names I publish under. Nobody is addressed in one. */
+export const copyFilters = (identifiers: string[]): Filter[] =>
+ inChunks(identifiers).map((chunk) => ({ kinds: [SPEC_KIND], "#d": chunk }));
+
+/**
+ * Whether anything held here has since been taken back. Deliberately not
+ * `referenceFilters`, which asks for comments, reactions and zaps on the same
+ * ids: those belong to a document's record, and a reaction to a comment somebody
+ * wrote to me is their conversation rather than my news.
+ */
+export const targetFilters = (ids: string[]): Filter[] =>
+ inChunks(ids).map((chunk) => ({ kinds: [DELETION_KIND], "#e": chunk }));
+
+/** The events themselves, for the ids a reaction or a zap named and nothing explained. */
+export const namedFilters = (ids: string[]): Filter[] =>
+ inChunks(ids).map((chunk) => ({ ids: chunk }));
+
+/**
+ * The ids a reaction or a zap pointed at without saying which document it was
+ * about, and which nothing here holds the event for yet.
+ *
+ * A client reacting to a comment has no coordinate to name, since a comment is
+ * not addressable, so it names an id and nothing else. Fetched, that id is
+ * either a comment I wrote, which makes the reaction mine to hear about, or it
+ * is not, which makes the `p` tag on it somebody tagging a stranger.
+ */
+export const unnamedTargets = (events: NostrEvent[]): string[] => {
+ const held = new Set(events.map((event) => event.id));
+ const wanted = new Set