applesauce-core 0.12.0 → 1.0.0

package/dist/queries/comments.js

@@ -1,14 +1,11 @@
 import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 /** Returns all NIP-22 comment replies for the event */
 export function CommentsQuery(parent) {
-    return {
-        key: `${getEventUID(parent)}-comments`,
-        run: (events) => {
-            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
-            if (isParameterizedReplaceableKind(parent.kind))
-                filter["#a"] = [getEventUID(parent)];
-            return events.timeline(filter);
-        },
+    return (events) => {
+        const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+        if (isAddressableKind(parent.kind))
+            filter["#a"] = [getEventUID(parent)];
+        return events.timeline(filter);
     };
 }

package/dist/queries/contacts.d.ts

@@ -1,3 +1,8 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Query } from "../query-store/index.js";
-export declare function UserContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all contacts for a user */
+export declare function ContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all public contacts for a user */
+export declare function PublicContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all hidden contacts for a user */
+export declare function HiddenContactsQuery(pubkey: string): Query<ProfilePointer[] | null | undefined>;

package/dist/queries/contacts.js

@@ -1,12 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isPTag, processTags } from "../helpers/tags.js";
-import { getProfilePointerFromPTag } from "../helpers/pointers.js";
-export function UserContactsQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Contacts, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isPTag), getProfilePointerFromPTag))),
-    };
+import { getContacts, getHiddenContacts, getPublicContacts } from "../helpers/contacts.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all contacts for a user */
+export function ContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all contacts
+    map((e) => e && getContacts(e)));
+}
+/** A query that returns all public contacts for a user */
+export function PublicContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(map((e) => e && getPublicContacts(e)));
+}
+/** A query that returns all hidden contacts for a user */
+export function HiddenContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden contacts
+    map((e) => e && (getHiddenContacts(e) ?? null)));
 }

package/dist/queries/index.d.ts

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/index.js

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/mailboxes.js

@@ -3,11 +3,8 @@ import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 /** A query that gets and parses the inbox and outbox relays for a pubkey */
 export function MailboxesQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
-            inboxes: getInboxes(event),
-            outboxes: getOutboxes(event),
-        })),
-    };
+    return (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+        inboxes: getInboxes(event),
+        outboxes: getOutboxes(event),
+    }));
 }

package/dist/queries/mutes.d.ts

@@ -1,8 +1,8 @@
 import { Mutes } from "../helpers/mutes.js";
 import { Query } from "../query-store/index.js";
-export declare function UserMuteQuery(pubkey: string): Query<Mutes | undefined>;
-export declare function UserHiddenMuteQuery(pubkey: string): Query<(Mutes & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all a users muted things */
+export declare function MuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users public muted things */
+export declare function PublicMuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users hidden muted things */
+export declare function HiddenMuteQuery(pubkey: string): Query<Mutes | null | undefined>;

package/dist/queries/mutes.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { getHiddenMutedThings, getMutedThings } from "../helpers/mutes.js";
-import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
-export function UserMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (event) => event.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
-    };
+import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/** A query that returns all a users muted things */
+export function MuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all muted things
+    map((event) => event && getMutedThings(event)));
 }
-export function UserHiddenMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const muted = getHiddenMutedThings(event);
-            if (isHiddenTagsLocked(event) || !muted)
-                return { locked: true };
-            return { locked: false, ...muted };
-        })),
-    };
+/** A query that returns all a users public muted things */
+export function PublicMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicMutedThings(event)));
+}
+/** A query that returns all a users hidden muted things */
+export function HiddenMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden muted things
+    map((event) => event && getHiddenMutedThings(event)));
 }

package/dist/queries/pins.d.ts

@@ -1,3 +1,4 @@
 import { Query } from "applesauce-core";
 import { EventPointer } from "nostr-tools/nip19";
+/** A query that returns all pinned pointers for a user */
 export declare function UserPinnedQuery(pubkey: string): Query<EventPointer[] | undefined>;

package/dist/queries/pins.js

@@ -2,11 +2,9 @@ import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { isETag, processTags } from "../helpers/tags.js";
 import { getEventPointerFromETag } from "../helpers/pointers.js";
+/** A query that returns all pinned pointers for a user */
 export function UserPinnedQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Pinlist, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag))),
-    };
+    return (events) => events
+        .replaceable(kinds.Pinlist, pubkey)
+        .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag)));
 }

package/dist/queries/profile.js

@@ -3,10 +3,5 @@ import { filter, map } from "rxjs/operators";
 import { getProfileContent, isValidProfile } from "../helpers/profile.js";
 /** A query that gets and parses the kind 0 metadata for a pubkey */
 export function ProfileQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => {
-            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
-        },
-    };
+    return (events) => events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
 }

package/dist/queries/reactions.js

@@ -2,18 +2,15 @@ import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
 /** A query that returns all reactions to an event (supports replaceable events) */
 export function ReactionsQuery(event) {
-    return {
-        key: getEventUID(event),
-        run: (events) => events.timeline(isReplaceable(event.kind)
-            ? [
-                { kinds: [kinds.Reaction], "#e": [event.id] },
-                { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
-            ]
-            : [
-                {
-                    kinds: [kinds.Reaction],
-                    "#e": [event.id],
-                },
-            ]),
-    };
+    return (events) => events.timeline(isReplaceable(event.kind)
+        ? [
+            { kinds: [kinds.Reaction], "#e": [event.id] },
+            { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+        ]
+        : [
+            {
+                kinds: [kinds.Reaction],
+                "#e": [event.id],
+            },
+        ]);
 }

package/dist/queries/relays.d.ts

@@ -0,0 +1,27 @@
+import { AddressPointer } from "nostr-tools/nip19";
+import { ReadListTags } from "../helpers/lists.js";
+import { Query } from "../query-store/query-store.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelaySets(pubkey: string, type?: ReadListTags): Query<AddressPointer[] | undefined>;
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export declare function SearchRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export declare function BlockedRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;

package/dist/queries/relays.js

@@ -0,0 +1,44 @@
+import { kinds } from "nostr-tools";
+import { identity, map } from "rxjs";
+import { FAVORITE_RELAYS_KIND, getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelaySets(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getAddressPointersFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export function SearchRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.SearchRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export function BlockedRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.BlockedRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}

package/dist/queries/simple.js

@@ -1,38 +1,21 @@
-import hash_sum from "hash-sum";
-import { getReplaceableUID } from "../helpers/event.js";
 /** Creates a Query that returns a single event or undefined */
 export function SingleEventQuery(id) {
-    return {
-        key: id,
-        run: (events) => events.event(id),
-    };
+    return (events) => events.event(id);
 }
 /** Creates a Query that returns a multiple events in a map */
 export function MultipleEventsQuery(ids) {
-    return {
-        key: ids.join(","),
-        run: (events) => events.events(ids),
-    };
+    return (events) => events.events(ids);
 }
 /** Creates a Query returning the latest version of a replaceable event */
 export function ReplaceableQuery(kind, pubkey, d) {
-    return {
-        key: getReplaceableUID(kind, pubkey, d),
-        run: (events) => events.replaceable(kind, pubkey, d),
-    };
+    return (events) => events.replaceable(kind, pubkey, d);
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
 export function TimelineQuery(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
-    return {
-        key: hash_sum(filters) + (includeOldVersion ? "-history" : ""),
-        run: (events) => events.timeline(filters, includeOldVersion),
-    };
+    return (events) => events.timeline(filters, includeOldVersion);
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    return {
-        key: hash_sum(pointers),
-        run: (events) => events.replaceableSet(pointers),
-    };
+    return (events) => events.replaceableSet(pointers);
 }

package/dist/queries/thread.js

@@ -1,9 +1,9 @@
 import { kinds } from "nostr-tools";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
 import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
 import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
-import { getEventUID, getReplaceableUID, getTagValue, isEvent } from "../helpers/event.js";
+import { getEventUID, createReplaceableAddress, getTagValue, isEvent } from "../helpers/event.js";
 import { COMMENT_KIND } from "../helpers/comment.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
@@ -32,61 +32,55 @@ export function ThreadQuery(root, opts) {
         rootFilter.ids = [root.id];
         replyFilter["#e"] = [root.id];
     }
-    return {
-        key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
-            if (!items.has(getEventUID(event))) {
-                const refs = getNip10References(event);
-                const replies = parentReferences.get(getEventUID(event)) || new Set();
-                const item = { event, refs, replies };
-                for (const child of replies) {
-                    child.parent = item;
+    return (events) => events.filters([rootFilter, replyFilter]).pipe(map((event) => {
+        if (!items.has(getEventUID(event))) {
+            const refs = getNip10References(event);
+            const replies = parentReferences.get(getEventUID(event)) || new Set();
+            const item = { event, refs, replies };
+            for (const child of replies) {
+                child.parent = item;
+            }
+            // add item to parent
+            if (refs.reply?.e || refs.reply?.a) {
+                let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
+                item.parent = items.get(uid);
+                if (item.parent) {
+                    item.parent.replies.add(item);
                 }
-                // add item to parent
-                if (refs.reply?.e || refs.reply?.a) {
-                    let uid = refs.reply.e ? refs.reply.e.id : getCoordinateFromAddressPointer(refs.reply.a);
-                    item.parent = items.get(uid);
-                    if (item.parent) {
-                        item.parent.replies.add(item);
-                    }
-                    else {
-                        // parent isn't created yet, store ref for later
-                        let set = parentReferences.get(uid);
-                        if (!set) {
-                            set = new Set();
-                            parentReferences.set(uid, set);
-                        }
-                        set.add(item);
+                else {
+                    // parent isn't created yet, store ref for later
+                    let set = parentReferences.get(uid);
+                    if (!set) {
+                        set = new Set();
+                        parentReferences.set(uid, set);
                     }
+                    set.add(item);
                 }
-                // add item to map
-                items.set(getEventUID(event), item);
             }
-            return { root: items.get(rootUID), all: items };
-        })),
-    };
+            // add item to map
+            items.set(getEventUID(event), item);
+        }
+        return { root: items.get(rootUID), all: items };
+    }));
 }
 /** A query that gets all legacy and NIP-10, and NIP-22 replies for an event */
 export function RepliesQuery(event, overrideKinds) {
-    return {
-        key: getEventUID(event),
-        run: (events) => {
-            const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
-            const filter = { kinds };
-            if (isEvent(parent) || isEventPointer(event))
-                filter["#e"] = [event.id];
-            const address = isParameterizedReplaceableKind(event.kind)
-                ? getReplaceableUID(event.kind, event.pubkey, getTagValue(event, "d"))
-                : undefined;
-            if (address) {
-                filter["#a"] = [address];
-            }
-            return events.timeline(filter).pipe(map((events) => {
-                return events.filter((e) => {
-                    const refs = interpretThreadTags(e.tags);
-                    return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
-                });
-            }));
-        },
+    return (events) => {
+        const kinds = overrideKinds || event.kind === 1 ? [1, COMMENT_KIND] : [COMMENT_KIND];
+        const filter = { kinds };
+        if (isEvent(parent) || isEventPointer(event))
+            filter["#e"] = [event.id];
+        const address = isAddressableKind(event.kind)
+            ? createReplaceableAddress(event.kind, event.pubkey, getTagValue(event, "d"))
+            : undefined;
+        if (address) {
+            filter["#a"] = [address];
+        }
+        return events.timeline(filter).pipe(map((events) => {
+            return events.filter((e) => {
+                const refs = interpretThreadTags(e.tags);
+                return refs.reply?.e?.[1] === event.id || refs.reply?.a?.[1] === address;
+            });
+        }));
     };
 }

package/dist/queries/user-status.js

@@ -4,36 +4,30 @@ import { getUserStatusPointer } from "../helpers/user-status.js";
 import { getReplaceableIdentifier } from "../helpers/event.js";
 /** Creates a Query that returns a parsed {@link UserStatus} for a certain type */
 export function UserStatusQuery(pubkey, type = "general") {
-    return {
-        key: pubkey,
-        run: (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const pointer = getUserStatusPointer(event);
-            if (!pointer)
-                return null;
-            return {
-                ...pointer,
-                event,
-                content: event.content,
-            };
-        })),
-    };
+    return (events) => events.replaceable(kinds.UserStatuses, pubkey, type).pipe(map((event) => {
+        if (!event)
+            return undefined;
+        const pointer = getUserStatusPointer(event);
+        if (!pointer)
+            return null;
+        return {
+            ...pointer,
+            event,
+            content: event.content,
+        };
+    }));
 }
 /** Creates a Query that returns a directory of parsed {@link UserStatus} for a pubkey */
 export function UserStatusesQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
-            return events.reduce((dir, event) => {
-                try {
-                    const d = getReplaceableIdentifier(event);
-                    return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
-                }
-                catch (error) {
-                    return dir;
-                }
-            }, {});
-        })),
-    };
+    return (events) => events.timeline([{ kinds: [kinds.UserStatuses], authors: [pubkey] }]).pipe(map((events) => {
+        return events.reduce((dir, event) => {
+            try {
+                const d = getReplaceableIdentifier(event);
+                return { ...dir, [d]: { event, ...getUserStatusPointer(event), content: event.content } };
+            }
+            catch (error) {
+                return dir;
+            }
+        }, {});
+    }));
 }

package/dist/queries/zaps.js

@@ -4,18 +4,15 @@ import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/po
 import { isValidZap } from "../helpers/zap.js";
 /** A query that gets all zap events for an event */
 export function EventZapsQuery(id) {
-    return {
-        key: JSON.stringify(id),
-        run: (events) => {
-            if (isAddressPointer(id)) {
-                return events
-                    .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
-                    .pipe(map((events) => events.filter(isValidZap)));
-            }
-            else {
-                id = typeof id === "string" ? id : id.id;
-                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
-            }
-        },
+    return (events) => {
+        if (isAddressPointer(id)) {
+            return events
+                .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
+                .pipe(map((events) => events.filter(isValidZap)));
+        }
+        else {
+            id = typeof id === "string" ? id : id.id;
+            return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
+        }
     };
 }

package/dist/query-store/query-store.d.ts

@@ -3,13 +3,10 @@ import { Filter, NostrEvent } from "nostr-tools";
 import type { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { IEventStore } from "../event-store/interface.js";
 import * as Queries from "../queries/index.js";
-export type Query<T extends unknown> = {
-    /** A unique key for this query. this is used to detect duplicate queries */
-    key: string;
-    /** The meat of the query, this should return an Observables that subscribes to the eventStore in some way */
-    run: (events: IEventStore, store: QueryStore) => Observable<T>;
+export type Query<T extends unknown> = (events: IEventStore, store: QueryStore) => Observable<T>;
+export type QueryConstructor<T extends unknown, Args extends Array<any>> = ((...args: Args) => Query<T>) & {
+    getKey?: (...args: Args) => string;
 };
-export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
 export declare class QueryStore {
     static Queries: typeof Queries;
     store: IEventStore;
@@ -38,6 +35,10 @@ export declare class QueryStore {
     timeline(filters: Filter | Filter[], keepOldVersions?: boolean): Observable<import("nostr-tools").Event[] | undefined>;
     /** Creates a ProfileQuery */
     profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Creates a ContactsQuery */
+    contacts(pubkey: string): Observable<import("nostr-tools/nip19").ProfilePointer[] | undefined>;
+    /** Creates a MuteQuery */
+    mutes(pubkey: string): Observable<import("../helpers/mutes.js").Mutes | undefined>;
     /** Creates a ReactionsQuery */
     reactions(event: NostrEvent): Observable<import("nostr-tools").Event[] | undefined>;
     /** Creates a MailboxesQuery */