applesauce-core 2.1.1 → 2.2.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.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

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

@@ -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;
     }))))
@@ -52,7 +62,7 @@ export function persistEncryptedContent(eventStore, storage) {
     // Get encrypted content from storage
     mergeMap(([gift, 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(gift), of(seal), getItem(storage, seal)])), catchError((error) => {
         log(`Failed to restore encrypted content for ${seal.id}`, error);
         return EMPTY;
     }))))

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

@@ -16,6 +16,8 @@ export declare function getSealRumor(seal: NostrEvent): Rumor | undefined;
  * @throws {Error} If the author of the rumor event does not match the author of the seal
  */
 export declare function getGiftWrapRumor(gift: NostrEvent): Rumor | undefined;
+/** Checks if an event is a rumor (normal event with "id" and no "sig") */
+export declare function isRumor(event: any): event is Rumor;
 /** 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 */

package/dist/helpers/gift-wraps.js

@@ -47,6 +47,19 @@ export function getGiftWrapRumor(gift) {
         return undefined;
     return getOrComputeCachedValue(gift, GiftWrapRumorSymbol, () => getSealRumor(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 if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapLocked(gift) {
     if (isEncryptedContentLocked(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.2.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",