applesauce-core 3.1.0 → 4.1.0

package/dist/event-store/interface.d.ts

@@ -1,28 +1,44 @@
 import { Filter, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { Observable } from "rxjs";
-import { LRU } from "../helpers/lru.js";
-import { Mutes } from "../helpers/mutes.js";
+import { AddressPointerWithoutD } from "../helpers/pointers.js";
 import { ProfileContent } from "../helpers/profile.js";
+import { Mutes } from "../helpers/mutes.js";
 import { Thread } from "../models/thread.js";
-import { AddressPointerWithoutD } from "../helpers/pointers.js";
 /** The read interface for an event store */
 export interface IEventStoreRead {
     /** Check if the event store has an event with id */
     hasEvent(id: string): boolean;
-    /** Check if the event store has a replaceable event */
-    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     /** Get an event by id */
     getEvent(id: string): NostrEvent | undefined;
+    /** Check if the event store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): boolean;
     /** Get a replaceable event */
     getReplaceable(kind: number, pubkey: string, identifier?: string): NostrEvent | undefined;
     /** Get the history of a replaceable event */
     getReplaceableHistory(kind: number, pubkey: string, identifier?: string): NostrEvent[] | undefined;
     /** Get all events that match the filters */
-    getByFilters(filters: Filter | Filter[]): Set<NostrEvent>;
+    getByFilters(filters: Filter | Filter[]): NostrEvent[];
     /** Get a timeline of events that match the filters */
     getTimeline(filters: Filter | Filter[]): NostrEvent[];
 }
+/** The async read interface for an event store */
+export interface IAsyncEventStoreRead {
+    /** Check if the event store has an event with id */
+    hasEvent(id: string): Promise<boolean>;
+    /** Get an event by id */
+    getEvent(id: string): Promise<NostrEvent | undefined>;
+    /** Check if the event store has a replaceable event */
+    hasReplaceable(kind: number, pubkey: string, identifier?: string): Promise<boolean>;
+    /** Get a replaceable event */
+    getReplaceable(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent | undefined>;
+    /** Get the history of a replaceable event */
+    getReplaceableHistory(kind: number, pubkey: string, identifier?: string): Promise<NostrEvent[] | undefined>;
+    /** Get all events that match the filters */
+    getByFilters(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+    /** Get a timeline of events that match the filters */
+    getTimeline(filters: Filter | Filter[]): Promise<NostrEvent[]>;
+}
 /** The stream interface for an event store */
 export interface IEventStoreStreams {
     /** A stream of new events added to the store */
@@ -41,8 +57,19 @@ export interface IEventStoreActions {
     /** Notify the store that an event has updated */
     update(event: NostrEvent): void;
 }
+/** The async actions for an event store */
+export interface IAsyncEventStoreActions {
+    /** Add an event to the store */
+    add(event: NostrEvent): Promise<NostrEvent | null>;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Notify the store that an event has updated */
+    update(event: NostrEvent): Promise<void>;
+}
 /** The claim interface for an event store */
 export interface IEventClaims {
+    /** Tell the store that this event was used */
+    touch(event: NostrEvent): void;
     /** Sets the claim on the event and touches it */
     claim(event: NostrEvent, claim: any): void;
     /** Checks if an event is claimed by anything */
@@ -51,59 +78,109 @@ export interface IEventClaims {
     removeClaim(event: NostrEvent, claim: any): void;
     /** Removes all claims on an event */
     clearClaim(event: NostrEvent): void;
+    /** Returns a generator of unclaimed events in order of least used */
+    unclaimed(): Generator<NostrEvent>;
 }
 /** An event store that can be subscribed to */
-export interface IEventStoreSubscriptions {
-    /** Susbscribe to an event by id */
+export interface IEventSubscriptions {
+    /** Subscribe to an event by id */
     event(id: string | EventPointer): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event by pointer */
     replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
+    /** Subscribe to a replaceable event with legacy arguments */
+    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
     /** Subscribe to an addressable event by pointer */
     addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
     /** Subscribe to a batch of events that match the filters */
-    filter(filters: Filter | Filter[]): Observable<NostrEvent[]>;
+    filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
+    /** Subscribe to a sorted timeline of events that match the filters */
+    timeline(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent[]>;
+}
+/** @deprecated use {@link IEventSubscriptions} instead */
+export interface IEventStoreSubscriptions extends IEventSubscriptions {
 }
 /** Methods for creating common models */
-export interface IEventStoreModels {
-    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args>, ...args: Args): Observable<T>;
-    event(id: string): Observable<NostrEvent | undefined>;
-    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    addressable(pointer: AddressPointer): Observable<NostrEvent | undefined>;
-    timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
+export interface IEventModelMixin<TStore extends IEventStore | IAsyncEventStore> {
+    model<T extends unknown, Args extends Array<any>>(constructor: ModelConstructor<T, Args, TStore>, ...args: Args): Observable<T>;
+    /** @deprecated use multiple {@link EventModel} instead */
     events(ids: string[]): Observable<Record<string, NostrEvent | undefined>>;
+    /** @deprecated use multiple {@link ReplaceableModel} instead */
     replaceableSet(pointers: (AddressPointer | AddressPointerWithoutD)[]): Observable<Record<string, NostrEvent | undefined>>;
 }
-/** A computed view of an event set or event store */
-export type Model<T extends unknown> = (events: IEventStore) => Observable<T>;
-/** A constructor for a {@link Model} */
-export type ModelConstructor<T extends unknown, Args extends Array<any>> = ((...args: Args) => Model<T>) & {
-    getKey?: (...args: Args) => string;
-};
-/** The base interface for a set of events */
-export interface IEventSet extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventClaims {
-    events: LRU<NostrEvent>;
-}
-export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventStoreModels, IEventClaims {
-    /** Enable this to keep old versions of replaceable events */
-    keepOldVersions: boolean;
-    /** Enable this to keep expired events */
-    keepExpired: boolean;
-    filters(filters: Filter | Filter[]): Observable<NostrEvent>;
-    updated(id: string | NostrEvent): Observable<NostrEvent>;
-    removed(id: string): Observable<never>;
-    replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
-    replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+/** Methods for creating helpful models */
+export interface IEventHelpfulSubscriptions {
+    /** Subscribe to a users profile */
     profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    /** Subscribe to a users contacts */
     contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
+    /** Subscribe to a users mutes */
     mutes(user: string | ProfilePointer): Observable<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<NostrEvent[]>;
+    /** Subscribe to a thread */
     thread(root: string | EventPointer | AddressPointer): Observable<Thread>;
+    /** Subscribe to a event's comments */
+    comments(event: NostrEvent): Observable<NostrEvent[]>;
+}
+/** @deprecated use {@link IEventModelMixin} instead */
+export interface IEventStoreModels extends IEventModelMixin<IEventStore> {
+}
+/** The interface that is passed to the model for creating subscriptions */
+export type ModelEventStore<TStore extends IEventStore | IAsyncEventStore> = IEventStoreStreams & IEventSubscriptions & IEventModelMixin<TStore> & IEventFallbackLoaders & TStore;
+/** A computed view of an event set or event store */
+export type Model<T extends unknown, TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> = (events: ModelEventStore<TStore>) => Observable<T>;
+/** A constructor for a {@link Model} */
+export type ModelConstructor<T extends unknown, Args extends Array<any>, TStore extends IEventStore | IAsyncEventStore = IEventStore> = ((...args: Args) => Model<T, TStore>) & {
+    getKey?: (...args: Args) => string;
+};
+/** The base interface for a database of events */
+export interface IEventDatabase extends IEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): boolean;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): number;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
+}
+/** The async base interface for a set of events */
+export interface IAsyncEventDatabase extends IAsyncEventStoreRead {
+    /** Add an event to the database */
+    add(event: NostrEvent): Promise<NostrEvent>;
+    /** Remove an event from the database */
+    remove(event: string | NostrEvent): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): Promise<number>;
+    /** Notifies the database that an event has updated */
+    update?: (event: NostrEvent) => void;
+}
+/** The base interface for the in-memory database of events */
+export interface IEventMemory extends IEventStoreRead, IEventClaims {
+    /** Add an event to the store */
+    add(event: NostrEvent): NostrEvent;
+    /** Remove an event from the store */
+    remove(event: string | NostrEvent): boolean;
+}
+/** A set of methods that an event store will use to load single events it does not have */
+export interface IEventFallbackLoaders {
+    /** A method that will be called when an event isn't found in the store */
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** A method that will be called when a replaceable event isn't found in the store */
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    /** A method that will be called when an addressable event isn't found in the store */
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+}
+/** The async event store interface */
+export interface IAsyncEventStore extends IAsyncEventStoreRead, IEventStoreStreams, IEventSubscriptions, IAsyncEventStoreActions, IEventModelMixin<IAsyncEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {
+}
+/** The sync event store interface */
+export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventSubscriptions, IEventStoreActions, IEventModelMixin<IEventStore>, IEventHelpfulSubscriptions, IEventClaims, IEventFallbackLoaders {
 }

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;