@bzzsocial/ndk 0.0.0-stage → 3.0.3-bzz.7

package/src/events/kinds/relay-feed-list.example.ts

@@ -0,0 +1,86 @@
+/**
+ * Examples of using NDKRelayFeedList (NIP-51 kind 10012)
+ *
+ * This kind represents user's favorite browsable relays and relay sets.
+ * It can contain both individual relay URLs and references to relay sets (kind:30002).
+ */
+
+import { NDK } from "../../ndk/index.js";
+import { NDKPrivateKeySigner } from "../../signers/private-key/index.js";
+import { NDKRelayFeedList } from "./relay-feed-list.js";
+
+async function createRelayFeedList() {
+    // Initialize NDK with a signer
+    const ndk = new NDK();
+    const signer = NDKPrivateKeySigner.generate();
+    ndk.signer = signer;
+
+    // Create a new relay feed list
+    const relayFeedList = new NDKRelayFeedList(ndk);
+    relayFeedList.title = "My Favorite Relays";
+    relayFeedList.description = "Relays I browse regularly";
+
+    // Add individual relay URLs
+    await relayFeedList.addRelay("wss://relay.damus.io");
+    await relayFeedList.addRelay("wss://nos.lol");
+    await relayFeedList.addRelay("wss://relay.nostr.band");
+
+    // Add relay set references (kind:30002)
+    await relayFeedList.addRelaySet("30002:pubkey123:my-outbox-relays");
+    await relayFeedList.addRelaySet("30002:pubkey456:trusted-relays");
+
+    // Publish the list
+    await relayFeedList.publish();
+
+    return relayFeedList;
+}
+
+async function readRelayFeedList() {
+    const ndk = new NDK();
+    const signer = NDKPrivateKeySigner.generate();
+    ndk.signer = signer;
+
+    // Fetch the user's relay feed list
+    const user = await signer.user();
+    const lists = await ndk.fetchEvents({
+        kinds: [10012],
+        authors: [user.pubkey],
+    });
+
+    for (const event of lists) {
+        const relayFeedList = NDKRelayFeedList.from(event);
+
+        console.log("Title:", relayFeedList.title);
+        console.log("Description:", relayFeedList.description);
+
+        // Get all relay URLs
+        console.log("Relay URLs:", relayFeedList.relayUrls);
+
+        // Get all relay set references
+        console.log("Relay Sets:", relayFeedList.relaySets);
+    }
+}
+
+async function modifyRelayFeedList() {
+    const ndk = new NDK();
+    const signer = NDKPrivateKeySigner.generate();
+    ndk.signer = signer;
+
+    const relayFeedList = new NDKRelayFeedList(ndk);
+
+    // Add some relays
+    await relayFeedList.addRelay("wss://relay.damus.io");
+    await relayFeedList.addRelay("wss://nos.lol");
+
+    // Remove a relay (don't publish yet)
+    await relayFeedList.removeRelay("wss://nos.lol", false);
+
+    // Add it back at the top of the list
+    await relayFeedList.addRelay("wss://nos.lol", undefined, false, "top");
+
+    // Publish all changes at once
+    await relayFeedList.publish();
+}
+
+// Export examples for documentation purposes
+export { createRelayFeedList, modifyRelayFeedList, readRelayFeedList };

package/src/events/kinds/relay-feed-list.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "vitest";
+import { NDK } from "../../ndk";
+import { NDKPrivateKeySigner } from "../../signers/private-key";
+import { NDKKind } from "./index.js";
+import { NDKRelayFeedList } from "./relay-feed-list.js";
+
+const ndk = new NDK();
+
+describe("NDKRelayFeedList", () => {
+    test("creates a new relay feed list", () => {
+        const list = new NDKRelayFeedList(ndk);
+        expect(list.kind).toBe(NDKKind.RelayFeedList);
+    });
+
+    test("has correct title", () => {
+        const list = new NDKRelayFeedList(ndk);
+        expect(list.title).toBe("Relay Feeds");
+    });
+
+    test("adds relay URLs", async () => {
+        ndk.signer = NDKPrivateKeySigner.generate();
+
+        const list = new NDKRelayFeedList(ndk);
+        await list.addRelay("wss://relay.damus.io");
+        await list.addRelay("wss://nos.lol");
+
+        expect(list.relayUrls).toEqual(["wss://relay.damus.io", "wss://nos.lol"]);
+    });
+
+    test("adds relay sets", async () => {
+        const signer = NDKPrivateKeySigner.generate();
+        ndk.signer = signer;
+
+        const list = new NDKRelayFeedList(ndk);
+        const relaySetNaddr = "30002:pubkey123:my-relay-set";
+        await list.addRelaySet(relaySetNaddr);
+
+        expect(list.relaySets).toEqual([relaySetNaddr]);
+    });
+
+    test("removes relay URLs", async () => {
+        const signer = NDKPrivateKeySigner.generate();
+        ndk.signer = signer;
+
+        const list = new NDKRelayFeedList(ndk);
+        await list.addRelay("wss://relay.damus.io");
+        await list.addRelay("wss://nos.lol");
+        await list.removeRelay("wss://relay.damus.io", false);
+
+        expect(list.relayUrls).toEqual(["wss://nos.lol"]);
+    });
+
+    test("removes relay sets", async () => {
+        const signer = NDKPrivateKeySigner.generate();
+        ndk.signer = signer;
+
+        const list = new NDKRelayFeedList(ndk);
+        const relaySet1 = "30002:pubkey123:set1";
+        const relaySet2 = "30002:pubkey123:set2";
+        await list.addRelaySet(relaySet1);
+        await list.addRelaySet(relaySet2);
+        await list.removeRelaySet(relaySet1, false);
+
+        expect(list.relaySets).toEqual([relaySet2]);
+    });
+
+    // Note: Encrypted tags are supported via the base NDKList class but are not tested here
+    // due to a known issue with the encryptedTagsLength cache in the base class.
+    // The encryption functionality works but the cache invalidation needs to be fixed upstream.
+
+    test("creates from existing NDKEvent", () => {
+        const list = new NDKRelayFeedList(ndk);
+        list.tags = [
+            ["relay", "wss://relay.damus.io"],
+            ["a", "30002:pubkey:relay-set"],
+        ];
+
+        const wrapped = NDKRelayFeedList.from(list);
+        expect(wrapped).toBeInstanceOf(NDKRelayFeedList);
+        expect(wrapped.relayUrls).toEqual(["wss://relay.damus.io"]);
+        expect(wrapped.relaySets).toEqual(["30002:pubkey:relay-set"]);
+    });
+
+    test("supports mixed relay and relay set items", async () => {
+        const signer = NDKPrivateKeySigner.generate();
+        ndk.signer = signer;
+
+        const list = new NDKRelayFeedList(ndk);
+        await list.addRelay("wss://relay.damus.io");
+        await list.addRelaySet("30002:pubkey:outbox-relays");
+        await list.addRelay("wss://nos.lol");
+        await list.addRelaySet("30002:pubkey:inbox-relays");
+
+        expect(list.relayUrls).toEqual(["wss://relay.damus.io", "wss://nos.lol"]);
+        expect(list.relaySets).toEqual(["30002:pubkey:outbox-relays", "30002:pubkey:inbox-relays"]);
+    });
+});

package/src/events/kinds/relay-feed-list.ts

@@ -0,0 +1,108 @@
+import type { NDK } from "../../ndk/index.js";
+import type { NostrEvent } from "../index.js";
+import { NDKEvent } from "../index.js";
+import { NDKKind } from "./index.js";
+import { NDKList } from "./lists/index.js";
+
+/**
+ * Represents a NIP-51 kind 10012 Relay Feed List.
+ *
+ * This list contains user's favorite browsable relays and relay sets.
+ * Items can be:
+ * - `relay` tags pointing to relay URLs
+ * - `a` tags pointing to kind:30002 relay sets
+ *
+ * @example
+ * const relayFeedList = new NDKRelayFeedList(ndk);
+ * relayFeedList.addRelay("wss://relay.damus.io");
+ * relayFeedList.addRelaySet("30002:pubkey:dtagvalue");
+ * await relayFeedList.publish();
+ *
+ * @group Kind Wrapper
+ */
+export class NDKRelayFeedList extends NDKList {
+    static kind = NDKKind.RelayFeedList;
+    static kinds = [NDKKind.RelayFeedList];
+
+    constructor(ndk?: NDK, rawEvent?: NostrEvent | NDKEvent) {
+        super(ndk, rawEvent);
+        if (!rawEvent?.kind) {
+            this.kind = NDKKind.RelayFeedList;
+        }
+    }
+
+    static from(ndkEvent: NDKEvent): NDKRelayFeedList {
+        return new NDKRelayFeedList(ndkEvent.ndk, ndkEvent);
+    }
+
+    /**
+     * Gets all relay URLs from the list.
+     */
+    get relayUrls(): string[] {
+        return this.getMatchingTags("relay").map(tag => tag[1]);
+    }
+
+    /**
+     * Gets all relay set references (kind:30002 naddr) from the list.
+     * Returns them in the format "kind:pubkey:dtag".
+     */
+    get relaySets(): string[] {
+        return this.getMatchingTags("a").map(tag => tag[1]);
+    }
+
+    /**
+     * Adds a relay URL to the list.
+     * @param relayUrl - WebSocket URL of the relay
+     * @param mark - Optional mark to add to the relay tag
+     * @param encrypted - Whether to encrypt the item
+     * @param position - Where to add the item in the list
+     */
+    async addRelay(
+        relayUrl: string,
+        mark?: string,
+        encrypted = false,
+        position: "top" | "bottom" = "bottom"
+    ): Promise<void> {
+        const tag: string[] = ["relay", relayUrl];
+        if (mark) tag.push(mark);
+        await this.addItem(tag, undefined, encrypted, position);
+    }
+
+    /**
+     * Adds a relay set reference to the list.
+     * @param relaySetNaddr - NIP-33 address in format "kind:pubkey:dtag" (kind should be 30002)
+     * @param mark - Optional mark to add to the relay set tag
+     * @param encrypted - Whether to encrypt the item
+     * @param position - Where to add the item in the list
+     */
+    async addRelaySet(
+        relaySetNaddr: string,
+        mark?: string,
+        encrypted = false,
+        position: "top" | "bottom" = "bottom"
+    ): Promise<void> {
+        const tag: string[] = ["a", relaySetNaddr];
+        if (mark) tag.push(mark);
+        await this.addItem(tag, undefined, encrypted, position);
+    }
+
+    /**
+     * Removes a relay URL from the list.
+     * @param relayUrl - The relay URL to remove
+     * @param publish - Whether to publish the change
+     */
+    async removeRelay(relayUrl: string, publish = true): Promise<void> {
+        await this.removeItemByValue(relayUrl, publish);
+    }
+
+    /**
+     * Removes a relay set from the list.
+     * @param relaySetNaddr - The relay set naddr to remove
+     * @param publish - Whether to publish the change
+     */
+    async removeRelaySet(relaySetNaddr: string, publish = true): Promise<void> {
+        await this.removeItemByValue(relaySetNaddr, publish);
+    }
+}
+
+export default NDKRelayFeedList;

package/src/events/kinds/relay-list.ts

@@ -0,0 +1,118 @@
+import type { NDK } from "../../ndk/index.js";
+import { NDKRelaySet } from "../../relay/sets/index.js";
+import { normalizeRelayUrl, tryNormalizeRelayUrl } from "../../utils/normalize-url.js";
+import type { NostrEvent } from "../index.js";
+import { NDKEvent } from "../index.js";
+import { NDKKind } from "./index.js";
+
+const READ_MARKER = "read";
+const WRITE_MARKER = "write";
+
+/**
+ * Represents a relay list for a user, ideally coming from a NIP-65 kind:10002 or alternatively from a kind:3 event's content.
+ * @group Kind Wrapper
+ */
+export class NDKRelayList extends NDKEvent {
+    static kind = NDKKind.RelayList;
+    static kinds = [NDKKind.RelayList];
+
+    constructor(ndk?: NDK, rawEvent?: NostrEvent) {
+        super(ndk, rawEvent);
+        this.kind ??= NDKKind.RelayList;
+    }
+
+    static from(ndkEvent: NDKEvent): NDKRelayList {
+        return new NDKRelayList(ndkEvent.ndk, ndkEvent.rawEvent());
+    }
+
+    get readRelayUrls(): WebSocket["url"][] {
+        return this.tags
+            .filter((tag) => tag[0] === "r" || tag[0] === "relay")
+            .filter((tag) => !tag[2] || (tag[2] && tag[2] === READ_MARKER))
+            .map((tag) => tryNormalizeRelayUrl(tag[1]))
+            .filter((url) => !!url) as WebSocket["url"][];
+    }
+
+    set readRelayUrls(relays: WebSocket["url"][]) {
+        for (const relay of relays) {
+            this.tags.push(["r", relay, READ_MARKER]);
+        }
+    }
+
+    get writeRelayUrls(): WebSocket["url"][] {
+        return this.tags
+            .filter((tag) => tag[0] === "r" || tag[0] === "relay")
+            .filter((tag) => !tag[2] || (tag[2] && tag[2] === WRITE_MARKER))
+            .map((tag) => tryNormalizeRelayUrl(tag[1]))
+            .filter((url) => !!url) as WebSocket["url"][];
+    }
+
+    set writeRelayUrls(relays: WebSocket["url"][]) {
+        for (const relay of relays) {
+            this.tags.push(["r", relay, WRITE_MARKER]);
+        }
+    }
+
+    get bothRelayUrls(): WebSocket["url"][] {
+        return this.tags
+            .filter((tag) => tag[0] === "r" || tag[0] === "relay")
+            .filter((tag) => !tag[2])
+            .map((tag) => tag[1]);
+    }
+    set bothRelayUrls(relays: WebSocket["url"][]) {
+        for (const relay of relays) {
+            this.tags.push(["r", relay]);
+        }
+    }
+
+    get relays(): WebSocket["url"][] {
+        return this.tags.filter((tag) => tag[0] === "r" || tag[0] === "relay").map((tag) => tag[1]);
+    }
+
+    /**
+     * Provides a relaySet for the relays in this list.
+     */
+    get relaySet(): NDKRelaySet {
+        if (!this.ndk) throw new Error("NDKRelayList has no NDK instance");
+
+        return new NDKRelaySet(
+            new Set(this.relays.map((u) => this.ndk?.pool.getRelay(u)).filter((r) => !!r)),
+            this.ndk,
+        );
+    }
+}
+
+export function relayListFromKind3(ndk: NDK, contactList: NDKEvent): NDKRelayList | undefined {
+    try {
+        const content = JSON.parse(contactList.content);
+        const relayList = new NDKRelayList(ndk);
+        const readRelays = new Set<string>();
+        const writeRelays = new Set<string>();
+
+        for (let [key, config] of Object.entries(content)) {
+            try {
+                key = normalizeRelayUrl(key);
+            } catch {
+                continue;
+            }
+
+            if (!config) {
+                readRelays.add(key);
+                writeRelays.add(key);
+            } else {
+                const relayConfig: { read?: boolean; write?: boolean } = config;
+                if (relayConfig.write) writeRelays.add(key);
+                if (relayConfig.read) readRelays.add(key);
+            }
+        }
+
+        relayList.readRelayUrls = Array.from(readRelays);
+        relayList.writeRelayUrls = Array.from(writeRelays);
+
+        return relayList;
+    } catch {
+        /* */
+    }
+
+    return undefined;
+}

package/src/events/kinds/repost.ts

@@ -0,0 +1,67 @@
+import type { NDK } from "../../ndk/index.js";
+import type { NDKFilter, NDKSubscriptionOptions } from "../../subscription/index.js";
+import type { NDKTag, NostrEvent } from "../index.js";
+import { NDKEvent } from "../index.js";
+import { NDKKind } from "./index.js";
+
+type classWithConvertFunction<T> = {
+    from: (event: NDKEvent) => T;
+};
+
+/**
+ * Handles NIP-18 reposts.
+ * @group Kind Wrapper
+ */
+export class NDKRepost<T> extends NDKEvent {
+    private _repostedEvents: T[] | undefined;
+    static kind = NDKKind.Repost;
+    static kinds = [NDKKind.Repost, NDKKind.GenericRepost];
+
+    static from(event: NDKEvent) {
+        return new NDKRepost(event.ndk, event.rawEvent());
+    }
+
+    /**
+     * Returns all reposted events by the current event.
+     *
+     * @param klass Optional class to convert the events to.
+     * @returns
+     */
+    async repostedEvents(klass?: classWithConvertFunction<T>, opts?: NDKSubscriptionOptions): Promise<T[]> {
+        const items: T[] = [];
+
+        if (!this.ndk) throw new Error("NDK instance not set");
+
+        if (this._repostedEvents !== undefined) return this._repostedEvents;
+
+        for (const eventId of this.repostedEventIds()) {
+            const filter = filterForId(eventId);
+            const event = await this.ndk.fetchEvent(filter, opts);
+
+            if (event) {
+                items.push(klass ? klass.from(event) : (event as T));
+            }
+        }
+
+        return items;
+    }
+
+    /**
+     * Returns the reposted event IDs.
+     */
+    repostedEventIds(): string[] {
+        return this.tags.filter((t: NDKTag) => t[0] === "e" || t[0] === "a").map((t: NDKTag) => t[1]);
+    }
+}
+
+function filterForId(id: string): NDKFilter {
+    if (id.match(/:/)) {
+        const [kind, pubkey, identifier] = id.split(":");
+        return {
+            kinds: [Number.parseInt(kind)],
+            authors: [pubkey],
+            "#d": [identifier],
+        };
+    }
+    return { ids: [id] };
+}