applesauce-core 1.2.0 → 2.1.0

package/dist/helpers/url.js

@@ -39,6 +39,26 @@ export function isSameURL(a, b) {
         return false;
     }
 }
+/** Adds a protocol to a URL string if its missing one */
+export function ensureProtocol(url, protocol = "https:") {
+    // Check if the URL already has a protocol
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]+:/.test(url))
+        return url;
+    return protocol + "//" + url;
+}
+/** Converts a URL to a WebSocket URL */
+export function ensureWebSocketURL(url) {
+    const p = typeof url === "string" ? new URL(ensureProtocol(url, "wss:")) : new URL(url);
+    if (p.protocol === "http:")
+        p.protocol = "ws:";
+    else if (p.protocol === "https:")
+        p.protocol = "wss:";
+    else
+        p.protocol = "wss:";
+    // return a string if a string was passed in
+    // @ts-expect-error
+    return typeof url === "string" ? p.toString() : p;
+}
 /**
  * Normalizes a string into a relay URL
  * Does not remove the trailing slash

package/dist/helpers/user-status.js

@@ -1,4 +1,5 @@
-import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, } from "applesauce-core/helpers";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
 export const UserStatusPointerSymbol = Symbol.for("user-status-pointer");
 function getStatusPointer(status) {
     const pTag = status.tags.find((t) => t[0] === "p" && t[1]);

package/dist/helpers/wrapped-messages.d.ts

@@ -0,0 +1,23 @@
+import { Rumor } from "./gift-wraps.js";
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - The conversation identifier (pubkey1:pubkey2:pubkey3), or a users pubkey, or a list of participant pubkeys, or a rumor message
+ * @returns The participants of the conversation
+ */
+export declare function getConversationParticipants(participants: string | string[] | Rumor): string[];
+/**
+ * Creates a conversation identifier from a users pubkey and alist of correspondants
+ * @param participants - The participants of the conversation
+ * @returns The conversation identifier
+ */
+export declare function createConversationIdentifier(participants: string[]): string;
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The message to get the conversation identifier for
+ * @returns The conversation identifier
+ */
+export declare function getConversationIdentifierFromMessage(message: Rumor): string;
+/** Returns the subject of a warpped direct message */
+export declare function getWrappedMessageSubject(message: Rumor): string | undefined;
+/** Returns the parent id of a wrapped direct message */
+export declare function getWrappedMessageParent(message: Rumor): string | undefined;

package/dist/helpers/wrapped-messages.js

@@ -0,0 +1,38 @@
+import { getTagValue } from "./index.js";
+import { isPTag } from "./tags.js";
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - The conversation identifier (pubkey1:pubkey2:pubkey3), or a users pubkey, or a list of participant pubkeys, or a rumor message
+ * @returns The participants of the conversation
+ */
+export function getConversationParticipants(participants) {
+    return Array.from(new Set(typeof participants === "string"
+        ? participants.split(":")
+        : Array.isArray(participants)
+            ? participants
+            : [participants.pubkey, ...participants.tags.filter(isPTag).map((t) => t[1])]));
+}
+/**
+ * Creates a conversation identifier from a users pubkey and alist of correspondants
+ * @param participants - The participants of the conversation
+ * @returns The conversation identifier
+ */
+export function createConversationIdentifier(participants) {
+    return Array.from(new Set(participants)).sort().join(":");
+}
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The message to get the conversation identifier for
+ * @returns The conversation identifier
+ */
+export function getConversationIdentifierFromMessage(message) {
+    return createConversationIdentifier(getConversationParticipants(message));
+}
+/** Returns the subject of a warpped direct message */
+export function getWrappedMessageSubject(message) {
+    return getTagValue(message, "subject");
+}
+/** Returns the parent id of a wrapped direct message */
+export function getWrappedMessageParent(message) {
+    return getTagValue(message, "e");
+}

package/dist/helpers/zap.d.ts

@@ -1,6 +1,9 @@
 import { NostrEvent } from "nostr-tools";
+import { ParsedInvoice } from "./bolt11.js";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export declare const ZapRequestSymbol: unique symbol;
-export declare const ZapFromSymbol: unique symbol;
+export declare const ZapSenderSymbol: unique symbol;
+export declare const ZapReceiverSymbol: unique symbol;
 export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
@@ -12,18 +15,18 @@ export declare function getZapSender(zap: NostrEvent): string;
  */
 export declare function getZapRecipient(zap: NostrEvent): string;
 /** Returns the parsed bolt11 invoice */
-export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+export declare function getZapPayment(zap: NostrEvent): ParsedInvoice | undefined;
 /** Gets the AddressPointer that was zapped */
-export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+export declare function getZapAddressPointer(zap: NostrEvent): AddressPointer | null;
 /** Gets the EventPointer that was zapped */
-export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
+export declare function getZapEventPointer(zap: NostrEvent): EventPointer | null;
 /** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
 /**
  * Returns the zap request event inside the zap receipt
  * @throws
  */
-export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+export declare function getZapRequest(zap: NostrEvent): NostrEvent;
 /**
  * Checks if the zap is valid
  * DOES NOT validate LNURL address

package/dist/helpers/zap.js

@@ -5,23 +5,28 @@ import { isATag, isETag } from "./tags.js";
 import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { parseBolt11 } from "./bolt11.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
-export const ZapFromSymbol = Symbol.for("zap-from");
+export const ZapSenderSymbol = Symbol.for("zap-sender");
+export const ZapReceiverSymbol = Symbol.for("zap-receiver");
 export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
 export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
 export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
 /** Returns the senders pubkey */
 export function getZapSender(zap) {
-    return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+    return getOrComputeCachedValue(zap, ZapSenderSymbol, () => {
+        return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+    });
 }
 /**
  * Gets the receivers pubkey
  * @throws
  */
 export function getZapRecipient(zap) {
-    const recipient = getTagValue(zap, "p");
-    if (!recipient)
-        throw new Error("Missing recipient");
-    return recipient;
+    return getOrComputeCachedValue(zap, ZapReceiverSymbol, () => {
+        const recipient = getTagValue(zap, "p");
+        if (!recipient)
+            throw new Error("Missing recipient");
+        return recipient;
+    });
 }
 /** Returns the parsed bolt11 invoice */
 export function getZapPayment(zap) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./event-store/index.js";
-export * from "./query-store/index.js";
 export * as Helpers from "./helpers/index.js";
-export * as Queries from "./queries/index.js";
+export * as Models from "./models/index.js";
+export * from "./observable/index.js";
 export * from "./logger.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from "./event-store/index.js";
-export * from "./query-store/index.js";
 export * as Helpers from "./helpers/index.js";
-export * as Queries from "./queries/index.js";
+export * as Models from "./models/index.js";
+export * from "./observable/index.js";
 export * from "./logger.js";

package/dist/models/blossom.d.ts

@@ -0,0 +1,3 @@
+import { Model } from "../event-store/interface.js";
+/** A model that returns a users blossom servers */
+export declare function UserBlossomServersModel(pubkey: string): Model<URL[]>;

package/dist/models/blossom.js

@@ -0,0 +1,8 @@
+import { map } from "rxjs/operators";
+import { BLOSSOM_SERVER_LIST_KIND, getBlossomServersFromList } from "../helpers/blossom.js";
+/** A model that returns a users blossom servers */
+export function UserBlossomServersModel(pubkey) {
+    return (store) => store
+        .replaceable(BLOSSOM_SERVER_LIST_KIND, pubkey)
+        .pipe(map((event) => (event ? getBlossomServersFromList(event) : [])));
+}

package/dist/models/bookmarks.d.ts

@@ -0,0 +1,8 @@
+import { Bookmarks } from "../helpers/bookmarks.js";
+import { Model } from "../event-store/interface.js";
+/** A model that returns all the bookmarks of a user */
+export declare function UserBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+/** A model that returns all the public bookmarks of a user */
+export declare function UserPublicBookmarkModel(pubkey: string): Model<Bookmarks | undefined>;
+/** A model that returns all the hidden bookmarks of a user */
+export declare function UserHiddenBookmarkModel(pubkey: string): Model<Bookmarks | null | undefined>;

package/dist/{queries → models}/bookmarks.js

@@ -1,24 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmarks.js";
-import { listenLatestUpdates } from "../observable/index.js";
-/** A query that returns all the bookmarks of a user */
-export function UserBookmarkQuery(pubkey) {
+import { watchEventUpdates } from "../observable/index.js";
+/** A model that returns all the bookmarks of a user */
+export function UserBookmarkModel(pubkey) {
     return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
     // listen for event updates (hidden tags unlocked)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get all bookmarks
     map((event) => event && getBookmarks(event)));
 }
-/** A query that returns all the public bookmarks of a user */
-export function UserPublicBookmarkQuery(pubkey) {
+/** A model that returns all the public bookmarks of a user */
+export function UserPublicBookmarkModel(pubkey) {
     return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
 }
-/** A query that returns all the hidden bookmarks of a user */
-export function UserHiddenBookmarkQuery(pubkey) {
+/** A model that returns all the hidden bookmarks of a user */
+export function UserHiddenBookmarkModel(pubkey) {
     return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
     // listen for event updates (hidden tags unlocked)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get hidden bookmarks
     map((event) => event && (getHiddenBookmarks(event) ?? null)));
 }

package/dist/models/channels.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+import { ChannelMetadataContent } from "../helpers/channels.js";
+/** A model that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenModel(channel: NostrEvent, authors?: string[]): Model<Map<string, string>>;
+/** A model that returns all messages in a channel */
+export declare function ChannelMessagesModel(channel: NostrEvent): Model<NostrEvent[]>;
+/** A model that returns the latest parsed metadata */
+export declare function ChannelMetadataModel(channel: NostrEvent): Model<ChannelMetadataContent | undefined>;
+/** A model that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedModel(channel: NostrEvent, authors?: string[]): Model<Map<string, string>>;

package/dist/{queries → models}/channels.js

@@ -1,9 +1,9 @@
-import { safeParse } from "applesauce-core/helpers/json";
 import { kinds } from "nostr-tools";
 import { map } from "rxjs";
 import { getChannelMetadataContent } from "../helpers/channels.js";
-/** A query that returns a map of hidden messages Map<id, reason> */
-export function ChannelHiddenQuery(channel, authors = []) {
+import { safeParse } from "../helpers/json.js";
+/** A model that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenModel(channel, authors = []) {
     return (events) => {
         const hidden = new Map();
         return events
@@ -18,12 +18,12 @@ export function ChannelHiddenQuery(channel, authors = []) {
         }));
     };
 }
-/** A query that returns all messages in a channel */
-export function ChannelMessagesQuery(channel) {
+/** A model that returns all messages in a channel */
+export function ChannelMessagesModel(channel) {
     return (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]);
 }
-/** A query that returns the latest parsed metadata */
-export function ChannelMetadataQuery(channel) {
+/** A model that returns the latest parsed metadata */
+export function ChannelMetadataModel(channel) {
     return (events) => {
         const filters = [
             { ids: [channel.id] },
@@ -43,8 +43,8 @@ export function ChannelMetadataQuery(channel) {
         }));
     };
 }
-/** A query that returns a map of muted users Map<pubkey, reason> */
-export function ChannelMutedQuery(channel, authors = []) {
+/** A model that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedModel(channel, authors = []) {
     return (events) => {
         const muted = new Map();
         return events

package/dist/models/comments.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+/** A model that returns all NIP-22 comment replies for the event */
+export declare function CommentsModel(parent: NostrEvent): Model<NostrEvent[]>;

package/dist/models/comments.js

@@ -0,0 +1,11 @@
+import { isAddressableKind } from "nostr-tools/kinds";
+import { COMMENT_KIND, getReplaceableAddress } from "../helpers/index.js";
+/** A model that returns all NIP-22 comment replies for the event */
+export function CommentsModel(parent) {
+    return (events) => {
+        const filters = [{ kinds: [COMMENT_KIND], "#e": [parent.id] }];
+        if (isAddressableKind(parent.kind))
+            filters.push({ kinds: [COMMENT_KIND], "#a": [getReplaceableAddress(parent)] });
+        return events.timeline(filters);
+    };
+}

package/dist/models/common.d.ts

@@ -0,0 +1,16 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+/** A model that returns a single event or undefined when its removed */
+export declare function EventModel(id: string): Model<NostrEvent | undefined>;
+/** A model that returns the latest version of a replaceable event or undefined if its removed */
+export declare function ReplaceableModel(kind: number, pubkey: string, d?: string): Model<NostrEvent | undefined>;
+/** A model that returns an array of sorted events matching the filters */
+export declare function TimelineModel(filters: Filter | Filter[], includeOldVersion?: boolean): Model<NostrEvent[]>;
+/** A model that returns a multiple events in a map */
+export declare function EventsModel(ids: string[]): Model<Record<string, NostrEvent>>;
+/** A model that returns a directory of events by their UID */
+export declare function ReplaceableSetModel(pointers: {
+    kind: number;
+    pubkey: string;
+    identifier?: string;
+}[]): Model<Record<string, NostrEvent>>;

package/dist/models/common.js

@@ -0,0 +1,176 @@
+import { defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { createReplaceableAddress, getEventUID, getReplaceableIdentifier, isReplaceable, matchFilters, } from "../helpers/index.js";
+import { claimEvents } from "../observable/claim-events.js";
+import { claimLatest } from "../observable/claim-latest.js";
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { withImmediateValueOrDefault } from "../observable/with-immediate-value.js";
+/** A model that returns a single event or undefined when its removed */
+export function EventModel(id) {
+    return (events) => merge(
+    // get current event and ignore if there is none
+    defer(() => {
+        let event = events.getEvent(id);
+        return event ? of(event) : EMPTY;
+    }), 
+    // subscribe to updates
+    events.insert$.pipe(filter((e) => e.id === id)), 
+    // subscribe to updates
+    events.updated(id), 
+    // emit undefined when deleted
+    events.removed(id).pipe(endWith(undefined))).pipe(
+    // claim all events
+    claimLatest(events), 
+    // always emit undefined so the observable is synchronous
+    withImmediateValueOrDefault(undefined));
+}
+/** A model that returns the latest version of a replaceable event or undefined if its removed */
+export function ReplaceableModel(kind, pubkey, d) {
+    return (events) => {
+        let current = undefined;
+        return merge(
+        // lazily get current event
+        defer(() => {
+            let event = events.getReplaceable(kind, pubkey, d);
+            return event ? of(event) : EMPTY;
+        }), 
+        // subscribe to new events
+        events.insert$.pipe(filter((e) => e.pubkey == pubkey && e.kind === kind && (d !== undefined ? getReplaceableIdentifier(e) === d : true)))).pipe(
+        // only update if event is newer
+        distinctUntilChanged((prev, event) => {
+            // are the events the same? i.e. is the prev event older
+            return prev.created_at >= event.created_at;
+        }), 
+        // Hacky way to extract the current event so takeUntil can access it
+        tap((event) => (current = event)), 
+        // complete when event is removed
+        takeUntil(events.remove$.pipe(filter((e) => e.id === current?.id))), 
+        // emit undefined when removed
+        endWith(undefined), 
+        // keep the observable hot
+        repeat(), 
+        // claim latest event
+        claimLatest(events), 
+        // always emit undefined so the observable is synchronous
+        withImmediateValueOrDefault(undefined));
+    };
+}
+/** A model that returns an array of sorted events matching the filters */
+export function TimelineModel(filters, includeOldVersion) {
+    filters = Array.isArray(filters) ? filters : [filters];
+    return (events) => {
+        const seen = new Map();
+        // get current events
+        return defer(() => of(Array.from(events.getTimeline(filters)))).pipe(
+        // claim existing events
+        claimEvents(events), 
+        // subscribe to newer events
+        mergeWith(events.insert$.pipe(filter((e) => matchFilters(filters, e)), 
+        // claim all new events
+        claimEvents(events))), 
+        // subscribe to delete events
+        mergeWith(events.remove$.pipe(filter((e) => matchFilters(filters, e)), map((e) => e.id))), 
+        // build a timeline
+        scan((timeline, event) => {
+            // filter out removed events from timeline
+            if (typeof event === "string")
+                return timeline.filter((e) => e.id !== event);
+            // initial timeline array
+            if (Array.isArray(event)) {
+                if (!includeOldVersion) {
+                    for (const e of event)
+                        if (isReplaceable(e.kind))
+                            seen.set(getEventUID(e), e);
+                }
+                return event;
+            }
+            // create a new timeline and insert the event into it
+            let newTimeline = [...timeline];
+            // remove old replaceable events if enabled
+            if (!includeOldVersion && isReplaceable(event.kind)) {
+                const uid = getEventUID(event);
+                const existing = seen.get(uid);
+                // if this is an older replaceable event, exit
+                if (existing && event.created_at < existing.created_at)
+                    return timeline;
+                // update latest version
+                seen.set(uid, event);
+                // remove old event from timeline
+                if (existing)
+                    newTimeline.slice(newTimeline.indexOf(existing), 1);
+            }
+            // add event into timeline
+            insertEventIntoDescendingList(newTimeline, event);
+            return newTimeline;
+        }, []), 
+        // ignore changes that do not modify the timeline instance
+        distinctUntilChanged(), 
+        // hacky hack to clear seen on unsubscribe
+        finalize(() => seen.clear()));
+    };
+}
+/** A model that returns a multiple events in a map */
+export function EventsModel(ids) {
+    return (events) => merge(
+    // lazily get existing events
+    defer(() => from(ids.map((id) => events.getEvent(id)))), 
+    // subscribe to new events
+    events.insert$.pipe(filter((e) => ids.includes(e.id))), 
+    // subscribe to updates
+    events.update$.pipe(filter((e) => ids.includes(e.id)))).pipe(
+    // ignore empty messages
+    filter((e) => !!e), 
+    // claim all events until cleanup
+    claimEvents(events), 
+    // watch for removed events
+    mergeWith(events.remove$.pipe(filter((e) => ids.includes(e.id)), map((e) => e.id))), 
+    // merge all events into a directory
+    scan((dir, event) => {
+        if (typeof event === "string") {
+            // delete event by id
+            const clone = { ...dir };
+            delete clone[event];
+            return clone;
+        }
+        else {
+            // add even to directory
+            return { ...dir, [event.id]: event };
+        }
+    }, {}));
+}
+/** A model that returns a directory of events by their UID */
+export function ReplaceableSetModel(pointers) {
+    return (events) => {
+        const uids = new Set(pointers.map((p) => createReplaceableAddress(p.kind, p.pubkey, p.identifier)));
+        return merge(
+        // start with existing events
+        defer(() => from(pointers.map((p) => events.getReplaceable(p.kind, p.pubkey, p.identifier)))), 
+        // subscribe to new events
+        events.insert$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))))).pipe(
+        // filter out undefined
+        filter((e) => !!e), 
+        // claim all events
+        claimEvents(events), 
+        // convert events to add commands
+        map((e) => ["add", e]), 
+        // watch for removed events
+        mergeWith(events.remove$.pipe(filter((e) => isReplaceable(e.kind) && uids.has(getEventUID(e))), map((e) => ["remove", e]))), 
+        // reduce events into directory
+        scan((dir, [action, event]) => {
+            const uid = getEventUID(event);
+            if (action === "add") {
+                // add event to dir if its newer
+                if (!dir[uid] || dir[uid].created_at < event.created_at)
+                    return { ...dir, [uid]: event };
+            }
+            else if (action === "remove" && dir[uid] === event) {
+                // remove event from dir
+                let newDir = { ...dir };
+                delete newDir[uid];
+                return newDir;
+            }
+            return dir;
+        }, {}), 
+        // ignore changes that do not modify the directory
+        distinctUntilChanged());
+    };
+}

package/dist/models/contacts.d.ts

@@ -0,0 +1,8 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Model } from "../event-store/interface.js";
+/** A model that returns all contacts for a user */
+export declare function ContactsModel(pubkey: string): Model<ProfilePointer[]>;
+/** A model that returns all public contacts for a user */
+export declare function PublicContactsModel(pubkey: string): Model<ProfilePointer[] | undefined>;
+/** A model that returns all hidden contacts for a user */
+export declare function HiddenContactsModel(pubkey: string): Model<ProfilePointer[] | null | undefined>;

package/dist/{queries → models}/contacts.js

@@ -1,24 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 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) {
+import { watchEventUpdates } from "../observable/index.js";
+/** A model that returns all contacts for a user */
+export function ContactsModel(pubkey) {
     return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
     // listen for event updates (hidden tags unlocked)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get all contacts
-    map((e) => e && getContacts(e)));
+    map((e) => (e ? getContacts(e) : [])));
 }
-/** A query that returns all public contacts for a user */
-export function PublicContactsQuery(pubkey) {
+/** A model that returns all public contacts for a user */
+export function PublicContactsModel(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) {
+/** A model that returns all hidden contacts for a user */
+export function HiddenContactsModel(pubkey) {
     return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
     // listen for event updates (hidden tags unlocked)
-    listenLatestUpdates(events), 
+    watchEventUpdates(events), 
     // Get hidden contacts
     map((e) => e && (getHiddenContacts(e) ?? null)));
 }

package/dist/models/encrypted-content.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+/** A model that returns the encrypted content of an event or event id */
+export declare function EncryptedContentModel(event: NostrEvent | string): Model<string | undefined>;

package/dist/models/encrypted-content.js

@@ -0,0 +1,11 @@
+import { map, of } from "rxjs";
+import { getEncryptedContent } from "../helpers/encrypted-content.js";
+import { watchEventUpdates } from "../observable/watch-event-updates.js";
+/** A model that returns the encrypted content of an event or event id */
+export function EncryptedContentModel(event) {
+    return (events) => (typeof event === "string" ? events.event(event) : of(event)).pipe(
+    // Listen for updates to the event
+    watchEventUpdates(events), 
+    // Get the encrypted content
+    map((event) => event && getEncryptedContent(event)));
+}

package/dist/models/gift-wrap.d.ts

@@ -0,0 +1,7 @@
+import { NostrEvent } from "nostr-tools";
+import { Model } from "../event-store/interface.js";
+import { Rumor } from "../helpers/gift-wraps.js";
+/** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
+export declare function GiftWrapsModel(pubkey: string, locked?: boolean): Model<NostrEvent[]>;
+/** A model that returns the rumor event of a gift wrap event when its unlocked */
+export declare function GiftWrapRumorModel(gift: NostrEvent | string): Model<Rumor | undefined>;

package/dist/models/gift-wrap.js

@@ -0,0 +1,20 @@
+import { kinds } from "nostr-tools";
+import { identity, map, of } from "rxjs";
+import { getGiftWrapRumor, isGiftWrapLocked } from "../helpers/gift-wraps.js";
+import { watchEventsUpdates, watchEventUpdates } from "../observable/watch-event-updates.js";
+/** A model that returns all gift wrap events for a pubkey, optionally filtered by locked status */
+export function GiftWrapsModel(pubkey, locked) {
+    return (store) => store.timeline({ kinds: [kinds.GiftWrap], "#p": [pubkey] }).pipe(
+    // Update the timeline when events are updated
+    watchEventsUpdates(store), 
+    // If lock is specified filter on locked status
+    locked !== undefined ? map((events) => events.filter((e) => isGiftWrapLocked(e) === locked)) : identity);
+}
+/** A model that returns the rumor event of a gift wrap event when its unlocked */
+export function GiftWrapRumorModel(gift) {
+    return (events) => (typeof gift === "string" ? events.event(gift) : of(gift)).pipe(
+    // Listen for updates to the event
+    watchEventUpdates(events), 
+    // Get the rumor event
+    map((event) => event && getGiftWrapRumor(event)));
+}

package/dist/{queries → models}/index.d.ts

@@ -2,13 +2,17 @@ export * from "./blossom.js";
 export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
+export * from "./common.js";
 export * from "./contacts.js";
-export * from "./relays.js";
+export * from "./encrypted-content.js";
+export * from "./gift-wrap.js";
+export * from "./legacy-messages.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";
 export * from "./profile.js";
 export * from "./reactions.js";
-export * from "./simple.js";
+export * from "./relays.js";
 export * from "./thread.js";
+export * from "./wrapped-messages.js";
 export * from "./zaps.js";