diff --git a/src/lib/components/prs/StatusSelector.svelte b/src/lib/components/prs/StatusSelector.svelte
index 2b0edc6..ad3b9ac 100644
--- a/src/lib/components/prs/StatusSelector.svelte
+++ b/src/lib/components/prs/StatusSelector.svelte
@@ -1,10 +1,12 @@
 <script lang="ts">
     import { ndk } from "$lib/stores/ndk";
-    import { NDKEvent, type NDKTag } from "@nostr-dev-kit/ndk";
+    import { NDKEvent, NDKRelaySet, type NDKTag } from "@nostr-dev-kit/ndk";
     import type { PRStatus } from "./type";
     import { selected_pr_full } from "$lib/stores/PR";
     import { load } from "../../../routes/repo/[repo_id]/+page";
     import { patch_kind } from "$lib/kinds";
+    import { getLoggedInUserRelays, logged_in_user } from "$lib/stores/users";
+    import { selected_repo } from "$lib/stores/repo";
 
     export let status: PRStatus = "Draft";
     export let repo_id: string = "";
@@ -12,19 +14,41 @@
 
     let loading = false;
 
+    let edit_mode = false;
+    $: {
+        edit_mode =
+            $logged_in_user !== undefined && repo_id === $selected_repo.repo_id;
+    }
+
     async function changeStatus(new_status: PRStatus) {
         let event = new NDKEvent(ndk);
-        // TODO: use random custom kind for status instead of NIP32?
         event.kind = patch_kind;
         event.tags.push(["t", new_status]);
         event.tags.push(["e", pr_id]);
         event.tags.push(["r", `r-${repo_id}`]);
-        event.sign();
         loading = true;
-        // TODO send to repo relays, current user relay and pr event pubkey relays
+        let relays = [...$selected_repo.relays];
+        try {
+            event.sign();
+        } catch {
+            alert("failed to sign event");
+        }
         try {
-            // TODO: check if we are signed in a signer is in ndk
-            // let res = await event.publish();
+            let user_relays = await getLoggedInUserRelays();
+            relays = [
+                ...relays,
+                ...(user_relays.ndk_relays
+                    ? user_relays.ndk_relays.writeRelayUrls
+                    : []),
+                // TODO: pr event pubkey relays
+            ];
+        } catch {
+            alert("failed to get user relays");
+        }
+        try {
+            let res = await event.publish(
+                NDKRelaySet.fromRelayUrls(relays, ndk),
+            );
             selected_pr_full.update((pr_full) => {
                 if (pr_full.summary.id !== pr_id) return pr_full;
                 return {
@@ -47,6 +71,7 @@
             class:btn-success={status === "Open"}
             class:btn-primary={status === "Merged"}
             class:btn-neutral={status === "Draft" || status === "Closed"}
+            class:cursor-default={edit_mode}
             class="btn btn-success btn-sm mr-6 align-middle"
         >
             {#if status === "Open"}
@@ -94,64 +119,68 @@
                 >
                 Draft
             {/if}
-            <svg
-                xmlns="http://www.w3.org/2000/svg"
-                viewBox="0 0 24 24"
-                class="h-5 w-5s flex-none fill-success-content"
-                ><path
-                    fill="currentColor"
-                    d="M11.646 15.146L5.854 9.354a.5.5 0 0 1 .353-.854h11.586a.5.5 0 0 1 .353.854l-5.793 5.792a.5.5 0 0 1-.707 0"
-                /></svg
-            >
-        </div>
-        <ul
-            tabIndex={0}
-            class="dropdown-content z-[1] menu p-2 ml-0 shadow bg-base-300 rounded-box w-52"
-        >
-            {#if status !== "Draft"}
-                <li class="pl-0">
-                    <button
-                        on:click={() => {
-                            changeStatus("Draft");
-                        }}
-                        class="btn btn-neutral btn-sm mx-2 align-middle"
-                        >Draft</button
-                    >
-                </li>
-            {/if}
-            {#if status !== "Open"}
-                <li class="pl-0">
-                    <button
-                        on:click={() => {
-                            changeStatus("Open");
-                        }}
-                        class="btn btn-success btn-sm mx-2 align-middle"
-                        >Open</button
-                    >
-                </li>
-            {/if}
-            {#if status !== "Merged"}
-                <li class="pl-0">
-                    <button
-                        on:click={() => {
-                            changeStatus("Merged");
-                        }}
-                        class="btn btn-primary btn-sm mx-2 align-middle"
-                        >Merged</button
-                    >
-                </li>
-            {/if}
-            {#if status !== "Closed"}
-                <li class="pl-0">
-                    <button
-                        on:click={() => {
-                            changeStatus("Closed");
-                        }}
-                        class="btn btn-neutral btn-sm mx-2 align-middle"
-                        >Closed</button
-                    >
-                </li>
+            {#if edit_mode}
+                <svg
+                    xmlns="http://www.w3.org/2000/svg"
+                    viewBox="0 0 24 24"
+                    class="h-5 w-5s flex-none fill-success-content"
+                    ><path
+                        fill="currentColor"
+                        d="M11.646 15.146L5.854 9.354a.5.5 0 0 1 .353-.854h11.586a.5.5 0 0 1 .353.854l-5.793 5.792a.5.5 0 0 1-.707 0"
+                    /></svg
+                >
             {/if}
-        </ul>
+        </div>
+        {#if edit_mode}
+            <ul
+                tabIndex={0}
+                class="dropdown-content z-[1] menu p-2 ml-0 shadow bg-base-300 rounded-box w-52"
+            >
+                {#if status !== "Draft"}
+                    <li class="pl-0">
+                        <button
+                            on:click={() => {
+                                changeStatus("Draft");
+                            }}
+                            class="btn btn-neutral btn-sm mx-2 align-middle"
+                            >Draft</button
+                        >
+                    </li>
+                {/if}
+                {#if status !== "Open"}
+                    <li class="pl-0">
+                        <button
+                            on:click={() => {
+                                changeStatus("Open");
+                            }}
+                            class="btn btn-success btn-sm mx-2 align-middle"
+                            >Open</button
+                        >
+                    </li>
+                {/if}
+                {#if status !== "Merged"}
+                    <li class="pl-0">
+                        <button
+                            on:click={() => {
+                                changeStatus("Merged");
+                            }}
+                            class="btn btn-primary btn-sm mx-2 align-middle"
+                            >Merged</button
+                        >
+                    </li>
+                {/if}
+                {#if status !== "Closed"}
+                    <li class="pl-0">
+                        <button
+                            on:click={() => {
+                                changeStatus("Closed");
+                            }}
+                            class="btn btn-neutral btn-sm mx-2 align-middle"
+                            >Closed</button
+                        >
+                    </li>
+                {/if}
+            </ul>
+        {/if}
     </div>
 {/if}
diff --git a/src/lib/stores/PR.ts b/src/lib/stores/PR.ts
index 9ede801..7068797 100644
--- a/src/lib/stores/PR.ts
+++ b/src/lib/stores/PR.ts
@@ -1,15 +1,15 @@
-import type { NDKEvent } from "@nostr-dev-kit/ndk";
+import { NDKRelaySet, type NDKEvent } from "@nostr-dev-kit/ndk";
 import { writable, type Unsubscriber, type Writable } from "svelte/store"
 import { ndk } from "./ndk";
 import type { User } from "$lib/components/users/type";
 import { ensureUser } from "./users";
 import { type PRFull, full_defaults, isPRStatus, type PRStatus } from "$lib/components/prs/type";
 import { pr_kind, pr_status_kind } from "$lib/kinds";
-
+import { ensureSelectedRepo } from "./repo";
 
 export let selected_pr_full: Writable<PRFull> = writable({ ...full_defaults });
 
-let selected_repo_id: string = "";
+let selected_pr_repo_id: string = "";
 let selected_pr_id: string = "";
 let pr_summary_author_unsubsriber: Unsubscriber | undefined;
 
@@ -21,124 +21,144 @@ export let ensurePRFull = (repo_id: string, pr_id: string) => {
     if (selected_pr_id == pr_id) return;
     if (pr_id == "") {
         selected_pr_full.set({ ...full_defaults });
+        selected_pr_replies.set([]);
         return;
     }
 
-    selected_repo_id = repo_id;
+    selected_pr_repo_id = repo_id;
     selected_pr_id = pr_id;
     selected_pr_status_date = 0;
     selected_pr_replies.set([]);
 
-    selected_pr_full.update(full => {
-        return {
-            ...full,
-            summary: {
-                ...full.summary,
-                id: pr_id,
-                repo_id: repo_id,
-                loading: true,
-            },
+    selected_pr_full.set({
+        ...full_defaults,
+        summary: {
+            ...full_defaults.summary,
+            id: pr_id,
+            repo_id: repo_id,
             loading: true,
-        };
+        },
+        loading: true,
     });
     if (pr_summary_author_unsubsriber) pr_summary_author_unsubsriber();
     pr_summary_author_unsubsriber = undefined;
 
-    let sub = ndk.subscribe({
-        ids: [pr_id],
-        limit: 1,
-    });
-
-    sub.on("event", (event: NDKEvent) => {
-        try {
-            if (event.kind == pr_kind
-                && event.getMatchingTags("r").find(t => t[1] === `r-${repo_id}`)
-                && event.id == pr_id
-            ) {
+    new Promise(async (r) => {
+        let repo = await ensureSelectedRepo(repo_id);
 
-                selected_pr_full.update(full => {
-                    return {
-                        ...full,
-                        pr_event: event,
-                        summary: {
-                            ...full.summary,
-                            title: event.tagValue("name") || "",
-                            descritpion: event.tagValue("description") || "",
-                            created_at: event.created_at,
-                            comments: 0,
-                            author: {
-                                hexpubkey: event.pubkey,
-                                loading: true,
-                                npub: "",
-                            },
-                            loading: false,
-                        }
-                    };
-                });
-
-                pr_summary_author_unsubsriber = ensureUser(event.pubkey).subscribe((u: User) => {
+        let sub = ndk.subscribe(
+            {
+                ids: [pr_id],
+                kinds: [pr_kind],
+                '#r': [`r-${repo_id}`],
+                limit: 50,
+            },
+            {},
+            NDKRelaySet.fromRelayUrls(repo.relays, ndk),
+        );
+
+        sub.on("event", (event: NDKEvent) => {
+            try {
+                if (event.kind == pr_kind
+                    && event.getMatchingTags("r").find(t => t[1] === `r-${repo_id}`)
+                    && event.id == pr_id
+                ) {
                     selected_pr_full.update(full => {
                         return {
                             ...full,
+                            pr_event: event,
                             summary: {
                                 ...full.summary,
-                                author: event.pubkey == u.hexpubkey ? u : full.summary.author,
+                                title: event.tagValue("name") || "",
+                                descritpion: event.tagValue("description") || "",
+                                created_at: event.created_at,
+                                comments: 0,
+                                author: {
+                                    hexpubkey: event.pubkey,
+                                    loading: true,
+                                    npub: "",
+                                },
+                                loading: false,
                             }
                         };
                     });
-                });
-            }
-        } catch { }
-    });
 
-    sub.on("eose", () => {
-        selected_pr_full.update(full => {
-            return {
-                ...full,
-                summary: {
-                    ...full.summary,
-                    loading: false,
-                },
-            };
+                    pr_summary_author_unsubsriber = ensureUser(event.pubkey).subscribe((u: User) => {
+                        selected_pr_full.update(full => {
+                            return {
+                                ...full,
+                                summary: {
+                                    ...full.summary,
+                                    author: event.pubkey == u.hexpubkey ? u : full.summary.author,
+                                }
+                            };
+                        });
+                    });
+                }
+            } catch { }
         });
-    });
 
-    let sub_replies = ndk.subscribe({
-        "#e": [pr_id],
-    });
+        sub.on("eose", () => {
+            selected_pr_full.update(full => {
+                let updated = {
+                    ...full,
+                    summary: {
+                        ...full.summary,
+                        loading: false,
+                    },
+                };
+                if (full.loading === false) {
+                    r({ ...updated });
+                }
+                return updated;
+            });
+        });
+
+        let sub_replies = ndk.subscribe(
+            {
+                "#e": [pr_id],
+            },
+            {},
+            NDKRelaySet.fromRelayUrls(repo.relays, ndk),
+        );
+
+        sub_replies.on("event", (event: NDKEvent) => {
+            if (event.kind == pr_status_kind
+                && event.created_at && selected_pr_status_date < event.created_at
+                && event.getMatchingTags("t").length === 1
+                && event.getMatchingTags("t")[0].length > 1
+            ) {
+                let potential_status = event.getMatchingTags("t")[0][1];
 
-    sub_replies.on("event", (event: NDKEvent) => {
-        if (event.kind == pr_status_kind
-            && event.created_at && selected_pr_status_date < event.created_at
-            && event.getMatchingTags("t").length === 1
-            && event.getMatchingTags("t")[0].length > 1
-        ) {
-            let potential_status = event.getMatchingTags("t")[0][1];
-
-            if (isPRStatus(potential_status)) {
-                selected_pr_status_date = event.created_at;
-                selected_pr_full.update(full => {
-                    return {
-                        ...full,
-                        status: potential_status as PRStatus,
-                    };
-                });
+                if (isPRStatus(potential_status)) {
+                    selected_pr_status_date = event.created_at;
+                    selected_pr_full.update(full => {
+                        return {
+                            ...full,
+                            status: potential_status as PRStatus,
+                        };
+                    });
+                }
             }
-        }
-        selected_pr_replies.update(replies => {
-            return [
-                ...replies,
-                event,
-            ];
+            selected_pr_replies.update(replies => {
+                return [
+                    ...replies,
+                    event,
+                ];
+            });
         });
-    });
 
-    sub.on("eose", () => {
-        selected_pr_full.update(full => {
-            return {
-                ...full,
-                loading: false,
-            };
+        sub.on("eose", () => {
+            selected_pr_full.update(full => {
+                let updated = {
+                    ...full,
+                    loading: false,
+                };
+                if (full.summary.loading === false) {
+                    r({ ...updated });
+                }
+                return updated;
+            });
         });
     });
 }
diff --git a/src/lib/stores/PRs.ts b/src/lib/stores/PRs.ts
index 4a1c7d7..5548656 100644
--- a/src/lib/stores/PRs.ts
+++ b/src/lib/stores/PRs.ts
@@ -1,11 +1,11 @@
-import type { NDKEvent } from "@nostr-dev-kit/ndk";
+import { NDKRelaySet, type NDKEvent } from "@nostr-dev-kit/ndk";
 import { writable, type Unsubscriber, type Writable } from "svelte/store"
 import { ndk } from "./ndk";
-import type { Repo } from "$lib/components/repo/type";
 import { summary_defaults } from "$lib/components/prs/type";
 import type { User } from "$lib/components/users/type";
-import { ensureUser, users } from "./users";
-import type { PRSummaries, PRSummary } from "$lib/components/prs/type";
+import { ensureUser } from "./users";
+import type { PRSummaries } from "$lib/components/prs/type";
+import { ensureSelectedRepo } from "./repo";
 
 export let pr_summaries: Writable<PRSummaries> = writable({
     id: "",
@@ -19,7 +19,7 @@ let selected_repo_id: string = "";
 
 let authors_unsubscribers: Unsubscriber[] = [];
 
-export let ensurePRSummaries = (repo_id: string) => {
+export let ensurePRSummaries = async (repo_id: string) => {
     if (selected_repo_id == repo_id) return;
     if (repo_id == "") return pr_summaries.set({
         id: "",
@@ -28,6 +28,9 @@ export let ensurePRSummaries = (repo_id: string) => {
     });
 
     selected_repo_id = repo_id;
+
+    let repo = await ensureSelectedRepo(repo_id);
+
     pr_summaries.update(prs => {
         return {
             ...prs,
@@ -38,11 +41,15 @@ export let ensurePRSummaries = (repo_id: string) => {
     authors_unsubscribers.forEach(u => u());
     authors_unsubscribers = [];
 
-    let sub = ndk.subscribe({
-        kinds: [pr_kind],
-        '#r': [`r-${repo_id}`],
-        limit: 50,
-    });
+    let sub = ndk.subscribe(
+        {
+            kinds: [pr_kind],
+            '#r': [`r-${repo_id}`],
+            limit: 50,
+        },
+        {},
+        NDKRelaySet.fromRelayUrls(repo.relays, ndk),
+    );
 
     sub.on("event", (event: NDKEvent) => {
         try {
diff --git a/src/lib/stores/ndk.ts b/src/lib/stores/ndk.ts
index 4aadfba..168dc4f 100644
--- a/src/lib/stores/ndk.ts
+++ b/src/lib/stores/ndk.ts
@@ -1,7 +1,24 @@
 import NDKSvelte from '@nostr-dev-kit/ndk-svelte';
 
+export let base_relays = import.meta.env.DEV
+    ? [
+        "ws://localhost:8055",
+    ]
+    : [
+        "wss://relayable.org",
+        "wss://relay.f7z.io",
+        "wss://relay.damus.io",
+        "wss://relay.snort.social",
+        // "wss://nostr.wine/",
+        // "wss://eden.nostr.land/",
+        // "wss://relay.nostr.band/",
+
+    ];
+
+// TODO: fallback_relays for if profile cannot be found
+
 export const ndk = new NDKSvelte({
-    explicitRelayUrls: ['ws://localhost:8055'],
+    explicitRelayUrls: [...base_relays],
 });
 
 ndk.connect();
diff --git a/src/lib/stores/repo.ts b/src/lib/stores/repo.ts
index 6466fab..c2f0d44 100644
--- a/src/lib/stores/repo.ts
+++ b/src/lib/stores/repo.ts
@@ -1,6 +1,6 @@
-import { NDKUser } from "@nostr-dev-kit/ndk";
-import { writable, type Unsubscriber, type Writable } from "svelte/store"
-import { ndk } from "./ndk";
+import { NDKRelaySet } from "@nostr-dev-kit/ndk";
+import { writable, type Unsubscriber, type Writable, get } from "svelte/store"
+import { base_relays, ndk } from "./ndk";
 import type { Repo } from "$lib/components/repo/type";
 import { defaults } from "$lib/components/repo/type";
 import type { User } from "$lib/components/users/type";
@@ -12,63 +12,87 @@ let selected_repo_id: string = "";
 
 let maintainers_unsubscribers: Unsubscriber[] = [];
 
-export let ensureSelectedRepo = (repo_id: string) => {
-    if (selected_repo_id == repo_id) return selected_repo;
+export let ensureSelectedRepo = async (repo_id: string): Promise<Repo> => {
+    if (selected_repo_id == repo_id) {
+        return new Promise(r => {
+            let unsubscriber = selected_repo.subscribe(repo => {
+                if (repo.repo_id === repo_id && !repo.loading) {
+                    setTimeout(() => {
+                        unsubscriber();
+                    }, 5);
+                    r({ ...repo });
+                }
+            });
+
+        })
+    }
     selected_repo_id = repo_id;
-    let sub = ndk.subscribe({
-        kinds: [repo_kind],
-        '#d': [repo_id],
-        limit: 1,
-    });
+    let sub = ndk.subscribe(
+        {
+            kinds: [repo_kind],
+            '#d': [repo_id],
+            limit: 1,
+        },
+        {},
+        NDKRelaySet.fromRelayUrls(base_relays, ndk),
+    );
+
+    return new Promise((r) => {
+        sub.on("event", (event) => {
+            try {
+                if (event.kind == repo_kind && event.tagValue("d") == repo_id) {
+                    selected_repo.set({
+                        loading: false,
+                        repo_id: event.replaceableDTag(),
+                        name: event.tagValue("name") || "",
+                        description: event.tagValue("description") || "",
+                        git_server: event.tagValue("git_server") || "",
+                        tags: event.getMatchingTags("t") || [],
+                        maintainers: event.getMatchingTags("p").map(
+                            (t: string[]) =>
+                                ({
+                                    hexpubkey: t[1],
+                                    loading: true,
+                                    npub: "",
+                                }) as User,
+                        ),
+                        relays: event
+                            .getMatchingTags("relay")
+                            .map((t: string[]) => t[1]),
+                    });
+                    let old_unsubscribers = maintainers_unsubscribers;
+                    maintainers_unsubscribers = event
+                        .getMatchingTags("p")
+                        .map((t: string[]) => {
+                            return ensureUser(t[1]).subscribe((u: User) => {
+                                selected_repo.update((repo) => {
+                                    return {
+                                        ...repo,
+                                        maintainers: repo.maintainers.map((m) => {
+                                            if (m.hexpubkey == u.hexpubkey) return { ...u };
+                                            else return { ...m };
+                                        }),
+                                    };
+                                });
+                            })
+                        });
+                    old_unsubscribers.forEach((unsubscriber) => unsubscriber());
+                }
+            } catch { }
+        });
 
-    sub.on("event", (event) => {
-        try {
-            if (event.kind == repo_kind && event.tagValue("d") == repo_id) {
-                selected_repo.set({
+        sub.on("eose", () => {
+            selected_repo.update((repo) => {
+                r({
+                    ...repo,
                     loading: false,
-                    repo_id: event.replaceableDTag(),
-                    name: event.tagValue("name") || "",
-                    description: event.tagValue("description") || "",
-                    git_server: event.tagValue("git_server") || "",
-                    tags: event.getMatchingTags("t") || [],
-                    maintainers: event.getMatchingTags("p").map(
-                        (t: string[]) =>
-                            ({
-                                hexpubkey: t[1],
-                                loading: true,
-                                npub: "",
-                            }) as User,
-                    ),
-                    relays: event
-                        .getMatchingTags("relay")
-                        .map((t: string[]) => t[1]),
                 });
-                let old_unsubscribers = maintainers_unsubscribers;
-                maintainers_unsubscribers = event
-                    .getMatchingTags("p")
-                    .map((t: string[]) => {
-                        return ensureUser(t[1]).subscribe((u: User) => {
-                            selected_repo.update((repo) => {
-                                return {
-                                    ...repo,
-                                    maintainers: repo.maintainers.map((m) => {
-                                        if (m.hexpubkey == u.hexpubkey) return { ...u };
-                                        else return { ...m };
-                                    }),
-                                };
-                            });
-                        })
-                    });
-                old_unsubscribers.forEach((unsubscriber) => unsubscriber());
-            }
-        } catch { }
-    });
-    sub.on("eose", () => {
-        selected_repo.update((repo) => {
-            return {
-                ...repo,
-                loading: false,
-            }
-        })
+                return {
+                    ...repo,
+                    loading: false,
+                }
+            })
+        });
     });
+
 }
diff --git a/src/lib/stores/users.ts b/src/lib/stores/users.ts
index 8c78526..4550a0d 100644
--- a/src/lib/stores/users.ts
+++ b/src/lib/stores/users.ts
@@ -16,6 +16,7 @@ export let ensureUser = (hexpubkey: string): Writable<User> => {
         };
 
         users[hexpubkey] = writable(base);
+        getUserRelays(hexpubkey);
         u.fetchProfile().then(
             (p) => {
                 users[hexpubkey].update((u) => ({
@@ -35,6 +36,17 @@ export let ensureUser = (hexpubkey: string): Writable<User> => {
     return users[hexpubkey];
 }
 
+export let returnUser = async (hexpubkey: string): Promise<User> => {
+    return new Promise((r) => {
+        let unsubscriber = ensureUser(hexpubkey).subscribe((u) => {
+            if (!u.loading) {
+                unsubscriber();
+                r(u);
+            }
+        });
+    });
+}
+
 // nip07_plugin is set in Navbar component
 export let nip07_plugin: Writable<undefined | boolean> = writable(undefined);
 
@@ -89,3 +101,80 @@ export let login = async (): Promise<void> => {
         }
     });
 };
+
+interface UserRelays {
+    loading: boolean;
+    ndk_relays: NDKRelayList | undefined;
+}
+
+export let user_relays: { [hexpubkey: string]: Writable<UserRelays>; } = {};
+
+export let getUserRelays = async (hexpubkey: string): Promise<UserRelays> => {
+    return new Promise(async (res, rej) => {
+        if (user_relays[hexpubkey]) {
+            let unsubscriber: Unsubscriber;
+            unsubscriber = user_relays[hexpubkey].subscribe(querying_user_relays => {
+                if (querying_user_relays && !querying_user_relays.loading) {
+                    res(querying_user_relays);
+                    unsubscriber();
+                }
+            });
+        }
+        else {
+            user_relays[hexpubkey] = writable({
+                loading: true,
+                ndk_relays: undefined,
+            });
+            logged_in_user_relays.set({
+                loading: true,
+                ndk_relays: undefined,
+            });
+            let relay_list = await ndk.getUser({ hexpubkey }).relayList();
+            let querying_user_relays = {
+                loading: false,
+                ndk_relays: relay_list,
+            };
+            user_relays[hexpubkey].set({ ...querying_user_relays });
+            res(querying_user_relays);
+        }
+    });
+
+};
+
+export let logged_in_user_relays: Writable<undefined | UserRelays> = writable(undefined);
+
+export let getLoggedInUserRelays = async (): Promise<UserRelays> => {
+    return new Promise(async (res, rej) => {
+        let user_relays = get(logged_in_user_relays);
+        if (user_relays) {
+            if (!user_relays.loading) return res(user_relays);
+            let unsubscriber = logged_in_user_relays.subscribe(user_relays => {
+                if (user_relays && !user_relays.loading) {
+                    res(user_relays);
+                    unsubscriber();
+                }
+            });
+        }
+        else {
+            let unsubscriber: Unsubscriber;
+            unsubscriber = logged_in_user.subscribe(async user => {
+                if (user) {
+                    if (unsubscriber) unsubscriber();
+                    logged_in_user_relays.set({
+                        loading: true,
+                        ndk_relays: undefined,
+                    });
+                    let relay_list = await ndk.getUser({ hexpubkey: user.hexpubkey }).relayList();
+                    let user_relays = {
+                        loading: false,
+                        ndk_relays: relay_list,
+                    };
+                    logged_in_user_relays.set({ ...user_relays });
+
+                    res(user_relays);
+                }
+            });
+        }
+    });
+
+};
\ No newline at end of file