feat: bookmarks (#279)

src/App.tsx

@@ -4,6 +4,7 @@ import './index.css'
 import { Toaster } from '@/components/ui/toaster'
 import { ThemeProvider } from '@/providers/ThemeProvider'
 import { PageManager } from './PageManager'
+import { BookmarksProvider } from './providers/BookmarksProvider'
 import { FavoriteRelaysProvider } from './providers/FavoriteRelaysProvider'
 import { FeedProvider } from './providers/FeedProvider'
 import { FollowListProvider } from './providers/FollowListProvider'
@@ -23,14 +24,16 @@ export default function App(): JSX.Element {
             <FavoriteRelaysProvider>
               <FollowListProvider>
                 <MuteListProvider>
-                  <FeedProvider>
+                  <BookmarksProvider>
-                    <NoteStatsProvider>
+                    <FeedProvider>
-                      <MediaUploadServiceProvider>
+                      <NoteStatsProvider>
-                        <PageManager />
+                        <MediaUploadServiceProvider>
-                        <Toaster />
+                          <PageManager />
-                      </MediaUploadServiceProvider>
+                          <Toaster />
-                    </NoteStatsProvider>
+                        </MediaUploadServiceProvider>
-                  </FeedProvider>
+                      </NoteStatsProvider>
+                    </FeedProvider>
+                  </BookmarksProvider>
                 </MuteListProvider>
               </FollowListProvider>
             </FavoriteRelaysProvider>

src/components/BookmarkButton/index.tsx

@@ -0,0 +1,90 @@
+import { useToast } from '@/hooks'
+import { useBookmarks } from '@/providers/BookmarksProvider'
+import { useNostr } from '@/providers/NostrProvider'
+import { BookmarkIcon, Loader } from 'lucide-react'
+import { useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Event } from 'nostr-tools'
+
+export default function BookmarkButton({ event }: { event: Event }) {
+  const { t } = useTranslation()
+  const { toast } = useToast()
+  const { pubkey: accountPubkey, checkLogin } = useNostr()
+  const { bookmarks, addBookmark, removeBookmark } = useBookmarks()
+  const [updating, setUpdating] = useState(false)
+
+  const eventId = event.id
+  const eventPubkey = event.pubkey
+
+  const isBookmarked = useMemo(
+    () => bookmarks.some((tag) => tag[0] === 'e' && tag[1] === eventId),
+    [bookmarks, eventId]
+  )
+
+  if (!accountPubkey) return null
+
+  const handleBookmark = async (e: React.MouseEvent) => {
+    e.stopPropagation()
+    checkLogin(async () => {
+      if (isBookmarked) return
+
+      setUpdating(true)
+      try {
+        await addBookmark(eventId, eventPubkey)
+        toast({
+          title: t('Note bookmarked'),
+          description: t('This note has been added to your bookmarks')
+        })
+      } catch (error) {
+        toast({
+          title: t('Bookmark failed'),
+          description: (error as Error).message,
+          variant: 'destructive'
+        })
+      } finally {
+        setUpdating(false)
+      }
+    })
+  }
+
+  const handleRemoveBookmark = async (e: React.MouseEvent) => {
+    e.stopPropagation()
+    checkLogin(async () => {
+      if (!isBookmarked) return
+
+      setUpdating(true)
+      try {
+        await removeBookmark(eventId)
+        toast({
+          title: t('Bookmark removed'),
+          description: t('This note has been removed from your bookmarks')
+        })
+      } catch (error) {
+        toast({
+          title: t('Remove bookmark failed'),
+          description: (error as Error).message,
+          variant: 'destructive'
+        })
+      } finally {
+        setUpdating(false)
+      }
+    })
+  }
+
+  return (
+    <button
+      className={`flex items-center gap-1 ${
+        isBookmarked ? 'text-primary' : 'text-muted-foreground'
+      } enabled:hover:text-primary px-3 h-full`}
+      onClick={isBookmarked ? handleRemoveBookmark : handleBookmark}
+      disabled={updating}
+      title={isBookmarked ? t('Remove bookmark') : t('Bookmark')}
+    >
+      {updating ? (
+        <Loader className="animate-spin" />
+      ) : (
+        <BookmarkIcon className={isBookmarked ? 'fill-primary' : ''} />
+      )}
+    </button>
+  )
+}

src/components/BookmarksList/index.tsx

@@ -0,0 +1,107 @@
+import { useFetchEvent } from '@/hooks'
+import { useBookmarks } from '@/providers/BookmarksProvider'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { generateEventIdFromETag } from '@/lib/tag'
+import NoteCard, { NoteCardLoadingSkeleton } from '../NoteCard'
+
+export default function BookmarksList() {
+  const { t } = useTranslation()
+  const { bookmarks } = useBookmarks()
+  const [visibleBookmarks, setVisibleBookmarks] = useState<
+    { eventId: string; neventId?: string }[]
+  >([])
+  const [loading, setLoading] = useState(true)
+  const bottomRef = useRef<HTMLDivElement | null>(null)
+  const SHOW_COUNT = 10
+
+  const bookmarkItems = useMemo(() => {
+    return bookmarks
+      .filter((tag) => tag[0] === 'e')
+      .map((tag) => ({
+        eventId: tag[1],
+        neventId: generateEventIdFromETag(tag)
+      }))
+      .reverse()
+  }, [bookmarks])
+
+  useEffect(() => {
+    setVisibleBookmarks(bookmarkItems.slice(0, SHOW_COUNT))
+    setLoading(false)
+  }, [bookmarkItems])
+
+  useEffect(() => {
+    const options = {
+      root: null,
+      rootMargin: '10px',
+      threshold: 0.1
+    }
+
+    const loadMore = () => {
+      if (visibleBookmarks.length < bookmarkItems.length) {
+        setVisibleBookmarks((prev) => [
+          ...prev,
+          ...bookmarkItems.slice(prev.length, prev.length + SHOW_COUNT)
+        ])
+      }
+    }
+
+    const observerInstance = new IntersectionObserver((entries) => {
+      if (entries[0].isIntersecting) {
+        loadMore()
+      }
+    }, options)
+
+    const currentBottomRef = bottomRef.current
+
+    if (currentBottomRef) {
+      observerInstance.observe(currentBottomRef)
+    }
+
+    return () => {
+      if (observerInstance && currentBottomRef) {
+        observerInstance.unobserve(currentBottomRef)
+      }
+    }
+  }, [visibleBookmarks, bookmarkItems])
+
+  if (loading) {
+    return <NoteCardLoadingSkeleton isPictures={false} />
+  }
+
+  if (bookmarkItems.length === 0) {
+    return (
+      <div className="mt-2 text-sm text-center text-muted-foreground">
+        {t('No bookmarks found. Add some by clicking the bookmark icon on notes.')}
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-4">
+      {visibleBookmarks.map((item) => (
+        <BookmarkedNote key={item.eventId} eventId={item.eventId} neventId={item.neventId} />
+      ))}
+
+      {visibleBookmarks.length < bookmarkItems.length && (
+        <div ref={bottomRef}>
+          <NoteCardLoadingSkeleton isPictures={false} />
+        </div>
+      )}
+    </div>
+  )
+}
+
+function BookmarkedNote({ eventId, neventId }: { eventId: string; neventId?: string }) {
+  const { event, isFetching } = useFetchEvent(neventId || eventId)
+
+  if (isFetching) {
+    return <NoteCardLoadingSkeleton isPictures={false} />
+  }
+
+  if (!event) {
+    return null
+  }
+
+  return <NoteCard event={event} className="w-full" />
+}

src/components/FeedSwitcher/index.tsx

@@ -1,6 +1,7 @@
 import { toRelaySettings } from '@/lib/link'
 import { simplifyUrl } from '@/lib/url'
 import { SecondaryPageLink } from '@/PageManager'
+import { useBookmarks } from '@/providers/BookmarksProvider'
 import { useFavoriteRelays } from '@/providers/FavoriteRelaysProvider'
 import { useFeed } from '@/providers/FeedProvider'
 import { useNostr } from '@/providers/NostrProvider'
@@ -8,11 +9,12 @@ import { useTranslation } from 'react-i18next'
 import RelayIcon from '../RelayIcon'
 import RelaySetCard from '../RelaySetCard'
 import SaveRelayDropdownMenu from '../SaveRelayDropdownMenu'
-import { UsersRound } from 'lucide-react'
+import { BookmarkIcon, UsersRound } from 'lucide-react'
 
 export default function FeedSwitcher({ close }: { close?: () => void }) {
   const { t } = useTranslation()
   const { pubkey } = useNostr()
+  const { bookmarks } = useBookmarks()
   const { relaySets, favoriteRelays } = useFavoriteRelays()
   const { feedInfo, switchFeed, temporaryRelayUrls } = useFeed()
 
@@ -35,6 +37,25 @@ export default function FeedSwitcher({ close }: { close?: () => void }) {
           </div>
         </FeedSwitcherItem>
       )}
+
+      {pubkey && bookmarks.length > 0 && (
+        <FeedSwitcherItem
+          isActive={feedInfo.feedType === 'bookmarks'}
+          onClick={() => {
+            if (!pubkey) return
+            switchFeed('bookmarks', { pubkey })
+            close?.()
+          }}
+        >
+          <div className="flex gap-2 items-center">
+            <div className="flex justify-center items-center w-6 h-6 shrink-0">
+              <BookmarkIcon className="size-4" />
+            </div>
+            <div>{t('Bookmarks')}</div>
+          </div>
+        </FeedSwitcherItem>
+      )}
+
       {temporaryRelayUrls.length > 0 && (
         <FeedSwitcherItem
           key="temporary"

src/components/NoteStats/index.tsx

@@ -3,6 +3,7 @@ import { useNoteStats } from '@/providers/NoteStatsProvider'
 import { useScreenSize } from '@/providers/ScreenSizeProvider'
 import { Event } from 'nostr-tools'
 import { useEffect } from 'react'
+import BookmarkButton from '../BookmarkButton'
 import LikeButton from './LikeButton'
 import ReplyButton from './ReplyButton'
 import RepostButton from './RepostButton'
@@ -48,6 +49,7 @@ export default function NoteStats({
           <RepostButton event={event} />
           <LikeButton event={event} />
           <ZapButton event={event} />
+          <BookmarkButton event={event} />
           <SeenOnButton event={event} />
         </div>
       </div>
@@ -63,6 +65,7 @@ export default function NoteStats({
           <RepostButton event={event} />
           <LikeButton event={event} />
           <ZapButton event={event} />
+          <BookmarkButton event={event} />
         </div>
         <div className="flex items-center" onClick={(e) => e.stopPropagation()}>
           <SeenOnButton event={event} />

src/lib/draft-event.ts

@@ -283,6 +283,15 @@ export function createSeenNotificationsAtDraftEvent(): TDraftEvent {
   }
 }
 
+export function createBookmarkDraftEvent(tags: string[][]): TDraftEvent {
+  return {
+    kind: kinds.BookmarkList,
+    content: '',
+    tags,
+    created_at: dayjs().unix()
+  }
+}
+
 function generateImetaTags(imageUrls: string[], pictureInfos: { url: string; tags: string[][] }[]) {
   return imageUrls.map((imageUrl) => {
     const pictureInfo = pictureInfos.find((info) => info.url === imageUrl)

src/pages/primary/NoteListPage/FeedButton.tsx

@@ -6,7 +6,7 @@ import { cn } from '@/lib/utils'
 import { useFavoriteRelays } from '@/providers/FavoriteRelaysProvider'
 import { useFeed } from '@/providers/FeedProvider'
 import { useScreenSize } from '@/providers/ScreenSizeProvider'
-import { ChevronDown, Server, UsersRound } from 'lucide-react'
+import { BookmarkIcon, ChevronDown, Server, UsersRound } from 'lucide-react'
 import { forwardRef, HTMLAttributes, useMemo, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 
@@ -55,6 +55,9 @@ const FeedSwitcherTrigger = forwardRef<HTMLDivElement, HTMLAttributes<HTMLDivEle
       if (feedInfo.feedType === 'following') {
         return t('Following')
       }
+      if (feedInfo.feedType === 'bookmarks') {
+        return t('Bookmarks')
+      }
       if (relayUrls.length === 0) {
         return t('Choose a relay')
       }
@@ -77,7 +80,13 @@ const FeedSwitcherTrigger = forwardRef<HTMLDivElement, HTMLAttributes<HTMLDivEle
         ref={ref}
         {...props}
       >
-        {feedInfo.feedType === 'following' ? <UsersRound /> : <Server />}
+        {feedInfo.feedType === 'following' ? (
+          <UsersRound />
+        ) : feedInfo.feedType === 'bookmarks' ? (
+          <BookmarkIcon />
+        ) : (
+          <Server />
+        )}
         <div className="text-lg font-semibold truncate">{title}</div>
         <ChevronDown />
       </div>

src/pages/primary/NoteListPage/index.tsx

@@ -1,3 +1,4 @@
+import BookmarksList from '@/components/BookmarksList'
 import NoteList from '@/components/NoteList'
 import PostEditor from '@/components/PostEditor'
 import SaveRelayDropdownMenu from '@/components/SaveRelayDropdownMenu'
@@ -35,6 +36,18 @@ const NoteListPage = forwardRef((_, ref) => {
         </Button>
       </div>
     )
+  } else if (feedInfo.feedType === 'bookmarks') {
+    if (!pubkey) {
+      content = (
+        <div className="flex justify-center w-full">
+          <Button size="lg" onClick={() => checkLogin()}>
+            {t('Please login to view bookmarks')}
+          </Button>
+        </div>
+      )
+    } else {
+      content = <BookmarksList />
+    }
   } else if (isReady) {
     content = (
       <NoteList

src/providers/BookmarksProvider.tsx

@@ -0,0 +1,72 @@
+import { createBookmarkDraftEvent } from '@/lib/draft-event'
+import { createContext, useContext, useMemo } from 'react'
+import { useNostr } from './NostrProvider'
+import client from '@/services/client.service'
+
+type TBookmarksContext = {
+  bookmarks: string[][]
+  addBookmark: (eventId: string, eventPubkey: string, relayHint?: string) => Promise<void>
+  removeBookmark: (eventId: string) => Promise<void>
+}
+
+const BookmarksContext = createContext<TBookmarksContext | undefined>(undefined)
+
+export const useBookmarks = () => {
+  const context = useContext(BookmarksContext)
+  if (!context) {
+    throw new Error('useBookmarks must be used within a BookmarksProvider')
+  }
+  return context
+}
+
+export function BookmarksProvider({ children }: { children: React.ReactNode }) {
+  const { pubkey: accountPubkey, bookmarkListEvent, publish, updateBookmarkListEvent } = useNostr()
+  const bookmarks = useMemo(
+    () => (bookmarkListEvent ? bookmarkListEvent.tags : []),
+    [bookmarkListEvent]
+  )
+
+  const addBookmark = async (eventId: string, eventPubkey: string, relayHint?: string) => {
+    if (!accountPubkey) return
+
+    const relayHintToUse = relayHint || client.getEventHint(eventId)
+
+    const newTag = ['e', eventId, relayHintToUse, eventPubkey]
+
+    const currentTags = bookmarkListEvent?.tags || []
+
+    const isDuplicate = currentTags.some((tag) => tag[0] === 'e' && tag[1] === eventId)
+
+    if (isDuplicate) return
+
+    const newTags = [...currentTags, newTag]
+
+    const newBookmarkDraftEvent = createBookmarkDraftEvent(newTags)
+    const newBookmarkEvent = await publish(newBookmarkDraftEvent)
+    await updateBookmarkListEvent(newBookmarkEvent)
+  }
+
+  const removeBookmark = async (eventId: string) => {
+    if (!accountPubkey || !bookmarkListEvent) return
+
+    const newTags = bookmarkListEvent.tags.filter((tag) => !(tag[0] === 'e' && tag[1] === eventId))
+
+    if (newTags.length === bookmarkListEvent.tags.length) return
+
+    const newBookmarkDraftEvent = createBookmarkDraftEvent(newTags)
+    const newBookmarkEvent = await publish(newBookmarkDraftEvent)
+    await updateBookmarkListEvent(newBookmarkEvent)
+  }
+
+  return (
+    <BookmarksContext.Provider
+      value={{
+        bookmarks,
+        addBookmark,
+        removeBookmark
+      }}
+    >
+      {children}
+    </BookmarksContext.Provider>
+  )
+}

src/providers/FeedProvider.tsx

@@ -170,6 +170,20 @@ export function FeedProvider({ children }: { children: React.ReactNode }) {
       })
       return setIsReady(true)
     }
+    if (feedType === 'bookmarks') {
+      if (!options.pubkey) {
+        return setIsReady(true)
+      }
+
+      const newFeedInfo = { feedType }
+      setFeedInfo(newFeedInfo)
+      feedInfoRef.current = newFeedInfo
+      storage.setFeedInfo(newFeedInfo, pubkey)
+
+      setRelayUrls([])
+      setFilter({})
+      return setIsReady(true)
+    }
     if (feedType === 'temporary') {
       const urls = options.temporaryRelayUrls ?? temporaryRelayUrls
       if (!urls.length) {

src/providers/NostrProvider/index.tsx

@@ -33,6 +33,7 @@ type TNostrContext = {
   relayList: TRelayList | null
   followListEvent?: Event
   muteListEvent?: Event
+  bookmarkListEvent?: Event
   favoriteRelaysEvent: Event | null
   notificationsSeenAt: number
   account: TAccountPointer | null
@@ -60,6 +61,7 @@ type TNostrContext = {
   updateProfileEvent: (profileEvent: Event) => Promise<void>
   updateFollowListEvent: (followListEvent: Event) => Promise<void>
   updateMuteListEvent: (muteListEvent: Event, tags: string[][]) => Promise<void>
+  updateBookmarkListEvent: (bookmarkListEvent: Event) => Promise<void>
   updateFavoriteRelaysEvent: (favoriteRelaysEvent: Event) => Promise<void>
   updateNotificationsSeenAt: () => Promise<void>
 }
@@ -87,6 +89,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
   const [relayList, setRelayList] = useState<TRelayList | null>(null)
   const [followListEvent, setFollowListEvent] = useState<Event | undefined>(undefined)
   const [muteListEvent, setMuteListEvent] = useState<Event | undefined>(undefined)
+  const [bookmarkListEvent, setBookmarkListEvent] = useState<Event | undefined>(undefined)
   const [favoriteRelaysEvent, setFavoriteRelaysEvent] = useState<Event | null>(null)
   const [notificationsSeenAt, setNotificationsSeenAt] = useState(-1)
   const [isInitialized, setIsInitialized] = useState(false)
@@ -149,12 +152,14 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
         storedProfileEvent,
         storedFollowListEvent,
         storedMuteListEvent,
+        storedBookmarkListEvent,
         storedFavoriteRelaysEvent
       ] = await Promise.all([
         indexedDb.getReplaceableEvent(account.pubkey, kinds.RelayList),
         indexedDb.getReplaceableEvent(account.pubkey, kinds.Metadata),
         indexedDb.getReplaceableEvent(account.pubkey, kinds.Contacts),
         indexedDb.getReplaceableEvent(account.pubkey, kinds.Mutelist),
+        indexedDb.getReplaceableEvent(account.pubkey, kinds.BookmarkList),
         indexedDb.getReplaceableEvent(account.pubkey, ExtendedKind.FAVORITE_RELAYS)
       ])
       if (storedRelayListEvent) {
@@ -172,6 +177,9 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
       if (storedMuteListEvent) {
         setMuteListEvent(storedMuteListEvent)
       }
+      if (storedBookmarkListEvent) {
+        setBookmarkListEvent(storedBookmarkListEvent)
+      }
       if (storedFavoriteRelaysEvent) {
         setFavoriteRelaysEvent(storedFavoriteRelaysEvent)
       }
@@ -190,7 +198,13 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
 
       const events = await client.fetchEvents(relayList.write.concat(BIG_RELAY_URLS).slice(0, 4), [
         {
-          kinds: [kinds.Metadata, kinds.Contacts, kinds.Mutelist, ExtendedKind.FAVORITE_RELAYS],
+          kinds: [
+            kinds.Metadata,
+            kinds.Contacts,
+            kinds.Mutelist,
+            kinds.BookmarkList,
+            ExtendedKind.FAVORITE_RELAYS
+          ],
           authors: [account.pubkey]
         },
         {
@@ -203,6 +217,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
       const profileEvent = sortedEvents.find((e) => e.kind === kinds.Metadata)
       const followListEvent = sortedEvents.find((e) => e.kind === kinds.Contacts)
       const muteListEvent = sortedEvents.find((e) => e.kind === kinds.Mutelist)
+      const bookmarkListEvent = sortedEvents.find((e) => e.kind === kinds.BookmarkList)
       const favoriteRelaysEvent = sortedEvents.find((e) => e.kind === ExtendedKind.FAVORITE_RELAYS)
       const notificationsSeenAtEvent = sortedEvents.find(
         (e) =>
@@ -227,6 +242,10 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
         setMuteListEvent(muteListEvent)
         await indexedDb.putReplaceableEvent(muteListEvent)
       }
+      if (bookmarkListEvent) {
+        setBookmarkListEvent(bookmarkListEvent)
+        await indexedDb.putReplaceableEvent(bookmarkListEvent)
+      }
       if (favoriteRelaysEvent) {
         setFavoriteRelaysEvent(favoriteRelaysEvent)
         await indexedDb.putReplaceableEvent(favoriteRelaysEvent)
@@ -563,6 +582,13 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
     setMuteListEvent(muteListEvent)
   }
 
+  const updateBookmarkListEvent = async (bookmarkListEvent: Event) => {
+    const newBookmarkListEvent = await indexedDb.putReplaceableEvent(bookmarkListEvent)
+    if (newBookmarkListEvent.id !== bookmarkListEvent.id) return
+
+    setBookmarkListEvent(newBookmarkListEvent)
+  }
+
   const updateFavoriteRelaysEvent = async (favoriteRelaysEvent: Event) => {
     const newFavoriteRelaysEvent = await indexedDb.putReplaceableEvent(favoriteRelaysEvent)
     if (newFavoriteRelaysEvent.id !== favoriteRelaysEvent.id) return
@@ -591,6 +617,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
         relayList,
         followListEvent,
         muteListEvent,
+        bookmarkListEvent,
         favoriteRelaysEvent,
         notificationsSeenAt,
         account,
@@ -617,6 +644,7 @@ export function NostrProvider({ children }: { children: React.ReactNode }) {
         updateProfileEvent,
         updateFollowListEvent,
         updateMuteListEvent,
+        updateBookmarkListEvent,
         updateFavoriteRelaysEvent,
         updateNotificationsSeenAt
       }}

src/services/indexed-db.service.ts

@@ -13,6 +13,7 @@ const StoreNames = {
   RELAY_LIST_EVENTS: 'relayListEvents',
   FOLLOW_LIST_EVENTS: 'followListEvents',
   MUTE_LIST_EVENTS: 'muteListEvents',
+  BOOKMARK_LIST_EVENTS: 'bookmarkListEvents',
   MUTE_DECRYPTED_TAGS: 'muteDecryptedTags',
   RELAY_INFO_EVENTS: 'relayInfoEvents',
   FAVORITE_RELAYS: 'favoriteRelays',
@@ -35,7 +36,7 @@ class IndexedDbService {
   init(): Promise<void> {
     if (!this.initPromise) {
       this.initPromise = new Promise((resolve, reject) => {
-        const request = window.indexedDB.open('jumble', 3)
+        const request = window.indexedDB.open('jumble', 4)
 
         request.onerror = (event) => {
           reject(event)
@@ -60,6 +61,9 @@ class IndexedDbService {
           if (!db.objectStoreNames.contains(StoreNames.MUTE_LIST_EVENTS)) {
             db.createObjectStore(StoreNames.MUTE_LIST_EVENTS, { keyPath: 'key' })
           }
+          if (!db.objectStoreNames.contains(StoreNames.BOOKMARK_LIST_EVENTS)) {
+            db.createObjectStore(StoreNames.BOOKMARK_LIST_EVENTS, { keyPath: 'key' })
+          }
           if (!db.objectStoreNames.contains(StoreNames.MUTE_DECRYPTED_TAGS)) {
             db.createObjectStore(StoreNames.MUTE_DECRYPTED_TAGS, { keyPath: 'key' })
           }
@@ -335,6 +339,8 @@ class IndexedDbService {
         return StoreNames.RELAY_SETS
       case ExtendedKind.FAVORITE_RELAYS:
         return StoreNames.FAVORITE_RELAYS
+      case kinds.BookmarkList:
+        return StoreNames.BOOKMARK_LIST_EVENTS
       default:
         return undefined
     }
@@ -360,7 +366,7 @@ class IndexedDbService {
       {
         name: StoreNames.FOLLOW_LIST_EVENTS,
         expirationTimestamp: Date.now() - 1000 * 60 * 60 * 24
-      } // 1 day
+      }
     ]
     const transaction = this.db!.transaction(
       stores.map((store) => store.name),

src/types.ts

@@ -94,7 +94,7 @@ export type TAccount = {
 
 export type TAccountPointer = Pick<TAccount, 'pubkey' | 'signerType'>
 
-export type TFeedType = 'following' | 'relays' | 'relay' | 'temporary'
+export type TFeedType = 'following' | 'relays' | 'relay' | 'temporary' | 'bookmarks'
 export type TFeedInfo = { feedType: TFeedType; id?: string }
 
 export type TLanguage = 'en' | 'zh' | 'pl'