feat: stricter type checking on tag types of events (#24)

core/protocol.d.ts

@@ -38,8 +38,8 @@ export interface NostrEvent<K extends EventKind = EventKind> {
   pubkey: PublicKey;
   created_at: Timestamp;
   kind: K;
-  tags: TagFor<K>[];
-  content: Stringified<EventContentFor<K>>;
+  tags: [...Tags<K>, ...OptionalTag<K>[]];
+  content: Stringified<EventContent<K>>;
   sig: Signature;
 }
 
@@ -52,11 +52,11 @@ export type Signature = Brand<string, "EventSignature">;
 
 export type EventSerializePrecursor<K extends EventKind = EventKind> = [
   header: 0,
-  pubkey: PublicKey,
-  created_at: Timestamp,
-  kind: K,
-  tags: TagFor<K>[],
-  content: Stringified<EventContentFor<K>>,
+  pubkey: NostrEvent<K>["pubkey"],
+  created_at: NostrEvent<K>["created_at"],
+  kind: NostrEvent<K>["kind"],
+  tags: NostrEvent<K>["tags"],
+  content: NostrEvent<K>["content"],
 ];
 
 // ----------------------
@@ -79,7 +79,12 @@ export type TagParams<T extends TagType> = TagRecord[T] extends [
   ...infer P,
 ] ? P
   : never;
-export type TagFor<K extends EventKind> = EventKindRecord[K]["Tag"];
+
+export type Tags<K extends EventKind> = EventKindRecord[K] extends
+  { Tags: infer T extends Tag[] } ? T : [];
+
+export type OptionalTag<K extends EventKind> = EventKindRecord[K] extends
+  { OptionalTag: infer T extends Tag } ? T | undefined : Tag | undefined;
 
 // ----------------------
 // Communication
@@ -116,7 +121,7 @@ export type OkMessageContent<
 ];
 
 export type OkMessageBody<K extends EventKind, B extends boolean> = B extends
-  true ? string : `${ResponsePrefixFor<K>}: ${string}`;
+  true ? string : `${ResponsePrefix<K>}: ${string}`;
 
 export type DefaultResponsePrefix =
   | "duplicate"
@@ -151,17 +156,18 @@ export type SubscriptionFilter<
 export type EventKind = keyof EventKindRecord & number;
 
 export interface EventKindRecordEntry {
-  Tag: Tag;
   Content: unknown;
+  OptionalTag?: Tag;
+  Tags?: Tag[];
   ResponsePrefix?: string;
 }
 
-export type EventContent = EventContentFor<EventKind>;
+export type AnyEventContent = EventContent<EventKind>;
 
-export type EventContentFor<K extends EventKind> = EventKindRecord[K] extends
+export type EventContent<K extends EventKind> = EventKindRecord[K] extends
   EventKindRecordEntry ? EventKindRecord[K]["Content"] : never;
 
-export type ResponsePrefixFor<K extends EventKind = EventKind> =
+export type ResponsePrefix<K extends EventKind = EventKind> =
   EventKindRecord[K] extends { ResponsePrefix: infer P extends string } ? P
     : DefaultResponsePrefix;
 

lib/events.ts

@@ -1,15 +1,15 @@
 import type {
   ClientToRelayMessage,
-  EventContentFor,
+  EventContent,
   EventKind,
-  TagFor,
+  NostrEvent,
 } from "../mod.ts";
 import { Stringified } from "../core/types.ts";
 
 export interface EventInit<K extends EventKind = EventKind> {
-  kind: K;
-  tags?: TagFor<K>[];
-  content: EventContentFor<K> | Stringified<EventContentFor<K>>;
+  kind: NostrEvent<K>["kind"];
+  tags?: NostrEvent<K>["tags"];
+  content: EventContent<K> | Stringified<EventContent<K>>;
 }
 
 import type { Signer } from "./signs.ts";

lib/signs.ts

@@ -1,6 +1,6 @@
 import type { Brand, Stringified } from "../core/types.ts";
 import type {
-  EventContentFor,
+  EventContent,
   EventId,
   EventKind,
   EventSerializePrecursor,
@@ -47,8 +47,9 @@ export class Signer extends TransformStream<EventInit, NostrEvent> {
       created_at: Timestamp.now,
       tags: [],
       ...event,
-      content: JSON.stringify(event.content) as Stringified<EventContentFor<K>>,
-    } satisfies UnsignedEvent<K>;
+      content: JSON.stringify(event.content) as Stringified<EventContent<K>>,
+      // TODO: Can we avoid this type assertion?
+    } as UnsignedEvent<K>;
     const precursor = { ...unsigned, pubkey: PublicKey.from(this.nsec) };
     const hash = sha256(this.#encoder.encode(serialize(precursor)));
     return {

nips/01/protocol.d.ts

@@ -19,6 +19,18 @@ declare module "../../core/protocol.d.ts" {
       Tag: "e" | "p" | "a" | "d";
     };
   }
+  interface EventKindRecord {
+    0: {
+      Content: {
+        name: string;
+        about: string;
+        picture: Url;
+      };
+    };
+    1: {
+      Content: string;
+    };
+  }
   interface TagRecord {
     /** Event ID */
     "e": [EventId, RelayUrl?];
@@ -46,18 +58,4 @@ declare module "../../core/protocol.d.ts" {
     EOSE: [SubscriptionId];
     NOTICE: [string];
   }
-  interface EventKindRecord {
-    0: {
-      Tag: Tag;
-      Content: {
-        name: string;
-        about: string;
-        picture: Url;
-      };
-    };
-    1: {
-      Tag: Tag;
-      Content: string;
-    };
-  }
 }

nips/02/protocol.d.ts

@@ -8,7 +8,7 @@ declare module "../../core/protocol.d.ts" {
   }
   interface EventKindRecord {
     3: {
-      Tag: ContactTag;
+      OptionalTag: ContactTag;
       Content: "";
     };
   }

nips/02/protocol_test.ts

@@ -1,7 +1,7 @@
 import { describe, it } from "../../lib/std/testing.ts";
 import { assertType, Has } from "../../lib/std/testing.ts";
 import { EventInit } from "../../lib/events.ts";
-import type { PublicKey } from "../../core/protocol.d.ts";
+import type { EventId, PublicKey } from "../../core/protocol.d.ts";
 import "./protocol.d.ts";
 
 describe("EventInit<3>", () => {
@@ -21,7 +21,7 @@ describe("EventInit<3>", () => {
       content: "",
       tags: [
         // @ts-expect-error: tag name should be "p"
-        ["e", "test" as PublicKey, "wss://nos.lol", "string"],
+        ["e", "test" as EventId, "wss://nos.lol", "string"],
       ],
     } satisfies EventInit<3>;
     assertType<Has<typeof init, EventInit<3>>>(false);

nips/07/signs.ts

@@ -1,9 +1,5 @@
 import type { Stringified } from "../../core/types.ts";
-import {
-  EventContentFor,
-  EventKind,
-  NostrEvent,
-} from "../../core/protocol.d.ts";
+import { EventContent, EventKind, NostrEvent } from "../../core/protocol.d.ts";
 import { EventInit } from "../../lib/events.ts";
 import { Timestamp } from "../../lib/times.ts";
 import { UnsignedEvent } from "./protocol.d.ts";
@@ -27,8 +23,9 @@ export class Signer extends TransformStream<EventInit, NostrEvent> {
       created_at: Timestamp.now,
       tags: [],
       ...init,
-      content: JSON.stringify(init.content) as Stringified<EventContentFor<K>>,
-    } satisfies UnsignedEvent<K>;
+      content: JSON.stringify(init.content) as Stringified<EventContent<K>>,
+      // TODO: Can we avoid this type assertion?
+    } as UnsignedEvent<K>;
     return window.nostr!.signEvent(unsigned);
   }
 }

nips/42/protocol.d.ts

@@ -8,7 +8,7 @@ declare module "../../core/protocol.d.ts" {
       ClientToRelayMessage: "AUTH";
       RelayToClientMessage: "AUTH";
       EventKind: 22242;
-      Tag: Tag<"relay" | "challenge">;
+      Tag: "relay" | "challenge";
     };
   }
   interface RelayToClientMessageRecord {
@@ -19,7 +19,7 @@ declare module "../../core/protocol.d.ts" {
   }
   interface EventKindRecord {
     22242: {
-      Tag: Tag<"relay" | "challenge">;
+      Tags: [Tag<"relay">, Tag<"challenge">];
       Content: "";
       ResponsePrefix: "restricted";
     };

nips/42/protocol_test.ts

@@ -0,0 +1,36 @@
+import { describe, it } from "../../lib/std/testing.ts";
+import { assertType, Has } from "../../lib/std/testing.ts";
+import { EventInit } from "../../lib/events.ts";
+import "./protocol.d.ts";
+
+describe("EventInit<22242>", () => {
+  it("can be valid", () => {
+    const init = {
+      kind: 22242,
+      content: "",
+      tags: [
+        ["relay", "wss://nos.lol", "string"],
+        ["challenge", "string"],
+      ],
+    } satisfies EventInit<22242>;
+    assertType<Has<typeof init, EventInit<22242>>>(true);
+  });
+  it("tags should not be empty", () => {
+    const init = {
+      kind: 22242,
+      content: "",
+      // @ts-expect-error tags should not be empty
+      tags: [],
+    } satisfies EventInit<22242>;
+    assertType<Has<typeof init, EventInit<22242>>>(false);
+  });
+  it('tags should have "relay" and "challenge"', () => {
+    const init = {
+      kind: 22242,
+      content: "",
+      // @ts-expect-error tags should have "relay" and "challenge"
+      tags: [["relay", "wss://nos.lol"]],
+    } satisfies EventInit<22242>;
+    assertType<Has<typeof init, EventInit<22242>>>(false);
+  });
+});