add NIP-22 support

Author: pablof7z

.changeset/strong-files-fly.md

@@ -0,0 +1,5 @@
+---
+"@nostr-dev-kit/ndk": patch
+---
+
+add NIP-22 support

ndk/src/events/index.test.ts

@@ -7,15 +7,17 @@ import { NDKUser } from "../user";
 import { NDKRelaySet } from "../relay/sets";
 import { NDKPrivateKeySigner } from "../signers/private-key";
 import { NIP73EntityType } from "./nip73";
+import { NDKSigner } from "../signers";
+import { NDKKind } from "./kinds";
+
+const ndk = new NDK();
 
 describe("NDKEvent", () => {
-    let ndk: NDK;
     let event: NDKEvent;
     let user1: NDKUser;
     let user2: NDKUser;
 
     beforeEach(() => {
-        ndk = new NDK();
         user1 = new NDKUser({
             npub: "npub1l2vyh47mk2p0qlsku7hg0vn29faehy9hy34ygaclpn66ukqp3afqutajft",
         });
@@ -433,4 +435,133 @@ describe("NDKEvent", () => {
             }).toThrow("Unsupported NIP-73 entity type: unsupported");
         });
     });
+
+    fdescribe("reply", () => {
+        const signers = [0,1,2].map(i => NDKPrivateKeySigner.generate());
+        let users: NDKUser[];
+
+        beforeEach(async () => {
+            users = await Promise.all(signers.map(s => s.user()));
+        });
+
+        const sign = async (event: Partial<NostrEvent>, signer = signers[0]) => {
+            const e = new NDKEvent(ndk, event as NostrEvent);
+            await e.sign(signer);
+            return e;
+        };
+
+        const reply = async (event: NDKEvent, signer: NDKSigner) => {
+            const reply = event.reply();
+            await reply.sign(signer);
+            return reply;
+        }
+
+        describe("replies to kind:1 events", () => {
+            it("creates a reply using a kind 1 event", async () => {
+                const op = await sign({ kind: 1 });
+                const reply = op.reply();
+                expect(reply.kind).toBe(1);
+            });
+                
+            it('carries over the root event of the OP', async () => {
+                const root = await sign({ kind: 1 });
+                const reply1 = await reply(root, signers[1]);
+                const reply2 = reply1.reply();
+                
+                expect(reply2.tags).toContainEqual(['e', root.id, '', 'root', root.pubkey]);
+                expect(reply2.tags).toContainEqual(['p', root.pubkey]);
+            });
+
+            it('adds a root marker for root events', async () => {
+                const op = await sign({ kind: 1 });
+                const reply = op.reply();
+                expect(reply.tags).toContainEqual(['e', op.id, '', 'root', op.pubkey]);
+                expect(reply.tags).toContainEqual(['p', op.pubkey]);
+            });
+
+            it('adds a reply marker for non-root events', async () => {
+                const op = await sign({ kind: 1 });
+                const reply1 = await reply(op, signers[1]);
+                const reply2 = reply1.reply();
+                expect(reply2.tags).toContainEqual(['e', reply1.id, '', 'reply', reply1.pubkey]);
+                expect(reply2.tags).toContainEqual(['p', reply1.pubkey]);
+            });
+        });
+    
+        describe("replies to other kinds", () => {
+            let root: NDKEvent;
+            beforeAll(async () => {
+                root = await sign({ kind: 30023 });
+            });
+            
+            it("creates a reply using a kind 1111 event", async () => {
+                const reply1 = await reply(root, signers[1]);
+                expect(reply1.kind).toBe(NDKKind.GenericReply);
+            });
+
+            it("tags the root event or scope using an appropriate uppercase tag (e.g., 'A', 'E', 'I')", async () => {
+                const reply1 = await reply(root, signers[1]);
+                expect(reply1.tags).toContainEqual(['A', root.tagId(), ""]);
+            });
+
+            it("tags the root event with an 'a' for addressable events when it's a top level reply", async () => {
+                const root = await sign({ kind: 30023 });
+                const reply1 = root.reply();
+                expect(reply1.tags).toContainEqual(['A', root.tagId(), ""]);
+                expect(reply1.tags).toContainEqual(['a', root.tagId(), ""]);
+            });
+
+            it("p-tags the author of the root event", async () => {
+                const root = await sign({ kind: 30023 });
+                const reply1 = root.reply();
+                expect(reply1.tags).toContainEqual(['p', root.pubkey]);
+            });
+
+            it('p-tags the author of the reply event', async () => {
+                const root = await sign({ kind: 30023 });
+                const reply1 = await reply(root, signers[1]);
+                const reply2 = reply1.reply();
+                expect(reply2.tags).toContainEqual(['p', reply1.pubkey]);
+            });
+
+            it("p-tags the author of the root event only once when it's the root reply", async () => {
+                const root = await sign({ kind: 30023 });
+                const reply1 = root.reply();
+                expect(reply1.tags).toContainEqual(['p', root.pubkey]);
+                expect(reply1.tags.filter(t => t[0] === 'p')).toHaveLength(1);
+            });
+
+            it('p-tags the author of the root and reply events', async () => {
+                const reply1 = await reply(root, signers[1]);
+                const reply2 = reply1.reply();
+                expect(reply2.tags).toContainEqual(['p', root.pubkey]);
+                expect(reply2.tags).toContainEqual(['p', reply1.pubkey]);
+            });
+
+            it("tags the root event or scope using an appropriate uppercase tag with the pubkey when it's an E tag", async () => {
+                const root = await sign({ kind: 20 }, signers[0]);
+                const reply1 = await reply(root, signers[1]);
+                expect(reply1.tags).toContainEqual(['E', root.tagId(), "", root.pubkey]);
+            });
+
+            it("tags the parent item using an appropriate lowercase tag (e.g., 'a', 'e', 'i')", async () => {
+                const reply1 = await reply(root, signers[1]);
+                const reply2 = reply1.reply();
+                expect(reply2.tags).toContainEqual(['A', root.tagId(), ""]);
+                expect(reply2.tags).toContainEqual(['e', reply1.tagId(), "", reply1.pubkey]);
+            });
+
+            it("adds a 'K' tag to specify the root kind", async () => {
+                const reply1 = await reply(root, signers[1]);
+                expect(reply1.tags).toContainEqual(['K', root.kind!.toString()]);
+            });
+
+            it("adds a 'k' tag to specify the parent kind", async () => {
+                const reply1 = await reply(root, signers[1]);
+                const reply2 = reply1.reply();
+                expect(reply2.tags).toContainEqual(['k', reply1.kind!.toString()]);
+            });
+        });
+    });
+    
 });

ndk/src/events/index.ts

@@ -645,8 +645,10 @@ export class NDKEvent extends EventEmitter {
             tag.push("");
         }
 
-        if (marker) {
-            tag.push(marker);
+        tag.push(marker ?? "");
+
+        if (!this.isParamReplaceable()) {
+            tag.push(this.pubkey);
         }
 
         return tag;
@@ -827,4 +829,58 @@ export class NDKEvent extends EventEmitter {
     get isValid(): boolean {
         return this.validate();
     }
+
+    public reply(): NDKEvent {
+        const reply = new NDKEvent(this.ndk);
+
+        if (this.kind === 1) {
+            reply.kind = 1;
+            const opHasETag = this.hasTag("e");
+
+            if (opHasETag) {
+                reply.tags = [
+                    ...reply.tags,
+                    ...this.getMatchingTags("e"),
+                    ...this.getMatchingTags("p"),
+                    ...this.getMatchingTags("a"),
+                    ...this.referenceTags("reply")
+                ];
+            } else {
+                reply.tag(this, "root");
+            }
+        } else {
+            reply.kind = NDKKind.GenericReply;
+
+            const carryOverTags = ["A", "E", "I"];
+            const rootTag = this.tags.find((tag) => carryOverTags.includes(tag[0]));
+            
+            // we have a root tag already
+            if (rootTag) {
+                const rootKind = this.tagValue("K");
+                reply.tags.push(rootTag);
+                if (rootKind) reply.tags.push(["K", rootKind]);
+
+                reply.tags.push(["k", this.kind!.toString()]);
+
+                const [ type, id, _, ...extra] = this.tagReference();
+                const tag = [type, id, ...extra];
+                reply.tags.push(tag);
+            } else {
+                const [ type, id, _, relayHint] = this.tagReference();
+                const tag = [type, id, relayHint ?? ""];
+                if (type === "e") tag.push(this.pubkey);
+                reply.tags.push(tag);
+                const uppercaseTag = [...tag];
+                uppercaseTag[0] = uppercaseTag[0].toUpperCase();
+                reply.tags.push(uppercaseTag);
+                reply.tags.push(["K", this.kind!.toString()])
+            }
+
+            // carry over all p tags
+            reply.tags.push(...this.getMatchingTags("p"));
+            reply.tags.push(["p", this.pubkey]);
+        }
+
+        return reply;
+    }
 }

ndk/src/events/kinds/index.ts

@@ -25,6 +25,9 @@ export enum NDKKind {
     ChannelMessage = 42,
     ChannelHideMessage = 43,
     ChannelMuteUser = 44,
+
+    GenericReply = 1111,
+    
     Media = 1063,
     Report = 1984,
     Label = 1985,

ndk/src/user/index.ts

@@ -387,9 +387,27 @@ export class NDKUser {
 
     /**
      * Returns a set of users that this user follows.
+     * 
+     * @deprecated Use followSet instead
      */
     public follows = follows.bind(this);
 
+    /**
+     * Returns a set of pubkeys that this user follows.
+     * 
+     * @param opts - NDKSubscriptionOptions
+     * @param outbox - boolean
+     * @param kind - number
+     */
+    public async followSet(
+        opts?: NDKSubscriptionOptions,
+        outbox?: boolean,
+        kind: number = NDKKind.Contacts
+    ): Promise<Set<Hexpubkey>> {
+        const follows = await this.follows(opts, outbox, kind);
+        return new Set(Array.from(follows).map((f) => f.pubkey));
+    }
+
     /** @deprecated Use referenceTags instead. */
     /**
      * Get the tag that can be used to reference this user in an event