Display user's blossom servers in menu (#90)

* feat: Display blossom servers in user menu with caching

Implements caching and display of user's blossom server lists (kind 10063) in the user menu dropdown.

**Key Changes:**

1. **Database Schema (db.ts)**:
   - Added `CachedBlossomServerList` interface
   - Added `blossomServers` table to Dexie v15
   - Indexed by pubkey and updatedAt for efficient querying

2. **Caching Service (blossom-server-cache.ts)**:
   - Dual-layer caching: LRU memory cache (100 entries) + Dexie persistent cache
   - 24-hour TTL to reduce network requests
   - Auto-caches kind:10063 events from EventStore
   - Mirrors relay-list-cache pattern for consistency

3. **Sync Hooks**:
   - `useBlossomServerCacheSync`: Subscribes to EventStore for auto-caching kind:10063 events
   - `useAccountSync`: Extended to fetch and watch active account's blossom servers

4. **State Management**:
   - Added `blossomServers` field to `activeAccount` in GrimoireState
   - Created `setActiveAccountBlossomServers` pure function and callback
   - Reactive updates when user's server list changes

5. **User Menu UI (user-menu.tsx)**:
   - Added blossom servers section with HardDrive icon
   - Shows server count badge (e.g., "3 servers")
   - Clickable links open servers in new tabs
   - Displays only when user has configured servers

**Architecture:**
- Follows existing relay list caching pattern for consistency
- Reactive: UI auto-updates when kind:10063 events arrive
- Incremental sync: Fetches on login, caches for 24h
- Performance: Memory cache for <1ms lookups, Dexie for persistence

**Testing:**
- Build: ✓ No TypeScript errors
- Tests: ✓ All 838 tests passing

* feat: Open blossom server file lists directly from menus

**User Menu & Profile Viewer Improvements:**

1. **Enhanced Click Behavior**:
   - Clicking a blossom server now opens the file list for that server
   - Shows blobs uploaded by the user (user menu) or profile owner (profile viewer)
   - Pre-selects the clicked server in the dropdown

2. **UX Improvements**:
   - Removed server count from user menu label (cleaner UI)
   - Added `cursor-crosshair` to blossom server items (consistent with other clickable items)
   - Removed external link icon (not opening external URL anymore)

3. **Technical Changes**:
   - Updated `ListBlobsView` to accept optional `serverUrl` prop for pre-selection
   - User menu: Opens `blossom list` with `serverUrl` for active user
   - Profile viewer: Opens `blossom list` with both `pubkey` and `serverUrl`

**Flow:**
- User menu → Click server → Opens files for active user on that server
- Profile viewer → Click server → Opens files for viewed user on that server

* fix: Properly fetch blossom servers for any profile view

**Problem:**
Blossom servers were only visible for the logged-in user's profile,
not for other users' profiles being viewed.

**Solution:**
Enhanced ProfileViewer blossom server fetching with multi-layer approach:

1. **Cache-first loading**: Check blossomServerCache for instant display
2. **EventStore check**: Use existing cached event if available
3. **Reactive subscription**: Subscribe to EventStore for real-time updates
4. **Network fetch**: Use addressLoader to fetch latest from relays
5. **Auto-caching**: Update cache when new events arrive

**Benefits:**
- Blossom servers now display for ANY user's profile
- Instant display from cache (< 1ms)
- Reactive updates when data changes
- Proper cache hydration for future visits
- Consistent with relay list fetching pattern

**Technical:**
- Imported and integrated blossomServerCache service
- Added cache check before network fetch
- Separated EventStore subscription from network fetch
- Added cache updates on event arrival

---------

Co-authored-by: Claude <noreply@anthropic.com>

src/components/BlossomViewer.tsx

@@ -72,7 +72,7 @@ export function BlossomViewer({
     case "upload":
       return <UploadView />;
     case "list":
-      return <ListBlobsView pubkey={pubkey} />;
+      return <ListBlobsView pubkey={pubkey} serverUrl={serverUrl} />;
     case "blob":
       return <BlobDetailView sha256={sha256!} serverUrl={serverUrl} />;
     case "mirror":
@@ -753,7 +753,13 @@ function formatSize(bytes: number): string {
 /**
  * ListBlobsView - List blobs for a user
  */
-function ListBlobsView({ pubkey }: { pubkey?: string }) {
+function ListBlobsView({
+  pubkey,
+  serverUrl,
+}: {
+  pubkey?: string;
+  serverUrl?: string;
+}) {
   const { state } = useGrimoire();
   const eventStore = useEventStore();
   const accountPubkey = state.activeAccount?.pubkey;
@@ -762,7 +768,9 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
   const [servers, setServers] = useState<string[]>([]);
   const [blobs, setBlobs] = useState<BlobDescriptor[]>([]);
   const [loading, setLoading] = useState(true);
-  const [selectedServer, setSelectedServer] = useState<string | null>(null);
+  const [selectedServer, setSelectedServer] = useState<string | null>(
+    serverUrl || null,
+  );
   const [selectedBlob, setSelectedBlob] = useState<BlobDescriptor | null>(null);
 
   // Fetch servers for the target pubkey
@@ -780,7 +788,8 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
     if (event) {
       const s = getServersFromEvent(event);
       setServers(s);
-      if (s.length > 0 && !selectedServer) {
+      // Only set default server if no serverUrl was provided and no server is selected
+      if (s.length > 0 && !selectedServer && !serverUrl) {
         setSelectedServer(s[0]);
       }
     }
@@ -799,7 +808,8 @@ function ListBlobsView({ pubkey }: { pubkey?: string }) {
         if (e) {
           const s = getServersFromEvent(e);
           setServers(s);
-          if (s.length > 0 && !selectedServer) {
+          // Only set default server if no serverUrl was provided and no server is selected
+          if (s.length > 0 && !selectedServer && !serverUrl) {
             setSelectedServer(s[0]);
           }
         }

src/components/ProfileViewer.tsx

@@ -10,7 +10,6 @@ import {
   Send,
   Wifi,
   HardDrive,
-  ExternalLink,
 } from "lucide-react";
 import { kinds, nip19 } from "nostr-tools";
 import { useEventStore, use$ } from "applesauce-react/hooks";
@@ -33,6 +32,7 @@ import { useEffect, useState } from "react";
 import type { Subscription } from "rxjs";
 import { useGrimoire } from "@/core/state";
 import { USER_SERVER_LIST_KIND, getServersFromEvent } from "@/services/blossom";
+import blossomServerCache from "@/services/blossom-server-cache";
 
 export interface ProfileViewerProps {
   pubkey: string;
@@ -43,7 +43,7 @@ export interface ProfileViewerProps {
  * Shows profile metadata, inbox/outbox relays, and raw JSON
  */
 export function ProfileViewer({ pubkey }: ProfileViewerProps) {
-  const { state } = useGrimoire();
+  const { state, addWindow } = useGrimoire();
   const accountPubkey = state.activeAccount?.pubkey;
 
   // Resolve $me alias
@@ -129,40 +129,55 @@ export function ProfileViewer({ pubkey }: ProfileViewerProps) {
 
   // Fetch Blossom server list (kind 10063)
   useEffect(() => {
-    if (!resolvedPubkey) return;
+    if (!resolvedPubkey) {
+      setBlossomServers([]);
+      return;
+    }
 
-    let subscription: Subscription | null = null;
+    // First, check cache for instant display
+    blossomServerCache.getServers(resolvedPubkey).then((cachedServers) => {
+      if (cachedServers && cachedServers.length > 0) {
+        setBlossomServers(cachedServers);
+      }
+    });
 
-    // Check if we already have the event in store
+    // Check if we already have the event in EventStore
     const existingEvent = eventStore.getReplaceable(
       USER_SERVER_LIST_KIND,
       resolvedPubkey,
       "",
     );
     if (existingEvent) {
-      setBlossomServers(getServersFromEvent(existingEvent));
+      const servers = getServersFromEvent(existingEvent);
+      setBlossomServers(servers);
+      // Also update cache
+      blossomServerCache.set(existingEvent);
     }
 
-    // Also fetch from network
+    // Subscribe to EventStore for reactive updates
-    subscription = addressLoader({
+    const storeSubscription = eventStore
+      .replaceable(USER_SERVER_LIST_KIND, resolvedPubkey, "")
+      .subscribe((event) => {
+        if (event) {
+          const servers = getServersFromEvent(event);
+          setBlossomServers(servers);
+          // Also update cache
+          blossomServerCache.set(event);
+        } else {
+          setBlossomServers([]);
+        }
+      });
+
+    // Also fetch from network to get latest data
+    const networkSubscription = addressLoader({
       kind: USER_SERVER_LIST_KIND,
       pubkey: resolvedPubkey,
       identifier: "",
-    }).subscribe({
+    }).subscribe();
-      next: () => {
-        const event = eventStore.getReplaceable(
-          USER_SERVER_LIST_KIND,
-          resolvedPubkey,
-          "",
-        );
-        if (event) {
-          setBlossomServers(getServersFromEvent(event));
-        }
-      },
-    });
 
     return () => {
-      subscription?.unsubscribe();
+      storeSubscription.unsubscribe();
+      networkSubscription.unsubscribe();
     };
   }, [resolvedPubkey, eventStore]);
 
@@ -336,14 +351,25 @@ export function ProfileViewer({ pubkey }: ProfileViewerProps) {
                 {blossomServers.map((url) => (
                   <DropdownMenuItem
                     key={url}
-                    className="flex items-center justify-between gap-2"
+                    className="flex items-center justify-between gap-2 cursor-crosshair"
-                    onClick={() => window.open(url, "_blank")}
+                    onClick={() => {
+                      if (resolvedPubkey) {
+                        addWindow(
+                          "blossom",
+                          {
+                            subcommand: "list",
+                            pubkey: resolvedPubkey,
+                            serverUrl: url,
+                          },
+                          `Files on ${url}`,
+                        );
+                      }
+                    }}
                   >
                     <div className="flex items-center gap-1.5 flex-1 min-w-0">
                       <HardDrive className="size-3 text-muted-foreground flex-shrink-0" />
                       <span className="font-mono text-xs truncate">{url}</span>
                     </div>
-                    <ExternalLink className="size-3 text-muted-foreground flex-shrink-0" />
                   </DropdownMenuItem>
                 ))}
               </DropdownMenuContent>

src/components/layouts/AppShell.tsx

@@ -2,6 +2,7 @@ import { useState, useEffect, ReactNode } from "react";
 import { Terminal } from "lucide-react";
 import { useAccountSync } from "@/hooks/useAccountSync";
 import { useRelayListCacheSync } from "@/hooks/useRelayListCacheSync";
+import { useBlossomServerCacheSync } from "@/hooks/useBlossomServerCacheSync";
 import { useRelayState } from "@/hooks/useRelayState";
 import relayStateManager from "@/services/relay-state-manager";
 import { TabBar } from "../TabBar";
@@ -25,6 +26,9 @@ export function AppShell({ children, hideBottomBar = false }: AppShellProps) {
   // Auto-cache kind:10002 relay lists from EventStore to Dexie
   useRelayListCacheSync();
 
+  // Auto-cache kind:10063 blossom server lists from EventStore to Dexie
+  useBlossomServerCacheSync();
+
   // Initialize global relay state manager
   useEffect(() => {
     relayStateManager.initialize().catch((err) => {

src/components/nostr/user-menu.tsx

@@ -1,4 +1,4 @@
-import { User } from "lucide-react";
+import { User, HardDrive } from "lucide-react";
 import accounts from "@/services/accounts";
 import { useProfile } from "@/hooks/useProfile";
 import { use$ } from "applesauce-react/hooks";
@@ -54,6 +54,7 @@ export default function UserMenu() {
   const account = use$(accounts.active$);
   const { state, addWindow } = useGrimoire();
   const relays = state.activeAccount?.relays;
+  const blossomServers = state.activeAccount?.blossomServers;
   const [showSettings, setShowSettings] = useState(false);
   const [showLogin, setShowLogin] = useState(false);
 
@@ -123,6 +124,34 @@ export default function UserMenu() {
                 </>
               )}
 
+              {blossomServers && blossomServers.length > 0 && (
+                <>
+                  <DropdownMenuSeparator />
+                  <DropdownMenuGroup>
+                    <DropdownMenuLabel className="text-xs text-muted-foreground font-normal flex items-center gap-1.5">
+                      <HardDrive className="size-3.5" />
+                      <span>Blossom Servers</span>
+                    </DropdownMenuLabel>
+                    {blossomServers.map((server) => (
+                      <DropdownMenuItem
+                        key={server}
+                        className="cursor-crosshair"
+                        onClick={() => {
+                          addWindow(
+                            "blossom",
+                            { subcommand: "list", serverUrl: server },
+                            `Files on ${server}`,
+                          );
+                        }}
+                      >
+                        <HardDrive className="size-4 text-muted-foreground mr-2" />
+                        <span className="text-sm truncate">{server}</span>
+                      </DropdownMenuItem>
+                    ))}
+                  </DropdownMenuGroup>
+                </>
+              )}
+
               <DropdownMenuSeparator />
               {/* <DropdownMenuItem
                 onClick={() => setShowSettings(true)}

src/core/logic.ts

@@ -295,6 +295,31 @@ export const setActiveAccountRelays = (
   };
 };
 
+/**
+ * Updates the blossom server list for the active account.
+ */
+export const setActiveAccountBlossomServers = (
+  state: GrimoireState,
+  blossomServers: string[],
+): GrimoireState => {
+  if (!state.activeAccount) {
+    return state;
+  }
+
+  // If blossom servers reference hasn't changed, return state unchanged
+  if (state.activeAccount.blossomServers === blossomServers) {
+    return state;
+  }
+
+  return {
+    ...state,
+    activeAccount: {
+      ...state.activeAccount,
+      blossomServers,
+    },
+  };
+};
+
 /**
  * Deletes a workspace by ID.
  * Cannot delete the last remaining workspace.

src/core/state.ts

@@ -275,6 +275,15 @@ export const useGrimoire = () => {
     [setState],
   );
 
+  const setActiveAccountBlossomServers = useCallback(
+    (blossomServers: string[]) => {
+      setState((prev) =>
+        Logic.setActiveAccountBlossomServers(prev, blossomServers),
+      );
+    },
+    [setState],
+  );
+
   const updateLayoutConfig = useCallback(
     (layoutConfig: Partial<LayoutConfig>) => {
       setState((prev) => Logic.updateLayoutConfig(prev, layoutConfig));
@@ -351,6 +360,7 @@ export const useGrimoire = () => {
     setActiveWorkspace,
     setActiveAccount,
     setActiveAccountRelays,
+    setActiveAccountBlossomServers,
     updateLayoutConfig,
     applyPresetLayout,
     updateWorkspaceLabel,

src/hooks/useAccountSync.ts

@@ -5,12 +5,17 @@ import { useGrimoire } from "@/core/state";
 import { addressLoader } from "@/services/loaders";
 import type { RelayInfo } from "@/types/app";
 import { normalizeRelayURL } from "@/lib/relay-url";
+import { getServersFromEvent } from "@/services/blossom";
 
 /**
- * Hook that syncs active account with Grimoire state and fetches relay lists
+ * Hook that syncs active account with Grimoire state and fetches relay lists and blossom servers
  */
 export function useAccountSync() {
-  const { setActiveAccount, setActiveAccountRelays } = useGrimoire();
+  const {
+    setActiveAccount,
+    setActiveAccountRelays,
+    setActiveAccountBlossomServers,
+  } = useGrimoire();
   const eventStore = useEventStore();
 
   // Watch active account from accounts service
@@ -83,4 +88,41 @@ export function useAccountSync() {
       storeSubscription.unsubscribe();
     };
   }, [activeAccount?.pubkey, eventStore, setActiveAccountRelays]);
+
+  // Fetch and watch blossom server list (kind 10063) when account changes
+  useEffect(() => {
+    if (!activeAccount?.pubkey) {
+      return;
+    }
+
+    const pubkey = activeAccount.pubkey;
+    let lastBlossomEventId: string | undefined;
+
+    // Subscribe to kind 10063 (blossom server list)
+    const subscription = addressLoader({
+      kind: 10063,
+      pubkey,
+      identifier: "",
+    }).subscribe();
+
+    // Watch for blossom server list event in store
+    const storeSubscription = eventStore
+      .replaceable(10063, pubkey, "")
+      .subscribe((blossomListEvent) => {
+        if (!blossomListEvent) return;
+
+        // Only process if this is a new event
+        if (blossomListEvent.id === lastBlossomEventId) return;
+        lastBlossomEventId = blossomListEvent.id;
+
+        // Parse servers from event
+        const servers = getServersFromEvent(blossomListEvent);
+        setActiveAccountBlossomServers(servers);
+      });
+
+    return () => {
+      subscription.unsubscribe();
+      storeSubscription.unsubscribe();
+    };
+  }, [activeAccount?.pubkey, eventStore, setActiveAccountBlossomServers]);
 }

src/hooks/useBlossomServerCacheSync.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook to keep blossom server cache in sync with EventStore
+ *
+ * Subscribes to kind:10063 events and automatically caches them in Dexie.
+ * Should be used once at app root level.
+ */
+
+import { useEffect } from "react";
+import { useEventStore } from "applesauce-react/hooks";
+import blossomServerCache from "@/services/blossom-server-cache";
+
+export function useBlossomServerCacheSync() {
+  const eventStore = useEventStore();
+
+  useEffect(() => {
+    // Subscribe to EventStore for auto-caching
+    blossomServerCache.subscribeToEventStore(eventStore);
+
+    // Cleanup on unmount
+    return () => {
+      blossomServerCache.unsubscribe();
+    };
+  }, [eventStore]);
+}

src/services/blossom-server-cache.ts

@@ -0,0 +1,285 @@
+/**
+ * Blossom Server Cache Service
+ *
+ * Caches BUD-03 blossom server lists (kind:10063) in Dexie for fast access.
+ * Reduces network requests and improves cold start performance.
+ *
+ * Auto-caches kind:10063 events from EventStore when subscribed.
+ */
+
+import type { NostrEvent } from "@/types/nostr";
+import { getServersFromEvent } from "./blossom";
+import db, { CachedBlossomServerList } from "./db";
+import type { IEventStore } from "applesauce-core/event-store";
+import type { Subscription } from "rxjs";
+
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_MEMORY_CACHE = 100; // LRU cache size
+
+class BlossomServerCache {
+  private eventStoreSubscription: Subscription | null = null;
+  private memoryCache = new Map<string, CachedBlossomServerList>();
+  private cacheOrder: string[] = [];
+
+  /**
+   * Subscribe to EventStore to auto-cache kind:10063 events
+   */
+  subscribeToEventStore(eventStore: IEventStore): void {
+    if (this.eventStoreSubscription) {
+      console.warn("[BlossomServerCache] Already subscribed to EventStore");
+      return;
+    }
+
+    // Subscribe to kind:10063 events
+    this.eventStoreSubscription = eventStore
+      .filters({ kinds: [10063] })
+      .subscribe((event: NostrEvent) => {
+        // Cache each kind:10063 event as it arrives
+        this.set(event);
+      });
+
+    console.log(
+      "[BlossomServerCache] Subscribed to EventStore for kind:10063 events",
+    );
+  }
+
+  /**
+   * Unsubscribe from EventStore
+   */
+  unsubscribe(): void {
+    if (this.eventStoreSubscription) {
+      this.eventStoreSubscription.unsubscribe();
+      this.eventStoreSubscription = null;
+      console.log("[BlossomServerCache] Unsubscribed from EventStore");
+    }
+  }
+
+  /**
+   * Get cached blossom server list for a pubkey
+   * Returns undefined if not cached or stale
+   */
+  async get(pubkey: string): Promise<CachedBlossomServerList | undefined> {
+    try {
+      const cached = await db.blossomServers.get(pubkey);
+
+      // Check if stale (>24 hours)
+      if (cached && Date.now() - cached.updatedAt < CACHE_TTL) {
+        return cached;
+      }
+
+      // Stale or not found
+      if (cached) {
+        console.debug(
+          `[BlossomServerCache] Cached server list for ${pubkey.slice(0, 8)} is stale (${Math.floor((Date.now() - cached.updatedAt) / 1000 / 60)}min old)`,
+        );
+      }
+
+      return undefined;
+    } catch (error) {
+      console.error(
+        `[BlossomServerCache] Error reading cache for ${pubkey.slice(0, 8)}:`,
+        error,
+      );
+      return undefined;
+    }
+  }
+
+  /**
+   * Store blossom server list event in cache
+   */
+  async set(event: NostrEvent): Promise<void> {
+    try {
+      if (event.kind !== 10063) {
+        console.warn(
+          `[BlossomServerCache] Attempted to cache non-10063 event (kind ${event.kind})`,
+        );
+        return;
+      }
+
+      // Parse servers from event
+      const servers = getServersFromEvent(event);
+
+      // Store in Dexie and memory cache
+      const cachedEntry: CachedBlossomServerList = {
+        pubkey: event.pubkey,
+        event,
+        servers,
+        updatedAt: Date.now(),
+      };
+
+      await db.blossomServers.put(cachedEntry);
+
+      // Also populate memory cache
+      this.memoryCache.set(event.pubkey, cachedEntry);
+      this.cacheOrder.push(event.pubkey);
+      this.evictOldest();
+
+      console.debug(
+        `[BlossomServerCache] Cached ${servers.length} server(s) for ${event.pubkey.slice(0, 8)}`,
+      );
+    } catch (error) {
+      console.error(
+        `[BlossomServerCache] Error caching server list for ${event.pubkey.slice(0, 8)}:`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Update LRU order for a pubkey
+   */
+  private updateLRU(pubkey: string): void {
+    const index = this.cacheOrder.indexOf(pubkey);
+    if (index > -1) {
+      this.cacheOrder.splice(index, 1);
+    }
+    this.cacheOrder.push(pubkey);
+  }
+
+  /**
+   * Evict oldest entries from memory cache if over limit
+   */
+  private evictOldest(): void {
+    while (this.cacheOrder.length > MAX_MEMORY_CACHE) {
+      const oldest = this.cacheOrder.shift();
+      if (oldest) {
+        this.memoryCache.delete(oldest);
+      }
+    }
+  }
+
+  /**
+   * Get blossom servers from memory cache only (synchronous, fast)
+   * Used for real-time operations where async Dexie lookup would be too slow
+   * Returns null if not in memory cache
+   */
+  getServersSync(pubkey: string): string[] | null {
+    const memCached = this.memoryCache.get(pubkey);
+    if (memCached && Date.now() - memCached.updatedAt < CACHE_TTL) {
+      this.updateLRU(pubkey);
+      return memCached.servers;
+    }
+    return null;
+  }
+
+  /**
+   * Get blossom servers for a pubkey from cache
+   */
+  async getServers(pubkey: string): Promise<string[] | null> {
+    // Check memory cache first (< 1ms)
+    const memCached = this.memoryCache.get(pubkey);
+    if (memCached && Date.now() - memCached.updatedAt < CACHE_TTL) {
+      this.updateLRU(pubkey);
+      return memCached.servers;
+    }
+
+    // Then check Dexie (5-10ms)
+    const cached = await this.get(pubkey);
+    if (cached) {
+      // Populate memory cache for next time
+      this.memoryCache.set(pubkey, cached);
+      this.cacheOrder.push(pubkey);
+      this.evictOldest();
+      return cached.servers;
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if we have a valid cache entry for a pubkey
+   */
+  async has(pubkey: string): Promise<boolean> {
+    const cached = await this.get(pubkey);
+    return cached !== undefined;
+  }
+
+  /**
+   * Invalidate (delete) cache entry for a pubkey
+   */
+  async invalidate(pubkey: string): Promise<void> {
+    try {
+      await db.blossomServers.delete(pubkey);
+      // Also remove from memory cache
+      this.memoryCache.delete(pubkey);
+      const index = this.cacheOrder.indexOf(pubkey);
+      if (index > -1) {
+        this.cacheOrder.splice(index, 1);
+      }
+      console.debug(
+        `[BlossomServerCache] Invalidated cache for ${pubkey.slice(0, 8)}`,
+      );
+    } catch (error) {
+      console.error(
+        `[BlossomServerCache] Error invalidating cache for ${pubkey.slice(0, 8)}:`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Clear all cached blossom server lists
+   */
+  async clear(): Promise<void> {
+    try {
+      await db.blossomServers.clear();
+      // Also clear memory cache
+      this.memoryCache.clear();
+      this.cacheOrder = [];
+      console.log("[BlossomServerCache] Cleared all cached server lists");
+    } catch (error) {
+      console.error("[BlossomServerCache] Error clearing cache:", error);
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  async getStats(): Promise<{
+    count: number;
+    oldestEntry: number | null;
+    newestEntry: number | null;
+    memoryCacheSize: number;
+    memoryCacheLimit: number;
+  }> {
+    try {
+      const count = await db.blossomServers.count();
+      const all = await db.blossomServers.toArray();
+
+      if (all.length === 0) {
+        return {
+          count: 0,
+          oldestEntry: null,
+          newestEntry: null,
+          memoryCacheSize: this.memoryCache.size,
+          memoryCacheLimit: MAX_MEMORY_CACHE,
+        };
+      }
+
+      const timestamps = all.map((entry) => entry.updatedAt);
+      const oldest = Math.min(...timestamps);
+      const newest = Math.max(...timestamps);
+
+      return {
+        count,
+        oldestEntry: oldest,
+        newestEntry: newest,
+        memoryCacheSize: this.memoryCache.size,
+        memoryCacheLimit: MAX_MEMORY_CACHE,
+      };
+    } catch (error) {
+      console.error("[BlossomServerCache] Error getting stats:", error);
+      return {
+        count: 0,
+        oldestEntry: null,
+        newestEntry: null,
+        memoryCacheSize: this.memoryCache.size,
+        memoryCacheLimit: MAX_MEMORY_CACHE,
+      };
+    }
+  }
+}
+
+// Singleton instance
+export const blossomServerCache = new BlossomServerCache();
+export default blossomServerCache;

src/services/db.ts

@@ -54,6 +54,13 @@ export interface RelayLivenessEntry {
   backoffUntil?: number;
 }
 
+export interface CachedBlossomServerList {
+  pubkey: string;
+  event: NostrEvent;
+  servers: string[];
+  updatedAt: number;
+}
+
 export interface LocalSpell {
   id: string; // UUID for local-only spells, or event ID for published spells
   alias?: string; // Optional local-only quick name (e.g., "btc")
@@ -88,6 +95,7 @@ class GrimoireDb extends Dexie {
   relayAuthPreferences!: Table<RelayAuthPreference>;
   relayLists!: Table<CachedRelayList>;
   relayLiveness!: Table<RelayLivenessEntry>;
+  blossomServers!: Table<CachedBlossomServerList>;
   spells!: Table<LocalSpell>;
   spellbooks!: Table<LocalSpellbook>;
 
@@ -311,6 +319,20 @@ class GrimoireDb extends Dexie {
       spells: "&id, alias, createdAt, isPublished, deletedAt",
       spellbooks: "&id, slug, title, createdAt, isPublished, deletedAt",
     });
+
+    // Version 15: Add blossom server list caching
+    this.version(15).stores({
+      profiles: "&pubkey",
+      nip05: "&nip05",
+      nips: "&id",
+      relayInfo: "&url",
+      relayAuthPreferences: "&url",
+      relayLists: "&pubkey, updatedAt",
+      relayLiveness: "&url",
+      blossomServers: "&pubkey, updatedAt",
+      spells: "&id, alias, createdAt, isPublished, deletedAt",
+      spellbooks: "&id, slug, title, createdAt, isPublished, deletedAt",
+    });
   }
 }
 

src/types/app.ts

@@ -87,6 +87,7 @@ export interface GrimoireState {
   activeAccount?: {
     pubkey: string;
     relays?: RelayInfo[];
+    blossomServers?: string[];
   };
   compactModeKinds?: number[];
   locale?: {