applesauce-core 3.0.1 → 4.0.0

package/dist/event-store/model-mixin.d.ts

@@ -0,0 +1,59 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { Observable } from "rxjs";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
+import { IAsyncEventStore, IEventStore, ModelConstructor } from "./interface.js";
+/** A mixin that provides model functionality for both sync and async event stores */
+export declare function EventStoreModelMixin<T extends new (...args: any[]) => any, TStore extends IEventStore | IAsyncEventStore>(Base: T): {
+    new (...args: any[]): {
+        [x: string]: any;
+        /** A directory of all active models */
+        models: Map<ModelConstructor<any, any[], TStore>, Map<string, Observable<any>>>;
+        /** How long a model should be kept "warm" while nothing is subscribed to it */
+        modelKeepWarm: number;
+        /** Get or create a model on the event store */
+        model<T_1 extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T_1, Args, TStore>, ...args: Args): Observable<T_1>;
+        /**
+         * Creates an observable that streams all events that match the filter
+         * @param filters
+         * @param [onlyNew=false] Only subscribe to new events
+         */
+        filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+        /** Creates a {@link EventModel} */
+        event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
+        /** Creates a {@link ReplaceableModel} */
+        replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+        replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
+        /** Subscribe to an addressable event by pointer */
+        addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
+        /** Creates a {@link TimelineModel} */
+        timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+        /** Subscribe to a users profile */
+        profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+        /** Subscribe to a users contacts */
+        contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+        /** Subscribe to a users mutes */
+        mutes(user: string | ProfilePointer): Observable<import("../helpers/mutes.js").Mutes | undefined>;
+        /** Subscribe to a users NIP-65 mailboxes */
+        mailboxes(user: string | ProfilePointer): Observable<{
+            inboxes: string[];
+            outboxes: string[];
+        } | undefined>;
+        /** Subscribe to a users blossom servers */
+        blossomServers(user: string | ProfilePointer): Observable<URL[]>;
+        /** Subscribe to an event's reactions */
+        reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        /** Subscribe to a thread */
+        thread(root: string | EventPointer | AddressPointer): Observable<import("../models/thread.js").Thread>;
+        /** Subscribe to a event's comments */
+        comments(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+        /** @deprecated use multiple {@link EventModel} instead */
+        events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+        /** @deprecated use multiple {@link ReplaceableModel} instead */
+        replaceableSet(pointers: {
+            kind: number;
+            pubkey: string;
+            identifier?: string;
+        }[]): Observable<Record<string, NostrEvent | undefined>>;
+    };
+} & T;

package/dist/event-store/model-mixin.js

@@ -0,0 +1,147 @@
+import hash_sum from "hash-sum";
+import { EMPTY, ReplaySubject, filter, finalize, from, merge, mergeMap, share, timer } from "rxjs";
+import { matchFilters } from "../helpers/filter.js";
+// Model imports
+import { UserBlossomServersModel } from "../models/blossom.js";
+import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
+import { ContactsModel } from "../models/contacts.js";
+import { CommentsModel, ThreadModel } from "../models/index.js";
+import { MailboxesModel } from "../models/mailboxes.js";
+import { MuteModel } from "../models/mutes.js";
+import { ProfileModel } from "../models/profile.js";
+import { ReactionsModel } from "../models/reactions.js";
+/** A mixin that provides model functionality for both sync and async event stores */
+export function EventStoreModelMixin(Base) {
+    return class extends Base {
+        /** A directory of all active models */
+        models = new Map();
+        /** How long a model should be kept "warm" while nothing is subscribed to it */
+        modelKeepWarm = 60_000;
+        /** Get or create a model on the event store */
+        model(constructor, ...args) {
+            let models = this.models.get(constructor);
+            if (!models) {
+                models = new Map();
+                this.models.set(constructor, models);
+            }
+            const key = constructor.getKey ? constructor.getKey(...args) : hash_sum(args);
+            let model = models.get(key);
+            // Create the model if it does not exist
+            if (!model) {
+                const cleanup = () => {
+                    // Remove the model from the cache if its the same one
+                    if (models.get(key) === model)
+                        models.delete(key);
+                };
+                model = constructor(...args)(this).pipe(
+                // remove the model when its unsubscribed
+                finalize(cleanup), 
+                // only subscribe to models once for all subscriptions
+                share({
+                    connector: () => new ReplaySubject(1),
+                    resetOnComplete: () => timer(this.modelKeepWarm),
+                    resetOnRefCountZero: () => timer(this.modelKeepWarm),
+                }));
+                // Add the model to the cache
+                models.set(key, model);
+            }
+            return model;
+        }
+        /**
+         * Creates an observable that streams all events that match the filter
+         * @param filters
+         * @param [onlyNew=false] Only subscribe to new events
+         */
+        filters(filters, onlyNew = false) {
+            filters = Array.isArray(filters) ? filters : [filters];
+            const getByFiltersResult = this.getByFilters(filters);
+            // Create the existing events observable
+            const existingEvents$ = onlyNew
+                ? EMPTY
+                : // Check if result is a Promise (async) or direct Set (sync)
+                    getByFiltersResult && typeof getByFiltersResult.then === "function"
+                        ? from(getByFiltersResult).pipe(mergeMap((events) => from(Array.from(events))))
+                        : from(Array.from(getByFiltersResult));
+            // Create the new events observable
+            const newEvents$ = this.insert$.pipe(filter((e) => matchFilters(filters, e)));
+            return merge(existingEvents$, newEvents$);
+        }
+        // Helper methods for creating models
+        /** Creates a {@link EventModel} */
+        event(pointer) {
+            if (typeof pointer === "string")
+                pointer = { id: pointer };
+            return this.model(EventModel, pointer);
+        }
+        replaceable(...args) {
+            let pointer;
+            // Parse arguments
+            if (args.length === 1) {
+                pointer = args[0];
+            }
+            else if (args.length === 3 || args.length === 2) {
+                let [kind, pubkey, identifier] = args;
+                pointer = { kind, pubkey, identifier };
+            }
+            if (!pointer)
+                throw new Error("Invalid arguments, expected address pointer or kind, pubkey, identifier");
+            return this.model(ReplaceableModel, pointer);
+        }
+        /** Subscribe to an addressable event by pointer */
+        addressable(pointer) {
+            return this.model(ReplaceableModel, pointer);
+        }
+        /** Creates a {@link TimelineModel} */
+        timeline(filters, includeOldVersion = false) {
+            return this.model(TimelineModel, filters, includeOldVersion);
+        }
+        /** Subscribe to a users profile */
+        profile(user) {
+            return this.model(ProfileModel, user);
+        }
+        /** Subscribe to a users contacts */
+        contacts(user) {
+            if (typeof user === "string")
+                user = { pubkey: user };
+            return this.model(ContactsModel, user);
+        }
+        /** Subscribe to a users mutes */
+        mutes(user) {
+            if (typeof user === "string")
+                user = { pubkey: user };
+            return this.model(MuteModel, user);
+        }
+        /** Subscribe to a users NIP-65 mailboxes */
+        mailboxes(user) {
+            if (typeof user === "string")
+                user = { pubkey: user };
+            return this.model(MailboxesModel, user);
+        }
+        /** Subscribe to a users blossom servers */
+        blossomServers(user) {
+            if (typeof user === "string")
+                user = { pubkey: user };
+            return this.model(UserBlossomServersModel, user);
+        }
+        /** Subscribe to an event's reactions */
+        reactions(event) {
+            return this.model(ReactionsModel, event);
+        }
+        /** Subscribe to a thread */
+        thread(root) {
+            return this.model(ThreadModel, root);
+        }
+        /** Subscribe to a event's comments */
+        comments(event) {
+            return this.model(CommentsModel, event);
+        }
+        /** @deprecated use multiple {@link EventModel} instead */
+        events(ids) {
+            return this.model(EventsModel, ids);
+        }
+        /** @deprecated use multiple {@link ReplaceableModel} instead */
+        replaceableSet(pointers) {
+            return this.model(ReplaceableSetModel, pointers);
+        }
+    };
+}

package/dist/helpers/app-data.d.ts

@@ -0,0 +1,39 @@
+import { NostrEvent } from "nostr-tools";
+import { EncryptionMethod } from "./encrypted-content.js";
+import { HiddenContentSigner } from "./hidden-content.js";
+export declare const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
+export declare const AppDataContentSymbol: unique symbol;
+/** Checks if an event has application data */
+export declare function hasAppData<T extends {
+    kind: number;
+    content: string;
+}>(event: T): boolean;
+/** Checks if the application data is encrypted */
+export declare function getAppDataEncryption<T extends {
+    kind: number;
+    content: string;
+}>(event: T): EncryptionMethod | undefined;
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export declare function isAppDataUnlocked<T extends {
+    kind: number;
+}>(event: T): boolean;
+/** Returns the parsed application data for an event if it's unlocked */
+export declare function getAppDataContent<R extends unknown = unknown, T extends {
+    kind: number;
+    content: string;
+} = NostrEvent>(event: T): R | undefined;
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export declare function unlockAppData<R extends unknown = unknown, T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+} = NostrEvent>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<R>;
+/** Removes the unencrypted application data cache on an event */
+export declare function lockAppData<T extends object>(event: T): void;

package/dist/helpers/app-data.js

@@ -0,0 +1,68 @@
+import { isNIP04Encrypted } from "./encryption.js";
+import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
+import { safeParse } from "./json.js";
+// NIP-78 Application Data event kind
+export const APP_DATA_KIND = 30078;
+/** A symbol used to cache the application data content */
+export const AppDataContentSymbol = Symbol.for("app-data-content");
+// Set the encryption method for app data events (default to nip44)
+setHiddenContentEncryptionMethod(APP_DATA_KIND, "nip44");
+/** Checks if an event has application data */
+export function hasAppData(event) {
+    return event.kind === APP_DATA_KIND && event.content.length > 0;
+}
+/** Checks if the application data is encrypted */
+export function getAppDataEncryption(event) {
+    // If content is empty, it can't be encrypted
+    if (event.content.length === 0)
+        return undefined;
+    // Try to parse as JSON - if it fails, it's likely encrypted
+    const parsed = safeParse(event.content);
+    if (parsed !== undefined)
+        return undefined;
+    return isNIP04Encrypted(event.content) ? "nip04" : "nip44";
+}
+/** Checks if the application data is locked (encrypted and not decrypted) */
+export function isAppDataUnlocked(event) {
+    return isHiddenContentUnlocked(event);
+}
+/** Returns the parsed application data for an event if it's unlocked */
+export function getAppDataContent(event) {
+    const cached = Reflect.get(event, AppDataContentSymbol);
+    if (cached)
+        return cached;
+    // If content is empty, return undefined
+    if (event.content.length === 0)
+        return undefined;
+    let data = getAppDataEncryption(event) ? undefined : safeParse(event.content);
+    if (!data) {
+        const decrypted = getHiddenContent(event);
+        if (decrypted)
+            data = safeParse(decrypted);
+    }
+    if (!data)
+        return undefined;
+    Reflect.set(event, AppDataContentSymbol, data);
+    return data;
+}
+/**
+ * Unlocks the encrypted application data in the event
+ * @param event The event with encrypted content to decrypt
+ * @param signer A signer to use to decrypt the content
+ * @param override The encryption method to use instead of the default
+ * @returns The decrypted application data
+ */
+export async function unlockAppData(event, signer, override) {
+    if (!getAppDataEncryption(event))
+        return getAppDataContent(event);
+    const method = override ?? getAppDataEncryption(event);
+    const plaintext = await unlockHiddenContent(event, signer, method);
+    const parsed = safeParse(plaintext);
+    if (parsed === undefined)
+        throw new Error("Failed to parse decrypted application data as JSON");
+    return parsed;
+}
+/** Removes the unencrypted application data cache on an event */
+export function lockAppData(event) {
+    lockHiddenContent(event);
+}

package/dist/helpers/bookmarks.d.ts

@@ -1,7 +1,12 @@
 import { NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { HiddenContentSigner } from "./index.js";
 export declare const BookmarkPublicSymbol: unique symbol;
 export declare const BookmarkHiddenSymbol: unique symbol;
+/** Type for unlocked bookmarks events */
+export type UnlockedBookmarks = {
+    [BookmarkHiddenSymbol]: Bookmarks;
+};
 export type Bookmarks = {
     notes: EventPointer[];
     articles: AddressPointer[];
@@ -16,5 +21,10 @@ export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]):
 export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
 /** Returns the public bookmarks of the event */
 export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Checks if the hidden bookmarks are unlocked */
+export declare function isHiddenBookmarksUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedBookmarks;
 /** Returns the bookmarks of the event if its unlocked */
-export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;
+export declare function getHiddenBookmarks<T extends NostrEvent & UnlockedBookmarks>(bookmark: T): Bookmarks;
+export declare function getHiddenBookmarks<T extends NostrEvent>(bookmark: T): Bookmarks | undefined;
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export declare function unlockHiddenBookmarks(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<Bookmarks>;

package/dist/helpers/bookmarks.js

@@ -1,6 +1,6 @@
 import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
+import { getHiddenTags, isHiddenTagsUnlocked, notifyEventUpdate, unlockHiddenTags, } from "./index.js";
 import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } from "./pointers.js";
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
@@ -63,9 +63,34 @@ export function getBookmarks(bookmark) {
 export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
-/** Returns the bookmarks of the event if its unlocked */
+/** Checks if the hidden bookmarks are unlocked */
+export function isHiddenBookmarksUnlocked(bookmark) {
+    return isHiddenTagsUnlocked(bookmark) && Reflect.has(bookmark, BookmarkHiddenSymbol);
+}
 export function getHiddenBookmarks(bookmark) {
-    if (isHiddenTagsLocked(bookmark))
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    //get hidden tags
+    const tags = getHiddenTags(bookmark);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => parseBookmarkTags(getHiddenTags(bookmark)));
+    // parse bookmarks
+    const bookmarks = parseBookmarkTags(tags);
+    // set cached value
+    Reflect.set(bookmark, BookmarkHiddenSymbol, bookmarks);
+    return bookmarks;
+}
+/** Unlocks the hidden bookmarks on a bookmarks event */
+export async function unlockHiddenBookmarks(bookmark, signer) {
+    if (isHiddenBookmarksUnlocked(bookmark))
+        return bookmark[BookmarkHiddenSymbol];
+    // unlock hidden tags
+    await unlockHiddenTags(bookmark, signer);
+    // get hidden bookmarks
+    const bookmarks = getHiddenBookmarks(bookmark);
+    if (!bookmarks)
+        throw new Error("Failed to unlock hidden bookmarks");
+    // notify event store
+    notifyEventUpdate(bookmark);
+    return bookmarks;
 }

package/dist/helpers/comment.d.ts

@@ -1,6 +1,9 @@
 import { NostrEvent } from "nostr-tools";
 import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
+import { KnownEvent } from "./index.js";
 export declare const COMMENT_KIND = 1111;
+/** Type for validated comment events */
+export type CommentEvent = KnownEvent<typeof COMMENT_KIND>;
 export type CommentEventPointer = {
     type: "event";
     id: string;
@@ -22,30 +25,20 @@ export type CommentExternalPointer<T extends keyof ExternalIdentifiers> = Extern
 export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer<keyof ExternalIdentifiers>;
 export declare const CommentRootPointerSymbol: unique symbol;
 export declare const CommentReplyPointerSymbol: unique symbol;
-/**
- * Gets the EventPointer from an array of tags
- * @throws
- */
+/** Gets the EventPointer from an array of tags */
 export declare function getCommentEventPointer(tags: string[][], root?: boolean): CommentEventPointer | null;
-/**
- * Gets the AddressPointer from an array of tags
- * @throws
- */
+/** Gets the AddressPointer from an array of tags */
 export declare function getCommentAddressPointer(tags: string[][], root?: boolean): CommentAddressPointer | null;
-/**
- * Gets the ExternalPointer from an array of tags
- * @throws
- */
+/** Gets the ExternalPointer from an array of tags */
 export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer<keyof ExternalIdentifiers> | null;
-/**
- * Returns the root pointer for a comment
- * @throws
- */
+/** Returns the root pointer for a comment */
+export declare function getCommentRootPointer(comment: CommentEvent): CommentPointer;
 export declare function getCommentRootPointer(comment: NostrEvent): CommentPointer | null;
-/**
- * Returns the reply pointer for a comment
- * @throws
- */
+/** Returns the reply pointer for a comment */
 export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
+/** Checks if a pointer is a {@link CommentEventPointer} */
 export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
+/** Checks if a pointer is a {@link CommentAddressPointer} */
 export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
+/** Checks if a comment event is valid */
+export declare function isValidComment(comment: NostrEvent): comment is CommentEvent;

package/dist/helpers/comment.js

@@ -5,16 +5,14 @@ import { isSafeRelayURL } from "./relays.js";
 export const COMMENT_KIND = 1111;
 export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
 export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
-/**
- * Gets the EventPointer from an array of tags
- * @throws
- */
+/** Gets the EventPointer from an array of tags */
 export function getCommentEventPointer(tags, root = false) {
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (eTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
         const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
         const pointer = {
@@ -28,17 +26,15 @@ export function getCommentEventPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the AddressPointer from an array of tags
- * @throws
- */
+/** Gets the AddressPointer from an array of tags */
 export function getCommentAddressPointer(tags, root = false) {
     const aTag = tags.find((t) => t[0] === (root ? "A" : "a"));
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (aTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
             type: "address",
@@ -52,16 +48,10 @@ export function getCommentAddressPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the ExternalPointer from an array of tags
- * @throws
- */
+/** Gets the ExternalPointer from an array of tags */
 export function getCommentExternalPointer(tags, root = false) {
     const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
-    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (iTag) {
-        if (!kind)
-            throw new Error("Missing kind tag");
         return {
             type: "external",
             ...getExternalPointerFromTag(iTag),
@@ -69,13 +59,9 @@ export function getCommentExternalPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Returns the root pointer for a comment
- * @throws
- */
 export function getCommentRootPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, true);
@@ -90,13 +76,10 @@ export function getCommentRootPointer(comment) {
         return null;
     });
 }
-/**
- * Returns the reply pointer for a comment
- * @throws
- */
+/** Returns the reply pointer for a comment */
 export function getCommentReplyPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, false);
@@ -111,15 +94,21 @@ export function getCommentReplyPointer(comment) {
         return null;
     });
 }
+/** Checks if a pointer is a {@link CommentEventPointer} */
 export function isCommentEventPointer(pointer) {
     return (Reflect.has(pointer, "id") &&
         Reflect.has(pointer, "kind") &&
         !Reflect.has(pointer, "identifier") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a pointer is a {@link CommentAddressPointer} */
 export function isCommentAddressPointer(pointer) {
     return (Reflect.has(pointer, "identifier") &&
         Reflect.has(pointer, "pubkey") &&
         Reflect.has(pointer, "kind") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a comment event is valid */
+export function isValidComment(comment) {
+    return (comment.kind === COMMENT_KIND && getCommentRootPointer(comment) !== null && getCommentReplyPointer(comment) !== null);
+}

package/dist/helpers/contacts.d.ts

@@ -1,14 +1,23 @@
 import { NostrEvent } from "nostr-tools";
 import { ProfilePointer } from "nostr-tools/nip19";
+import { HiddenContentSigner } from "./hidden-content.js";
 export declare const ContactsRelaysSymbol: unique symbol;
 export declare const PublicContactsSymbol: unique symbol;
 export declare const HiddenContactsSymbol: unique symbol;
-export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;
+/** Type for contact events with unlocked hidden tags */
+export type UnlockedContacts = {
+    [HiddenContactsSymbol]: ProfilePointer[];
+};
+export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "inbox" | "outbox" | "all"> | null;
 /** Merges any number of contact lists into a single list */
 export declare function mergeContacts(...pointers: (ProfilePointer | undefined | (ProfilePointer | undefined)[])[]): ProfilePointer[];
 /** Returns all public and hidden contacts from a contacts list event */
 export declare function getContacts(event: NostrEvent): ProfilePointer[];
 /** Returns only the public contacts from a contacts list event */
 export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
+/** Checks if the hidden contacts are unlocked */
+export declare function isHiddenContactsUnlocked<T extends NostrEvent>(event: T): event is T & UnlockedContacts;
 /** Returns only the hidden contacts from a contacts list event */
 export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;
+/** Unlocks the hidden contacts */
+export declare function unlockHiddenContacts(event: NostrEvent, signer: HiddenContentSigner): Promise<ProfilePointer[]>;

package/dist/helpers/contacts.js

@@ -2,7 +2,8 @@ import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
 import { isPTag, processTags } from "./tags.js";
 import { getProfilePointerFromPTag } from "./pointers.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "./hidden-tags.js";
+import { notifyEventUpdate } from "./index.js";
 export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
 export const PublicContactsSymbol = Symbol.for("public-contacts");
 export const HiddenContactsSymbol = Symbol.for("hidden-contacts");
@@ -51,9 +52,35 @@ export function getContacts(event) {
 export function getPublicContacts(event) {
     return getOrComputeCachedValue(event, PublicContactsSymbol, () => processTags(event.tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
 }
+/** Checks if the hidden contacts are unlocked */
+export function isHiddenContactsUnlocked(event) {
+    return isHiddenTagsUnlocked(event) && Reflect.has(event, HiddenContactsSymbol);
+}
 /** Returns only the hidden contacts from a contacts list event */
 export function getHiddenContacts(event) {
-    if (isHiddenTagsLocked(event))
+    if (isHiddenContactsUnlocked(event))
+        return event[HiddenContactsSymbol];
+    // Get hidden tags
+    const tags = getHiddenTags(event);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+    // Parse tags
+    const contacts = processTags(tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+    // Set cache and notify event store
+    Reflect.set(event, HiddenContactsSymbol, contacts);
+    return contacts;
+}
+/** Unlocks the hidden contacts */
+export async function unlockHiddenContacts(event, signer) {
+    if (isHiddenContactsUnlocked(event))
+        return event[HiddenContactsSymbol];
+    // Unlock hidden tags
+    await unlockHiddenTags(event, signer);
+    // Get hidden contacts
+    const contacts = getHiddenContacts(event);
+    if (!contacts)
+        throw new Error("Failed to unlock hidden contacts");
+    // Set cache and notify event store
+    notifyEventUpdate(event);
+    return contacts;
 }