applesauce-core 2.1.1 → 2.3.0

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

@@ -1 +1 @@
-export declare const INDEXABLE_TAGS: Set<string>;
+export {};

package/dist/event-store/common.js

@@ -1,2 +1 @@
-const LETTERS = "abcdefghijklmnopqrstuvwxyz";
-export const INDEXABLE_TAGS = new Set((LETTERS + LETTERS.toUpperCase()).split(""));
+export {};

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

@@ -79,4 +79,6 @@ export declare class EventSet implements IEventSet {
     getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Remove the oldest events that are not claimed */
     prune(limit?: number): number;
+    /** Resets the event set */
+    reset(): void;
 }

package/dist/event-store/event-set.js

@@ -1,9 +1,9 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
 import { Subject } from "rxjs";
-import { createReplaceableAddress, getIndexableTags, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
+import { getIndexableTags, INDEXABLE_TAGS } from "../helpers/event-tags.js";
+import { createReplaceableAddress, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { LRU } from "../helpers/lru.js";
 import { logger } from "../logger.js";
-import { INDEXABLE_TAGS } from "./common.js";
 /**
  * A set of nostr events that can be queried and subscribed to
  * NOTE: does not handle replaceable events or any deletion logic
@@ -344,4 +344,14 @@ export class EventSet {
         }
         return removed;
     }
+    /** Resets the event set */
+    reset() {
+        this.events.clear();
+        this.kinds.clear();
+        this.authors.clear();
+        this.tags.clear();
+        this.created_at = [];
+        this.replaceable.clear();
+        this.claims = new WeakMap();
+    }
 }

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

@@ -3,8 +3,6 @@ import { Observable } from "rxjs";
 import { EventSet } from "./event-set.js";
 import { IEventStore, ModelConstructor } from "./interface.js";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-/** A symbol on an event that marks which event store its part of */
-export declare const EventStoreSymbol: unique symbol;
 export declare class EventStore implements IEventStore {
     database: EventSet;
     /** Enable this to keep old versions of replaceable events */

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

@@ -3,7 +3,7 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, take, timer } from "rxjs";
 import hash_sum from "hash-sum";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { FromCacheSymbol, getReplaceableAddress, getTagValue, isReplaceable } from "../helpers/event.js";
+import { EventStoreSymbol, FromCacheSymbol, getReplaceableAddress, isReplaceable } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
@@ -16,8 +16,6 @@ import { ReactionsModel } from "../models/reactions.js";
 import { MailboxesModel } from "../models/mailboxes.js";
 import { UserBlossomServersModel } from "../models/blossom.js";
 import { CommentsModel, ThreadModel } from "../models/index.js";
-/** A symbol on an event that marks which event store its part of */
-export const EventStoreSymbol = Symbol.for("event-store");
 export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
@@ -120,7 +118,7 @@ export class EventStore {
         if (this.checkDeleted(event))
             return event;
         // Get the replaceable identifier
-        const d = isReplaceable(event.kind) ? getTagValue(event, "d") : undefined;
+        const d = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
         // Don't insert the event if there is already a newer version
         if (!this.keepOldVersions && isReplaceable(event.kind)) {
             const existing = this.database.getReplaceableHistory(event.kind, event.pubkey, d);

package/dist/helpers/article.js

@@ -1,4 +1,4 @@
-import { getTagValue } from "./event.js";
+import { getTagValue } from "./event-tags.js";
 /** Returns an articles title, if it exists */
 export function getArticleTitle(article) {
     return getTagValue(article, "title");

package/dist/helpers/emoji.js

@@ -1,4 +1,4 @@
-import { getTagValue } from "./event.js";
+import { getTagValue } from "./event-tags.js";
 /** Gets an "emoji" tag that matches an emoji code */
 export function getEmojiTag(tags, code) {
     code = code.replace(/^:|:$/g, "").toLowerCase();

package/dist/helpers/encrypted-content-cache.d.ts

@@ -1,3 +1,4 @@
+import { NostrEvent } from "nostr-tools";
 import { Observable } from "rxjs";
 import { IEventStoreStreams } from "../event-store/interface.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
@@ -11,5 +12,11 @@ export interface EncryptedContentCache {
 export declare function markEncryptedContentFromCache<T extends object>(event: T): void;
 /** Checks if the encrypted content is from a cache */
 export declare function isEncryptedContentFromCache<T extends object>(event: T): boolean;
-/** Starts a process that persists and restores all encrypted content */
-export declare function persistEncryptedContent(eventStore: IEventStoreStreams, storage: EncryptedContentCache | Observable<EncryptedContentCache>): () => void;
+/**
+ * Starts a process that persists and restores all encrypted content
+ * @param eventStore - The event store to listen to
+ * @param storage - The storage to use
+ * @param fallback - A function that will be called when the encrypted content is not found in storage
+ * @returns A function that can be used to stop the process
+ */
+export declare function persistEncryptedContent(eventStore: IEventStoreStreams, storage: EncryptedContentCache | Observable<EncryptedContentCache>, fallback?: (event: NostrEvent) => any | Promise<any>): () => void;

package/dist/helpers/encrypted-content-cache.js

@@ -3,7 +3,7 @@ import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map,
 import { logger } from "../logger.js";
 import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentLocked, setEncryptedContentCache, } from "./encrypted-content.js";
 import { notifyEventUpdate } from "./event.js";
-import { getGiftWrapSeal } from "./gift-wraps.js";
+import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } from "./gift-wraps.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
 export const EncryptedContentFromCacheSymbol = Symbol.for("encrypted-content-from-cache");
 /** Marks the encrypted content as being from a cache */
@@ -15,9 +15,19 @@ export function isEncryptedContentFromCache(event) {
     return Reflect.has(event, EncryptedContentFromCacheSymbol);
 }
 const log = logger.extend("EncryptedContentCache");
-/** Starts a process that persists and restores all encrypted content */
-export function persistEncryptedContent(eventStore, storage) {
+/**
+ * Starts a process that persists and restores all encrypted content
+ * @param eventStore - The event store to listen to
+ * @param storage - The storage to use
+ * @param fallback - A function that will be called when the encrypted content is not found in storage
+ * @returns A function that can be used to stop the process
+ */
+export function persistEncryptedContent(eventStore, storage, fallback) {
     const storage$ = isObservable(storage) ? storage : of(storage);
+    // Get the encrypted content from storage or call the fallback
+    const getItem = async (storage, event) => {
+        return (await storage.getItem(event.id)) || (fallback ? await fallback(event) : null);
+    };
     // Restore encrypted content when it is inserted
     const restore = eventStore.insert$
         .pipe(
@@ -26,7 +36,7 @@ export function persistEncryptedContent(eventStore, storage) {
     // Get the encrypted content from storage
     mergeMap((event) => 
     // Wait for storage to be available
-    storage$.pipe(switchMap((storage) => combineLatest([of(event), storage.getItem(event.id)])), catchError((error) => {
+    storage$.pipe(switchMap((storage) => combineLatest([of(event), getItem(storage, event)])), catchError((error) => {
         log(`Failed to restore encrypted content for ${event.id}`, error);
         return EMPTY;
     }))))
@@ -44,25 +54,29 @@ export function persistEncryptedContent(eventStore, storage) {
     // Look for gift wraps that are unlocked
     filter((e) => e.kind === kinds.GiftWrap && !isEncryptedContentLocked(e)), 
     // Get the seal event
-    map((gift) => [gift, getGiftWrapSeal(gift)]), 
+    map((gift) => getGiftWrapSeal(gift)), 
     // Look for gift wraps with locked seals
-    filter(([_gift, seal]) => seal !== undefined && isEncryptedContentLocked(seal)), 
+    filter((seal) => seal !== undefined && isEncryptedContentLocked(seal)), 
     // Only attempt to unlock seals once
-    distinct(([_gift, seal]) => seal.id), 
+    distinct((seal) => seal.id), 
     // Get encrypted content from storage
-    mergeMap(([gift, seal]) => 
+    mergeMap((seal) => 
     // Wait for storage to be available
-    storage$.pipe(switchMap((storage) => combineLatest([of(gift), of(seal), storage.getItem(seal.id)])), catchError((error) => {
+    storage$.pipe(switchMap((storage) => combineLatest([of(seal), getItem(storage, seal)])), catchError((error) => {
         log(`Failed to restore encrypted content for ${seal.id}`, error);
         return EMPTY;
     }))))
-        .subscribe(async ([gift, seal, content]) => {
+        .subscribe(async ([seal, content]) => {
         if (!seal || !content)
             return;
         markEncryptedContentFromCache(seal);
         setEncryptedContentCache(seal, content);
+        // Parse the rumor event
+        getSealRumor(seal);
         // Trigger an update to the gift wrap event
-        notifyEventUpdate(gift);
+        const gift = getSealGiftWrap(seal);
+        if (gift)
+            notifyEventUpdate(gift);
         log(`Restored encrypted content for ${seal.id}`);
     });
     // Persist encrypted content when it is updated or inserted
@@ -94,14 +108,14 @@ export function persistEncryptedContent(eventStore, storage) {
     // Look for gift wraps that are unlocked
     filter(([event]) => event.kind === kinds.GiftWrap && !isEncryptedContentLocked(event)), 
     // Get the seal event
-    map(([gift, storage]) => [gift, getGiftWrapSeal(gift), storage]), 
+    map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
     // Make sure the seal is defined
-    filter(([_gift, seal]) => seal !== undefined), 
+    filter(([seal]) => seal !== undefined), 
     // Make sure seal is unlocked and not from cache
-    filter(([_gift, seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
+    filter(([seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
     // Only persist the seal once
     distinct(([seal]) => seal.id))
-        .subscribe(async ([_gift, seal, storage]) => {
+        .subscribe(async ([seal, storage]) => {
         if (!seal)
             return;
         try {

package/dist/helpers/encrypted-content.js

@@ -16,6 +16,8 @@ export function setEncryptedContentEncryptionMethod(kind, method) {
 /** Returns either nip04 or nip44 encryption methods depending on event kind */
 export function getEncryptedContentEncryptionMethods(kind, signer) {
     const method = EventContentEncryptionMethod[kind];
+    if (!method)
+        throw new Error(`Event kind ${kind} does not support encrypted content`);
     const encryption = signer[method];
     if (!encryption)
         throw new Error(`Signer does not support ${method} encryption`);

package/dist/helpers/event-tags.d.ts

@@ -0,0 +1,14 @@
+import { NostrEvent } from "nostr-tools";
+export declare const INDEXABLE_TAGS: Set<string>;
+export declare const EventIndexableTagsSymbol: unique symbol;
+/**
+ * Returns the second index ( tag[1] ) of the first tag that matches the name
+ * If the event has any hidden tags they will be searched first
+ */
+export declare function getTagValue<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+}>(event: T, name: string): string | undefined;
+/** Returns a Set of tag names and values that are indexable */
+export declare function getIndexableTags(event: NostrEvent): Set<string>;

package/dist/helpers/event-tags.js

@@ -0,0 +1,30 @@
+import { getHiddenTags } from "./hidden-tags.js";
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const INDEXABLE_TAGS = new Set((LETTERS + LETTERS.toUpperCase()).split(""));
+export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
+/**
+ * Returns the second index ( tag[1] ) of the first tag that matches the name
+ * If the event has any hidden tags they will be searched first
+ */
+export function getTagValue(event, name) {
+    const hidden = getHiddenTags(event);
+    const hiddenValue = hidden?.find((t) => t[0] === name)?.[1];
+    if (hiddenValue)
+        return hiddenValue;
+    return event.tags.find((t) => t[0] === name)?.[1];
+}
+/** Returns a Set of tag names and values that are indexable */
+export function getIndexableTags(event) {
+    let indexable = Reflect.get(event, EventIndexableTagsSymbol);
+    if (!indexable) {
+        const tags = new Set();
+        for (const tag of event.tags) {
+            if (tag.length >= 2 && tag[0].length === 1 && INDEXABLE_TAGS.has(tag[0])) {
+                tags.add(tag[0] + ":" + tag[1]);
+            }
+        }
+        indexable = tags;
+        Reflect.set(event, EventIndexableTagsSymbol, tags);
+    }
+    return indexable;
+}

package/dist/helpers/event.d.ts

@@ -1,13 +1,14 @@
 import { NostrEvent, VerifiedEvent } from "nostr-tools";
 import { IEventStore } from "../event-store/interface.js";
+/** A symbol on an event that marks which event store its part of */
+export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;
 export declare const ReplaceableAddressSymbol: unique symbol;
-export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
 export declare const ReplaceableIdentifierSymbol: unique symbol;
 /**
  * Checks if an object is a nostr event
- * NOTE: does not validation the signature on the event
+ * NOTE: does not validate the signature on the event
  */
 export declare function isEvent(event: any): event is NostrEvent;
 /**
@@ -28,17 +29,6 @@ export declare function getReplaceableAddress(event: NostrEvent): string;
 export declare function createReplaceableAddress(kind: number, pubkey: string, identifier?: string): string;
 /** @deprecated use createReplaceableAddress instead */
 export declare const getReplaceableUID: typeof createReplaceableAddress;
-/** Returns a Set of tag names and values that are indexable */
-export declare function getIndexableTags(event: NostrEvent): Set<string>;
-/**
- * Returns the second index ( tag[1] ) of the first tag that matches the name
- * If the event has any hidden tags they will be searched first
- */
-export declare function getTagValue<T extends {
-    kind: number;
-    tags: string[][];
-    content: string;
-}>(event: T, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */

package/dist/helpers/event.js

@@ -1,17 +1,15 @@
 import { verifiedSymbol } from "nostr-tools";
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
-import { INDEXABLE_TAGS } from "../event-store/common.js";
-import { EventStoreSymbol } from "../event-store/event-store.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./hidden-tags.js";
+/** A symbol on an event that marks which event store its part of */
+export const EventStoreSymbol = Symbol.for("event-store");
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const ReplaceableAddressSymbol = Symbol.for("replaceable-address");
-export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
 export const ReplaceableIdentifierSymbol = Symbol.for("replaceable-identifier");
 /**
  * Checks if an object is a nostr event
- * NOTE: does not validation the signature on the event
+ * NOTE: does not validate the signature on the event
  */
 export function isEvent(event) {
     if (event === undefined || event === null)
@@ -64,32 +62,6 @@ export function createReplaceableAddress(kind, pubkey, identifier) {
 }
 /** @deprecated use createReplaceableAddress instead */
 export const getReplaceableUID = createReplaceableAddress;
-/** Returns a Set of tag names and values that are indexable */
-export function getIndexableTags(event) {
-    let indexable = Reflect.get(event, EventIndexableTagsSymbol);
-    if (!indexable) {
-        const tags = new Set();
-        for (const tag of event.tags) {
-            if (tag.length >= 2 && tag[0].length === 1 && INDEXABLE_TAGS.has(tag[0])) {
-                tags.add(tag[0] + ":" + tag[1]);
-            }
-        }
-        indexable = tags;
-        Reflect.set(event, EventIndexableTagsSymbol, tags);
-    }
-    return indexable;
-}
-/**
- * Returns the second index ( tag[1] ) of the first tag that matches the name
- * If the event has any hidden tags they will be searched first
- */
-export function getTagValue(event, name) {
-    const hidden = getHiddenTags(event);
-    const hiddenValue = hidden?.find((t) => t[0] === name)?.[1];
-    if (hiddenValue)
-        return hiddenValue;
-    return event.tags.find((t) => t[0] === name)?.[1];
-}
 /** Sets events verified flag without checking anything */
 export function fakeVerifyEvent(event) {
     event[verifiedSymbol] = true;
@@ -121,7 +93,7 @@ export function getReplaceableIdentifier(event) {
     if (!isAddressableKind(event.kind))
         throw new Error("Event is not addressable");
     return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
-        const d = getTagValue(event, "d");
+        const d = event.tags.find((t) => t[0] === "d")?.[1];
         if (d === undefined)
             throw new Error("Event missing identifier");
         return d;

package/dist/helpers/expiration.js

@@ -1,6 +1,6 @@
-import { getTagValue } from "./event.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { unixNow } from "./time.js";
+import { getTagValue } from "./event-tags.js";
 export const ExpirationTimestampSymbol = Symbol("expiration-timestamp");
 /** Returns the NIP-40 expiration timestamp for an event */
 export function getExpirationTimestamp(event) {

package/dist/helpers/filter.js

@@ -1,5 +1,5 @@
-import { getIndexableTags } from "./event.js";
 import equal from "fast-deep-equal";
+import { getIndexableTags } from "./event-tags.js";
 /**
  * Copied from nostr-tools and modified to use getIndexableTags
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts

package/dist/helpers/gift-wraps.d.ts

@@ -1,24 +1,46 @@
 import { NostrEvent, UnsignedEvent } from "nostr-tools";
+import { EventSet } from "../event-store/event-set.js";
 import { EncryptedContentSigner } from "./encrypted-content.js";
+/**
+ * An internal event set to keep track of seals and rumors
+ * This is intentially isolated from the main applications event store so to prevent seals and rumors from being leaked
+ */
+export declare const internalGiftWrapEvents: EventSet;
 export type Rumor = UnsignedEvent & {
     id: string;
 };
-export declare const GiftWrapSealSymbol: unique symbol;
-export declare const GiftWrapRumorSymbol: unique symbol;
-/** Returns the unsigned seal event in a gift-wrap event */
-export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
+/** Used to store a reference to the seal event on gift wraps (downstream) or the seal event on rumors (upstream[]) */
+export declare const SealSymbol: unique symbol;
+/** Used to store a reference to the rumor on seals (downstream) */
+export declare const RumorSymbol: unique symbol;
+/** Used to store a reference to the parent gift wrap event on seals (upstream) */
+export declare const GiftWrapSymbol: unique symbol;
+/** Checks if an event is a rumor (normal event with "id" and no "sig") */
+export declare function isRumor(event: any): event is Rumor;
+/** Returns all the parent gift wraps for a seal event */
+export declare function getSealGiftWrap(seal: NostrEvent): NostrEvent | undefined;
+/** Returns all the parent seals for a rumor event */
+export declare function getRumorSeals(rumor: Rumor): NostrEvent[];
+/** Returns all the parent gift wraps for a rumor event */
+export declare function getRumorGiftWraps(rumor: Rumor): NostrEvent[];
 /** Checks if a seal event is locked */
 export declare function isSealLocked(seal: NostrEvent): boolean;
 /** Gets the rumor from a seal event */
 export declare function getSealRumor(seal: NostrEvent): Rumor | undefined;
-/**
- * Returns the unsigned event in the gift-wrap seal
- * @throws {Error} If the author of the rumor event does not match the author of the seal
- */
+/** Returns the seal event in a gift-wrap event */
+export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
+/** Returns the unsigned rumor in the gift-wrap */
 export declare function getGiftWrapRumor(gift: NostrEvent): Rumor | undefined;
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export declare function isGiftWrapLocked(gift: NostrEvent): boolean;
-/** Unlocks and returns the unsigned seal event in a gift-wrap */
-export declare function unlockGiftWrap(gift: NostrEvent, signer: EncryptedContentSigner): Promise<UnsignedEvent>;
-/** Locks a gift-wrap event by removing its cached seal and encrypted content */
+/**
+ * Unlocks a seal event and returns the rumor event
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function unlockSeal(seal: NostrEvent, signer: EncryptedContentSigner): Promise<Rumor>;
+/**
+ * Unlocks and returns the unsigned seal event in a gift-wrap
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function unlockGiftWrap(gift: NostrEvent, signer: EncryptedContentSigner): Promise<Rumor>;
 export declare function lockGiftWrap(gift: NostrEvent): void;

package/dist/helpers/gift-wraps.js

@@ -1,21 +1,68 @@
 import { verifyEvent } from "nostr-tools";
-import { getOrComputeCachedValue } from "./cache.js";
+import { EventSet } from "../event-store/event-set.js";
 import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
-import { isEvent, notifyEventUpdate } from "./event.js";
-export const GiftWrapSealSymbol = Symbol.for("gift-wrap-seal");
-export const GiftWrapRumorSymbol = Symbol.for("gift-wrap-rumor");
-/** Returns the unsigned seal event in a gift-wrap event */
-export function getGiftWrapSeal(gift) {
-    if (isEncryptedContentLocked(gift))
-        return undefined;
-    const plaintext = getEncryptedContent(gift);
-    if (!plaintext)
-        return undefined;
-    return getOrComputeCachedValue(gift, GiftWrapSealSymbol, () => {
-        const seal = JSON.parse(plaintext);
-        verifyEvent(seal);
-        return seal;
-    });
+import { notifyEventUpdate } from "./event.js";
+/**
+ * An internal event set to keep track of seals and rumors
+ * This is intentially isolated from the main applications event store so to prevent seals and rumors from being leaked
+ */
+export const internalGiftWrapEvents = new EventSet();
+/** Used to store a reference to the seal event on gift wraps (downstream) or the seal event on rumors (upstream[]) */
+export const SealSymbol = Symbol.for("seal");
+/** Used to store a reference to the rumor on seals (downstream) */
+export const RumorSymbol = Symbol.for("rumor");
+/** Used to store a reference to the parent gift wrap event on seals (upstream) */
+export const GiftWrapSymbol = Symbol.for("gift-wrap");
+/** Adds a parent reference to a seal or rumor */
+function addParentSealReference(rumor, seal) {
+    const parents = Reflect.get(rumor, SealSymbol);
+    if (!parents)
+        Reflect.set(rumor, SealSymbol, new Set([seal]));
+    else
+        parents.add(seal);
+}
+/** Removes a parent reference from a seal or rumor */
+function removeParentSealReference(rumor, seal) {
+    const parents = Reflect.get(rumor, SealSymbol);
+    if (parents)
+        parents.delete(seal);
+}
+/** Checks if an event is a rumor (normal event with "id" and no "sig") */
+export function isRumor(event) {
+    if (event === undefined || event === null)
+        return false;
+    return (event.id?.length === 64 &&
+        !("sig" in event) &&
+        typeof event.pubkey === "string" &&
+        event.pubkey.length === 64 &&
+        typeof event.content === "string" &&
+        Array.isArray(event.tags) &&
+        typeof event.created_at === "number" &&
+        event.created_at > 0);
+}
+/** Returns all the parent gift wraps for a seal event */
+export function getSealGiftWrap(seal) {
+    return Reflect.get(seal, GiftWrapSymbol);
+}
+/** Returns all the parent seals for a rumor event */
+export function getRumorSeals(rumor) {
+    let set = Reflect.get(rumor, SealSymbol);
+    if (!set) {
+        set = new Set();
+        Reflect.set(rumor, SealSymbol, set);
+    }
+    return Array.from(set);
+}
+/** Returns all the parent gift wraps for a rumor event */
+export function getRumorGiftWraps(rumor) {
+    const giftWraps = new Set();
+    const seals = getRumorSeals(rumor);
+    for (const seal of seals) {
+        const upstream = getSealGiftWrap(seal);
+        if (upstream)
+            giftWraps.add(upstream);
+    }
+    return Array.from(giftWraps);
 }
 /** Checks if a seal event is locked */
 export function isSealLocked(seal) {
@@ -23,29 +70,64 @@ export function isSealLocked(seal) {
 }
 /** Gets the rumor from a seal event */
 export function getSealRumor(seal) {
-    if (isEncryptedContentLocked(seal))
-        return undefined;
+    // Returned cached rumor if it exists (downstream)
+    const cached = Reflect.get(seal, RumorSymbol);
+    if (cached)
+        return cached;
+    // Get the encrypted content plaintext
     const plaintext = getEncryptedContent(seal);
     if (!plaintext)
         return undefined;
-    return getOrComputeCachedValue(seal, GiftWrapRumorSymbol, () => {
-        const rumor = JSON.parse(plaintext);
-        if (rumor.pubkey !== seal.pubkey)
-            throw new Error("Seal author does not match rumor author");
-        return rumor;
-    });
+    let rumor = JSON.parse(plaintext);
+    // Check if the rumor event already exists in the internal event set
+    const existing = internalGiftWrapEvents.getEvent(rumor.id);
+    if (existing)
+        // Reuse the existing rumor instance
+        rumor = existing;
+    else
+        // Add to the internal event set
+        internalGiftWrapEvents.add(rumor);
+    // Save a reference to the parent seal event
+    addParentSealReference(rumor, seal);
+    // Save a reference to the rumor on the seal (downstream)
+    Reflect.set(seal, RumorSymbol, rumor);
+    return rumor;
 }
-/**
- * Returns the unsigned event in the gift-wrap seal
- * @throws {Error} If the author of the rumor event does not match the author of the seal
- */
-export function getGiftWrapRumor(gift) {
-    if (isEncryptedContentLocked(gift))
+/** Returns the seal event in a gift-wrap event */
+export function getGiftWrapSeal(gift) {
+    // Returned cached seal if it exists (downstream)
+    const cached = Reflect.get(gift, SealSymbol);
+    if (cached)
+        return cached;
+    // Get the encrypted content plaintext
+    const plaintext = getEncryptedContent(gift);
+    if (!plaintext)
         return undefined;
+    let seal = JSON.parse(plaintext);
+    // Check if the seal event already exists in the internal event set
+    const existing = internalGiftWrapEvents.getEvent(seal.id);
+    if (existing) {
+        // Reuse the existing seal instance
+        seal = existing;
+    }
+    else {
+        // Verify the seal event
+        verifyEvent(seal);
+        // Add to the internal event set
+        internalGiftWrapEvents.add(seal);
+        // Set the reference to the parent gift wrap event (upstream)
+        Reflect.set(seal, GiftWrapSymbol, gift);
+    }
+    // Save a reference to the seal on the gift wrap (downstream)
+    Reflect.set(gift, SealSymbol, seal);
+    return seal;
+}
+/** Returns the unsigned rumor in the gift-wrap */
+export function getGiftWrapRumor(gift) {
     const seal = getGiftWrapSeal(gift);
-    if (!seal || isSealLocked(seal))
+    if (!seal)
         return undefined;
-    return getOrComputeCachedValue(gift, GiftWrapRumorSymbol, () => getSealRumor(seal));
+    return getSealRumor(seal);
 }
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapLocked(gift) {
@@ -53,35 +135,62 @@ export function isGiftWrapLocked(gift) {
         return true;
     else {
         const seal = getGiftWrapSeal(gift);
-        if (!seal || isEncryptedContentLocked(seal))
+        if (!seal || isSealLocked(seal))
             return true;
         else
             return false;
     }
 }
-/** Unlocks and returns the unsigned seal event in a gift-wrap */
+/**
+ * Unlocks a seal event and returns the rumor event
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export async function unlockSeal(seal, signer) {
+    if (isEncryptedContentLocked(seal))
+        await unlockEncryptedContent(seal, seal.pubkey, signer);
+    // Parse the rumor event
+    const rumor = getSealRumor(seal);
+    if (!rumor)
+        throw new Error("Failed to read rumor in gift wrap");
+    // Check if the seal and rumor authors match
+    if (rumor.pubkey !== seal.pubkey)
+        throw new Error("Seal author does not match rumor author");
+    return rumor;
+}
+/**
+ * Unlocks and returns the unsigned seal event in a gift-wrap
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
 export async function unlockGiftWrap(gift, signer) {
     // First unlock the gift-wrap event
     if (isEncryptedContentLocked(gift))
         await unlockEncryptedContent(gift, gift.pubkey, signer);
-    // Next get and unlock the seal
+    // Get the seal event
     const seal = getGiftWrapSeal(gift);
     if (!seal)
         throw new Error("Failed to read seal in gift wrap");
-    if (isEncryptedContentLocked(seal))
-        await unlockEncryptedContent(seal, seal.pubkey, signer);
-    // Finally get the rumor event
-    const rumor = getGiftWrapRumor(gift);
-    if (!rumor)
-        throw new Error("Failed to read rumor in gift wrap");
+    // Unlock the seal event
+    const rumor = await unlockSeal(seal, signer);
     // if the event has been added to an event store, notify it
-    if (isEvent(gift))
-        notifyEventUpdate(gift);
+    notifyEventUpdate(gift);
     return rumor;
 }
-/** Locks a gift-wrap event by removing its cached seal and encrypted content */
 export function lockGiftWrap(gift) {
-    Reflect.deleteProperty(gift, GiftWrapSealSymbol);
-    Reflect.deleteProperty(gift, GiftWrapRumorSymbol);
+    const seal = getGiftWrapSeal(gift);
+    if (seal) {
+        const rumor = getSealRumor(seal);
+        // Remove the rumors parent seal reference (upstream)
+        if (rumor)
+            removeParentSealReference(rumor, seal);
+        // Remove the seal's parent gift wrap reference (upstream)
+        Reflect.deleteProperty(seal, GiftWrapSymbol);
+        // Remove the seal's rumor reference (downstream)
+        Reflect.deleteProperty(seal, RumorSymbol);
+        // Lock the seal's encrypted content
+        lockEncryptedContent(seal);
+    }
+    // Remove the gift wrap's seal reference (downstream)
+    Reflect.deleteProperty(gift, SealSymbol);
+    // Lock the gift wrap's encrypted content
     lockEncryptedContent(gift);
 }

package/dist/helpers/index.d.ts

@@ -14,6 +14,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
 export * from "./external-id.js";

package/dist/helpers/index.js

@@ -14,6 +14,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";
 export * from "./external-id.js";

package/dist/helpers/messages.d.ts

@@ -1,3 +1,5 @@
+import { NostrEvent } from "nostr-tools";
+import { Rumor } from "./gift-wraps.js";
 /**
  * Groups messages into bubble sets based on the pubkey and time
  *
@@ -9,3 +11,21 @@ export declare function groupMessageEvents<T extends {
     created_at: number;
     pubkey: string;
 }>(messages: T[], buffer?: number): T[][];
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - A 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 | NostrEvent): 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[])[]): string;
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The NIP-17 Rumor or NIP-04 message event
+ * @returns The conversation identifier
+ */
+export declare function getConversationIdentifierFromMessage(message: Rumor | NostrEvent): string;

package/dist/helpers/messages.js

@@ -1,3 +1,5 @@
+import { kinds } from "nostr-tools";
+import { isPTag } from "./tags.js";
 /**
  * Groups messages into bubble sets based on the pubkey and time
  *
@@ -17,3 +19,39 @@ export function groupMessageEvents(messages, buffer = 5 * 60) {
     }
     return groups;
 }
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - A 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) {
+    let participantList;
+    if (typeof participants === "string") {
+        participantList = participants.split(":");
+    }
+    else if (Array.isArray(participants)) {
+        participantList = participants;
+    }
+    else {
+        if (participants.kind !== kinds.EncryptedDirectMessage && participants.kind !== kinds.PrivateDirectMessage)
+            throw new Error("Can only get participants from direct message event (4, 14)");
+        participantList = [participants.pubkey, ...participants.tags.filter(isPTag).map((t) => t[1])];
+    }
+    return Array.from(new Set(participantList));
+}
+/**
+ * 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.flat())).sort().join(":");
+}
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The NIP-17 Rumor or NIP-04 message event
+ * @returns The conversation identifier
+ */
+export function getConversationIdentifierFromMessage(message) {
+    return createConversationIdentifier(getConversationParticipants(message));
+}

package/dist/helpers/reactions.js

@@ -1,5 +1,5 @@
 import { getOrComputeCachedValue } from "./cache.js";
-import { getTagValue } from "./event.js";
+import { getTagValue } from "./event-tags.js";
 import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
 import { mergeRelaySets } from "./relays.js";
 import { isATag, isETag, isPTag } from "./tags.js";

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

@@ -1,22 +1,4 @@
 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 */

package/dist/helpers/wrapped-messages.js

@@ -1,33 +1,4 @@
 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");

package/dist/helpers/zap.d.ts

@@ -1,6 +1,6 @@
 import { NostrEvent } from "nostr-tools";
-import { ParsedInvoice } from "./bolt11.js";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { ParsedInvoice } from "./bolt11.js";
 export declare const ZapRequestSymbol: unique symbol;
 export declare const ZapSenderSymbol: unique symbol;
 export declare const ZapReceiverSymbol: unique symbol;

package/dist/helpers/zap.js

@@ -1,9 +1,9 @@
 import { kinds, nip57 } from "nostr-tools";
+import { parseBolt11 } from "./bolt11.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getTagValue } from "./event.js";
-import { isATag, isETag } from "./tags.js";
+import { getTagValue } from "./event-tags.js";
 import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
-import { parseBolt11 } from "./bolt11.js";
+import { isATag, isETag } from "./tags.js";
 export const ZapRequestSymbol = Symbol.for("zap-request");
 export const ZapSenderSymbol = Symbol.for("zap-sender");
 export const ZapReceiverSymbol = Symbol.for("zap-receiver");

package/dist/models/legacy-messages.d.ts

@@ -1,7 +1,13 @@
 import { NostrEvent } from "nostr-tools";
 import { Model } from "../event-store/interface.js";
-/** Returns all legacy direct messages in a conversation */
-export declare function LegacyMessagesConversation(self: string, corraspondant: string): Model<NostrEvent[]>;
+/** A model that returns all legacy message groups (1-1) that a pubkey is participating in */
+export declare function LegacyMessagesGroups(self: string): Model<{
+    id: string;
+    participants: string[];
+    lastMessage: NostrEvent;
+}[]>;
+/** Returns all legacy direct messages in a group */
+export declare function LegacyMessagesGroup(self: string, corraspondant: string): Model<NostrEvent[]>;
 /** Returns an array of legacy messages that have replies */
 export declare function LegacyMessageThreads(self: string, corraspondant: string): Model<NostrEvent[]>;
 /** Returns all the legacy direct messages that are replies to a given message */

package/dist/models/legacy-messages.js

@@ -1,17 +1,41 @@
 import { kinds } from "nostr-tools";
 import { getLegacyMessageCorraspondant, getLegacyMessageParent } from "../helpers/legacy-messages.js";
 import { map } from "rxjs";
-/** Returns all legacy direct messages in a conversation */
-export function LegacyMessagesConversation(self, corraspondant) {
-    return (store) => store.timeline({
-        kinds: [kinds.EncryptedDirectMessage],
-        "#p": [self, corraspondant],
-        authors: [self, corraspondant],
-    });
+import { getConversationIdentifierFromMessage, getConversationParticipants } from "../helpers/messages.js";
+/** A model that returns all legacy message groups (1-1) that a pubkey is participating in */
+export function LegacyMessagesGroups(self) {
+    return (store) => store.timeline({ kinds: [kinds.EncryptedDirectMessage], "#p": [self] }).pipe(map((messages) => {
+        const groups = {};
+        for (const message of messages) {
+            const id = getConversationIdentifierFromMessage(message);
+            if (!groups[id] || groups[id].created_at < message.created_at)
+                groups[id] = message;
+        }
+        return Object.values(groups).map((message) => ({
+            id: getConversationIdentifierFromMessage(message),
+            participants: getConversationParticipants(message),
+            lastMessage: message,
+        }));
+    }));
+}
+/** Returns all legacy direct messages in a group */
+export function LegacyMessagesGroup(self, corraspondant) {
+    return (store) => store.timeline([
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [self],
+            authors: [corraspondant],
+        },
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [corraspondant],
+            authors: [self],
+        },
+    ]);
 }
 /** Returns an array of legacy messages that have replies */
 export function LegacyMessageThreads(self, corraspondant) {
-    return (store) => store.model(LegacyMessagesConversation, self, corraspondant).pipe(map((messages) => messages.filter((message) => 
+    return (store) => store.model(LegacyMessagesGroup, self, corraspondant).pipe(map((messages) => messages.filter((message) => 
     // Only select messages that are not replies
     !getLegacyMessageParent(message) &&
         // Check if message has any replies
@@ -20,10 +44,18 @@ export function LegacyMessageThreads(self, corraspondant) {
 /** Returns all the legacy direct messages that are replies to a given message */
 export function LegacyMessageReplies(self, message) {
     const corraspondant = getLegacyMessageCorraspondant(message, self);
-    return (store) => store.timeline({
-        kinds: [kinds.EncryptedDirectMessage],
-        "#p": [self, corraspondant],
-        authors: [self, corraspondant],
-        "#e": [message.id],
-    });
+    return (store) => store.timeline([
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [self],
+            authors: [corraspondant],
+            "#e": [message.id],
+        },
+        {
+            kinds: [kinds.EncryptedDirectMessage],
+            "#p": [corraspondant],
+            authors: [self],
+            "#e": [message.id],
+        },
+    ]);
 }

package/dist/models/thread.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
-import { ThreadReferences } from "../helpers/threading.js";
 import { Model } from "../event-store/interface.js";
+import { ThreadReferences } from "../helpers/threading.js";
 export type Thread = {
     root?: ThreadItem;
     all: Map<string, ThreadItem>;

package/dist/models/thread.js

@@ -1,10 +1,11 @@
 import { kinds } from "nostr-tools";
 import { isAddressableKind } from "nostr-tools/kinds";
 import { map } from "rxjs/operators";
-import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
-import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
-import { getEventUID, createReplaceableAddress, getTagValue, isEvent } from "../helpers/event.js";
 import { COMMENT_KIND } from "../helpers/comment.js";
+import { getTagValue } from "../helpers/event-tags.js";
+import { createReplaceableAddress, getEventUID, isEvent } from "../helpers/event.js";
+import { getCoordinateFromAddressPointer, isAddressPointer, isEventPointer } from "../helpers/pointers.js";
+import { getNip10References, interpretThreadTags } from "../helpers/threading.js";
 const defaultOptions = {
     kinds: [kinds.ShortTextNote],
 };

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

@@ -5,18 +5,24 @@ import { Rumor } from "../helpers/gift-wraps.js";
  * @param self - The pubkey of the user
  */
 export declare function WrappedMessagesModel(self: string): Model<Rumor[]>;
+/** A model that returns all conversations that a pubkey is participating in */
+export declare function WrappedMessagesGroups(self: string): Model<{
+    id: string;
+    participants: string[];
+    lastMessage: Rumor;
+}[]>;
 /**
  * A model that returns all wrapped direct messages in a conversation
  * @param self - The pubkey of the user
  * @param participants - A conversation identifier or a list of participant pubkeys
  */
-export declare function WrappedMessagesConversation(self: string, participants: string | string[]): Model<Rumor[]>;
+export declare function WrappedMessagesGroup(self: string, participants: string | string[]): Model<Rumor[]>;
 /**
  * Returns an array of root wrapped messages that have replies
  * @param self - The pubkey of the user
- * @param conversation - The conversation identifier
+ * @param participants - A conversation identifier or a list of participant pubkeys
  */
-export declare function WrappedMessageThreads(self: string, conversation: string): Model<Rumor[]>;
+export declare function WrappedMessageThreads(self: string, participants: string | string[]): Model<Rumor[]>;
 /**
  * A model that returns all the gift wrapped direct messages that are replies to a given message
  * @param self - The pubkey of the user

package/dist/models/wrapped-messages.js

@@ -1,7 +1,8 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs";
 import { getGiftWrapRumor } from "../helpers/gift-wraps.js";
-import { createConversationIdentifier, getConversationIdentifierFromMessage, getConversationParticipants, getWrappedMessageParent, } from "../helpers/wrapped-messages.js";
+import { createConversationIdentifier, getConversationIdentifierFromMessage, getConversationParticipants, } from "../helpers/messages.js";
+import { getWrappedMessageParent } from "../helpers/wrapped-messages.js";
 import { watchEventsUpdates } from "../observable/watch-event-updates.js";
 /**
  * A model that returns all wrapped messages for a pubkey
@@ -15,19 +16,33 @@ export function WrappedMessagesModel(self) {
     map((rumors) => rumors
         .map((gift) => getGiftWrapRumor(gift))
         .filter((e) => !!e)
+        .filter((e) => e.kind === kinds.PrivateDirectMessage)
         .sort((a, b) => b.created_at - a.created_at)));
 }
+/** A model that returns all conversations that a pubkey is participating in */
+export function WrappedMessagesGroups(self) {
+    return (store) => store.model(WrappedMessagesModel, self).pipe(map((messages) => {
+        const groups = {};
+        for (const message of messages) {
+            const id = getConversationIdentifierFromMessage(message);
+            if (!groups[id] || groups[id].created_at < message.created_at)
+                groups[id] = message;
+        }
+        return Object.values(groups).map((message) => ({
+            id: getConversationIdentifierFromMessage(message),
+            participants: getConversationParticipants(message),
+            lastMessage: message,
+        }));
+    }));
+}
 /**
  * A model that returns all wrapped direct messages in a conversation
  * @param self - The pubkey of the user
  * @param participants - A conversation identifier or a list of participant pubkeys
  */
-export function WrappedMessagesConversation(self, participants) {
+export function WrappedMessagesGroup(self, participants) {
     // Get the conversation identifier include the users pubkey
-    const identifier = createConversationIdentifier([
-        self,
-        ...(typeof participants === "string" ? getConversationParticipants(participants) : participants),
-    ]);
+    const identifier = createConversationIdentifier(self, participants);
     return (store) => store.model(WrappedMessagesModel, self).pipe(
     // Only select direct messages for this conversation
     map((rumors) => rumors.filter((rumor) => rumor.kind === kinds.PrivateDirectMessage &&
@@ -37,10 +52,10 @@ export function WrappedMessagesConversation(self, participants) {
 /**
  * Returns an array of root wrapped messages that have replies
  * @param self - The pubkey of the user
- * @param conversation - The conversation identifier
+ * @param participants - A conversation identifier or a list of participant pubkeys
  */
-export function WrappedMessageThreads(self, conversation) {
-    return (store) => store.model(WrappedMessagesConversation, self, conversation).pipe(
+export function WrappedMessageThreads(self, participants) {
+    return (store) => store.model(WrappedMessagesGroup, self, participants).pipe(
     // Filter down messages to only include root messages that have replies
     map((rumors) => rumors.filter((rumor) => 
     // Only select root messages
@@ -55,7 +70,7 @@ export function WrappedMessageThreads(self, conversation) {
  */
 export function WrappedMessageReplies(self, message) {
     const conversation = getConversationIdentifierFromMessage(message);
-    return (store) => store.model(WrappedMessagesConversation, self, conversation).pipe(
+    return (store) => store.model(WrappedMessagesGroup, self, conversation).pipe(
     // Only select replies to this message
     map((rumors) => rumors.filter((rumor) => getWrappedMessageParent(rumor) === message.id)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",