applesauce-core 1.0.0 → 2.0.0

package/dist/helpers/gift-wraps.js

@@ -1,49 +1,87 @@
 import { verifyEvent } from "nostr-tools";
-import { getHiddenContent, isHiddenContentLocked, unlockHiddenContent } from "./hidden-content.js";
 import { getOrComputeCachedValue } from "./cache.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 GiftWrapEventSymbol = Symbol.for("gift-wrap-event");
+export const GiftWrapRumorSymbol = Symbol.for("gift-wrap-rumor");
 /** Returns the unsigned seal event in a gift-wrap event */
 export function getGiftWrapSeal(gift) {
-    if (isHiddenContentLocked(gift))
+    if (isEncryptedContentLocked(gift))
+        return undefined;
+    const plaintext = getEncryptedContent(gift);
+    if (!plaintext)
         return undefined;
     return getOrComputeCachedValue(gift, GiftWrapSealSymbol, () => {
-        const plaintext = getHiddenContent(gift);
-        if (!plaintext)
-            throw new Error("Gift-wrap is locked");
         const seal = JSON.parse(plaintext);
-        // verify the seal is valid
         verifyEvent(seal);
         return seal;
     });
 }
-/** Returns the unsigned event in the gift-wrap seal */
-export function getGiftWrapEvent(gift) {
-    if (isHiddenContentLocked(gift))
+/** Checks if a seal event is locked */
+export function isSealLocked(seal) {
+    return isEncryptedContentLocked(seal);
+}
+/** Gets the rumor from a seal event */
+export function getSealRumor(seal) {
+    if (isEncryptedContentLocked(seal))
         return undefined;
-    return getOrComputeCachedValue(gift, GiftWrapEventSymbol, () => {
-        const seal = getGiftWrapSeal(gift);
-        if (!seal)
-            throw new Error("Gift is locked");
-        const plaintext = getHiddenContent(seal);
-        if (!plaintext)
-            throw new Error("Gift-wrap seal is locked");
-        const event = JSON.parse(plaintext);
-        if (event.pubkey !== seal.pubkey)
-            throw new Error("Seal author does not match content");
-        return event;
+    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;
     });
 }
+/**
+ * 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))
+        return undefined;
+    const seal = getGiftWrapSeal(gift);
+    if (!seal || isSealLocked(seal))
+        return undefined;
+    return getOrComputeCachedValue(gift, GiftWrapRumorSymbol, () => getSealRumor(seal));
+}
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapLocked(gift) {
-    return isHiddenContentLocked(gift) || isHiddenContentLocked(getGiftWrapSeal(gift));
+    if (isEncryptedContentLocked(gift))
+        return true;
+    else {
+        const seal = getGiftWrapSeal(gift);
+        if (!seal || isEncryptedContentLocked(seal))
+            return true;
+        else
+            return false;
+    }
 }
 /** Unlocks and returns the unsigned seal event in a gift-wrap */
 export async function unlockGiftWrap(gift, signer) {
-    if (isHiddenContentLocked(gift))
-        await unlockHiddenContent(gift, signer);
+    // First unlock the gift-wrap event
+    if (isEncryptedContentLocked(gift))
+        await unlockEncryptedContent(gift, gift.pubkey, signer);
+    // Next get and unlock the seal
     const seal = getGiftWrapSeal(gift);
-    if (isHiddenContentLocked(seal))
-        await unlockHiddenContent(seal, signer);
-    return getGiftWrapEvent(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");
+    // if the event has been added to an event store, notify it
+    if (isEvent(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);
+    lockEncryptedContent(gift);
 }

package/dist/helpers/groups.d.ts

@@ -3,8 +3,11 @@ export declare const GROUPS_LIST_KIND = 10009;
 export declare const GROUP_MESSAGE_KIND = 9;
 /** NIP-29 group pointer */
 export type GroupPointer = {
+    /** the id of the group */
     id: string;
+    /** The url to the relay with wss:// or ws:// protocol */
     relay: string;
+    /** The name of the group */
     name?: string;
 };
 /**
@@ -16,6 +19,8 @@ export declare function decodeGroupPointer(str: string): GroupPointer;
 export declare function encodeGroupPointer(pointer: GroupPointer): string;
 export declare const GroupsPublicSymbol: unique symbol;
 export declare const GroupsHiddenSymbol: unique symbol;
+/** gets a {@link GroupPointer} from a "h" tag if it has a relay hint */
+export declare function getGroupPointerFromHTag(tag: string[]): GroupPointer | undefined;
 /** gets a {@link GroupPointer} from a "group" tag */
 export declare function getGroupPointerFromGroupTag(tag: string[]): GroupPointer;
 /** Returns all the public groups from a k:10009 list */

package/dist/helpers/groups.js

@@ -1,6 +1,6 @@
 import { getOrComputeCachedValue } from "./cache.js";
-import { processTags } from "./tags.js";
 import { getHiddenTags } from "./hidden-tags.js";
+import { processTags } from "./tags.js";
 export const GROUPS_LIST_KIND = 10009;
 export const GROUP_MESSAGE_KIND = 9;
 /**
@@ -8,9 +8,12 @@ export const GROUP_MESSAGE_KIND = 9;
  * @throws
  */
 export function decodeGroupPointer(str) {
-    const [relay, id] = str.split("'");
+    let [relay, id] = str.split("'");
     if (!relay)
         throw new Error("Group pointer missing relay");
+    // Prepend wss:// if missing
+    if (!relay.match(/^wss?:/))
+        relay = `wss://${relay}`;
     return { relay, id: id || "_" };
 }
 /** Converts a group pointer into a group identifier */
@@ -20,6 +23,13 @@ export function encodeGroupPointer(pointer) {
 }
 export const GroupsPublicSymbol = Symbol.for("groups-public");
 export const GroupsHiddenSymbol = Symbol.for("groups-hidden");
+/** gets a {@link GroupPointer} from a "h" tag if it has a relay hint */
+export function getGroupPointerFromHTag(tag) {
+    const [_, id, relay] = tag;
+    if (!id || !relay)
+        return undefined;
+    return { id, relay };
+}
 /** gets a {@link GroupPointer} from a "group" tag */
 export function getGroupPointerFromGroupTag(tag) {
     const [_, id, relay, name] = tag;

package/dist/helpers/hidden-content.d.ts

@@ -1,18 +1,12 @@
-export declare const HiddenContentSymbol: unique symbol;
-export type HiddenContentSigner = {
-    nip04?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-    nip44?: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-    };
-};
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export declare const EventContentEncryptionMethod: Record<number, "nip04" | "nip44">;
-/** Sets the encryption method that is used for the contents of a specific event kind */
-export declare function setEventContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): void;
+import { EncryptedContentSigner, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
+export declare const HiddenContentSymbol: symbol;
+export interface HiddenContentSigner extends EncryptedContentSigner {
+}
+export declare const getHiddenContentEncryptionMethods: typeof getEncryptedContentEncryptionMethods;
+/** Various event kinds that can have hidden content */
+export declare const HiddenContentKinds: Set<number>;
+/** Sets the encryption method for hidden content on a kind */
+export declare function setHiddenContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
 /** Checks if an event can have hidden content */
 export declare function canHaveHiddenContent(kind: number): boolean;
 /** Checks if an event has hidden content */
@@ -20,29 +14,30 @@ export declare function hasHiddenContent<T extends {
     kind: number;
     content: string;
 }>(event: T): boolean;
-/** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenContent<T extends object>(event: T): string | undefined;
-/** Checks if the hidden tags are locked */
+/** Checks if the hidden content is locked */
 export declare function isHiddenContentLocked<T extends object>(event: T): boolean;
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export declare function getHiddenContentEncryptionMethods(kind: number, signer: HiddenContentSigner): {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
-export type HiddenContentEvent = {
+/** Returns the hidden content for an event if they are unlocked */
+export declare function getHiddenContent<T extends {
     kind: number;
-    pubkey: string;
     content: string;
-};
+}>(event: T): string | undefined;
 /**
- * Unlocks the encrypted content in an event
+ * Unlocks the hidden content in the event
  * @param event The event with content to decrypt
- * @param signer A signer to use to decrypt the tags
+ * @param signer A signer to use to decrypt the content
+ * @throws
+ */
+export declare function unlockHiddenContent<T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+}>(event: T, signer: EncryptedContentSigner): Promise<string>;
+/**
+ * Sets the hidden content on an event and updates it if its part of an event store
  * @throws
  */
-export declare function unlockHiddenContent<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string>;
+export declare function setHiddenContentCache<T extends {
+    kind: number;
+}>(event: T, plaintext: string): void;
 /** Removes the unencrypted hidden content on an event */
 export declare function lockHiddenContent<T extends object>(event: T): void;

package/dist/helpers/hidden-content.js

@@ -1,88 +1,58 @@
-import * as kinds from "nostr-tools/kinds";
-import { GROUPS_LIST_KIND } from "./groups.js";
-import { getParentEventStore, isEvent } from "./event.js";
-export const HiddenContentSymbol = Symbol.for("hidden-content");
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export const EventContentEncryptionMethod = {
-    // NIP-60 wallet
-    17375: "nip44",
-    375: "nip44",
-    7375: "nip44",
-    7376: "nip44",
-    // DMs
-    [kinds.EncryptedDirectMessage]: "nip04",
-    // Gift wraps
-    [kinds.GiftWrap]: "nip44",
-    // NIP-51 lists
-    [kinds.BookmarkList]: "nip04",
-    [kinds.InterestsList]: "nip04",
-    [kinds.Mutelist]: "nip04",
-    [kinds.CommunitiesList]: "nip04",
-    [kinds.PublicChatsList]: "nip04",
-    [kinds.SearchRelaysList]: "nip04",
-    [GROUPS_LIST_KIND]: "nip04",
-    // NIP-51 sets
-    [kinds.Bookmarksets]: "nip04",
-    [kinds.Relaysets]: "nip04",
-    [kinds.Followsets]: "nip04",
-    [kinds.Curationsets]: "nip04",
-    [kinds.Interestsets]: "nip04",
-};
-/** Sets the encryption method that is used for the contents of a specific event kind */
-export function setEventContentEncryptionMethod(kind, method) {
-    EventContentEncryptionMethod[kind] = method;
+import { kinds } from "nostr-tools";
+import { canHaveEncryptedContent, EncryptedContentSymbol, getEncryptedContent, getEncryptedContentEncryptionMethods, hasEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, setEncryptedContentCache, setEncryptedContentEncryptionMethod, } from "./encrypted-content.js";
+// reexport from encrypted-content
+export const HiddenContentSymbol = EncryptedContentSymbol;
+export const getHiddenContentEncryptionMethods = getEncryptedContentEncryptionMethods;
+/** Various event kinds that can have hidden content */
+export const HiddenContentKinds = new Set([setEncryptedContentEncryptionMethod(kinds.DraftLong, "nip04")]);
+/** Sets the encryption method for hidden content on a kind */
+export function setHiddenContentEncryptionMethod(kind, method) {
+    HiddenContentKinds.add(setEncryptedContentEncryptionMethod(kind, method));
+    return kind;
 }
 /** Checks if an event can have hidden content */
 export function canHaveHiddenContent(kind) {
-    return EventContentEncryptionMethod[kind] !== undefined;
+    return canHaveEncryptedContent(kind) && HiddenContentKinds.has(kind);
 }
 /** Checks if an event has hidden content */
 export function hasHiddenContent(event) {
-    return canHaveHiddenContent(event.kind) && event.content.length > 0;
+    return canHaveHiddenContent(event.kind) && hasEncryptedContent(event);
 }
-/** Returns the hidden tags for an event if they are unlocked */
-export function getHiddenContent(event) {
-    return Reflect.get(event, HiddenContentSymbol);
-}
-/** Checks if the hidden tags are locked */
+/** Checks if the hidden content is locked */
 export function isHiddenContentLocked(event) {
-    return Reflect.has(event, HiddenContentSymbol) === false;
+    return isEncryptedContentLocked(event);
 }
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export function getHiddenContentEncryptionMethods(kind, signer) {
-    const method = EventContentEncryptionMethod[kind];
-    const encryption = signer[method];
-    if (!encryption)
-        throw new Error(`Signer does not support ${method} encryption`);
-    return encryption;
+/** Returns the hidden content for an event if they are unlocked */
+export function getHiddenContent(event) {
+    if (!canHaveHiddenContent(event.kind) || isHiddenContentLocked(event))
+        return undefined;
+    return getEncryptedContent(event);
 }
 /**
- * Unlocks the encrypted content in an event
+ * Unlocks the hidden content in the event
  * @param event The event with content to decrypt
- * @param signer A signer to use to decrypt the tags
+ * @param signer A signer to use to decrypt the content
  * @throws
  */
 export async function unlockHiddenContent(event, signer) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
-    const encryption = getHiddenContentEncryptionMethods(event.kind, signer);
+    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
-    Reflect.set(event, HiddenContentSymbol, plaintext);
-    // if the event has been added to an event store, notify it
-    if (isEvent(event)) {
-        const eventStore = getParentEventStore(event);
-        if (eventStore)
-            eventStore.update(event);
-    }
+    setHiddenContentCache(event, plaintext);
     return plaintext;
 }
+/**
+ * Sets the hidden content on an event and updates it if its part of an event store
+ * @throws
+ */
+export function setHiddenContentCache(event, plaintext) {
+    if (!canHaveHiddenContent(event.kind))
+        throw new Error("Event kind does not support hidden content");
+    // Set the encrypted content
+    setEncryptedContentCache(event, plaintext);
+}
 /** Removes the unencrypted hidden content on an event */
 export function lockHiddenContent(event) {
-    Reflect.deleteProperty(event, HiddenContentSymbol);
-    // if the event has been added to an event store, notify it
-    if (isEvent(event)) {
-        const eventStore = getParentEventStore(event);
-        if (eventStore)
-            eventStore.update(event);
-    }
+    lockEncryptedContent(event);
 }

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

@@ -1,14 +1,21 @@
-import { HiddenContentEvent, HiddenContentSigner } from "./hidden-content.js";
+import { HiddenContentSigner } from "./hidden-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
+/** Various event kinds that can have hidden tags */
+export declare const HiddenTagsKinds: Set<number>;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
+/** Sets the type of encryption to use for hidden tags on a kind */
+export declare function setHiddenTagsEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
 /** Checks if an event has hidden tags */
 export declare function hasHiddenTags<T extends {
-    content: string;
     kind: number;
+    content: string;
 }>(event: T): boolean;
 /** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenTags<T extends object>(event: T): string[][] | undefined;
+export declare function getHiddenTags<T extends {
+    kind: number;
+    content: string;
+}>(event: T): string[][] | undefined;
 /** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
@@ -26,5 +33,17 @@ export declare function getHiddenTagsEncryptionMethods(kind: number, signer: Hid
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export declare function unlockHiddenTags<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+export declare function unlockHiddenTags<T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+}>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+/**
+ * Sets the hidden tags on an event and updates it if its part of an event store
+ * @throws
+ */
+export declare function setHiddenTagsCache<T extends {
+    kind: number;
+}>(event: T, tags: string[][]): void;
+/** Clears the cached hidden tags on an event */
 export declare function lockHiddenTags<T extends object>(event: T): void;

package/dist/helpers/hidden-tags.js

@@ -1,17 +1,41 @@
-import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, isHiddenContentLocked, lockHiddenContent, unlockHiddenContent, } from "./hidden-content.js";
+import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
+import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, hasHiddenContent, isHiddenContentLocked, lockHiddenContent, setHiddenContentCache, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
+import { GROUPS_LIST_KIND } from "./groups.js";
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
+/** Various event kinds that can have hidden tags */
+export const HiddenTagsKinds = new Set([
+    // NIP-51 lists
+    setHiddenContentEncryptionMethod(kinds.BookmarkList, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.InterestsList, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.Mutelist, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.CommunitiesList, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.PublicChatsList, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.SearchRelaysList, "nip04"),
+    setHiddenContentEncryptionMethod(GROUPS_LIST_KIND, "nip04"),
+    // NIP-51 sets
+    setHiddenContentEncryptionMethod(kinds.Bookmarksets, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.Relaysets, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.Followsets, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.Curationsets, "nip04"),
+    setHiddenContentEncryptionMethod(kinds.Interestsets, "nip04"),
+]);
 /** Checks if an event can have hidden tags */
 export function canHaveHiddenTags(kind) {
-    return canHaveHiddenContent(kind);
+    return canHaveHiddenContent(kind) && HiddenTagsKinds.has(kind);
+}
+/** Sets the type of encryption to use for hidden tags on a kind */
+export function setHiddenTagsEncryptionMethod(kind, method) {
+    HiddenTagsKinds.add(setHiddenContentEncryptionMethod(kind, method));
+    return kind;
 }
 /** Checks if an event has hidden tags */
 export function hasHiddenTags(event) {
-    return canHaveHiddenTags(event.kind) && event.content.length > 0;
+    return canHaveHiddenTags(event.kind) && hasHiddenContent(event);
 }
 /** Returns the hidden tags for an event if they are unlocked */
 export function getHiddenTags(event) {
-    if (isHiddenTagsLocked(event))
+    if (!canHaveHiddenTags(event.kind) || isHiddenTagsLocked(event))
         return undefined;
     return getOrComputeCachedValue(event, HiddenTagsSymbol, () => {
         const plaintext = getHiddenContent(event);
@@ -45,6 +69,17 @@ export async function unlockHiddenTags(event, signer) {
         await unlockHiddenContent(event, signer);
     return getHiddenTags(event);
 }
+/**
+ * Sets the hidden tags on an event and updates it if its part of an event store
+ * @throws
+ */
+export function setHiddenTagsCache(event, tags) {
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const plaintext = JSON.stringify(tags);
+    setHiddenContentCache(event, plaintext);
+}
+/** Clears the cached hidden tags on an event */
 export function lockHiddenTags(event) {
     Reflect.deleteProperty(event, HiddenTagsSymbol);
     lockHiddenContent(event);

package/dist/helpers/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./app-handlers.js";
+export * from "./article.js";
 export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
@@ -7,10 +9,13 @@ export * from "./comment.js";
 export * from "./contacts.js";
 export * from "./content.js";
 export * from "./delete.js";
-export * from "./direct-messages.js";
 export * from "./dns-identity.js";
 export * from "./emoji.js";
+export * from "./encrypted-content-cache.js";
+export * from "./encrypted-content.js";
+export * from "./encryption.js";
 export * from "./event.js";
+export * from "./expiration.js";
 export * from "./external-id.js";
 export * from "./file-metadata.js";
 export * from "./filter.js";
@@ -20,15 +25,19 @@ export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
 export * from "./json.js";
+export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";
+export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
 export * from "./profile.js";
+export * from "./reactions.js";
 export * from "./relays.js";
+export * from "./reports.js";
 export * from "./share.js";
 export * from "./string.js";
 export * from "./tags.js";
@@ -36,4 +45,5 @@ export * from "./threading.js";
 export * from "./time.js";
 export * from "./url.js";
 export * from "./user-status.js";
+export * from "./wrapped-messages.js";
 export * from "./zap.js";

package/dist/helpers/index.js

@@ -1,3 +1,5 @@
+export * from "./app-handlers.js";
+export * from "./article.js";
 export * from "./blossom.js";
 export * from "./bolt11.js";
 export * from "./bookmarks.js";
@@ -7,10 +9,13 @@ export * from "./comment.js";
 export * from "./contacts.js";
 export * from "./content.js";
 export * from "./delete.js";
-export * from "./direct-messages.js";
 export * from "./dns-identity.js";
 export * from "./emoji.js";
+export * from "./encrypted-content-cache.js";
+export * from "./encrypted-content.js";
+export * from "./encryption.js";
 export * from "./event.js";
+export * from "./expiration.js";
 export * from "./external-id.js";
 export * from "./file-metadata.js";
 export * from "./filter.js";
@@ -20,15 +25,19 @@ export * from "./hashtag.js";
 export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
 export * from "./json.js";
+export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";
+export * from "./messages.js";
 export * from "./mutes.js";
 export * from "./picture-post.js";
 export * from "./pointers.js";
 export * from "./profile.js";
+export * from "./reactions.js";
 export * from "./relays.js";
+export * from "./reports.js";
 export * from "./share.js";
 export * from "./string.js";
 export * from "./tags.js";
@@ -36,4 +45,5 @@ export * from "./threading.js";
 export * from "./time.js";
 export * from "./url.js";
 export * from "./user-status.js";
+export * from "./wrapped-messages.js";
 export * from "./zap.js";

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

@@ -0,0 +1,21 @@
+import { NostrEvent } from "nostr-tools";
+import { EncryptedContentSigner } from "./encrypted-content.js";
+/** Checks if a legacy direct message content is encrypted */
+export declare function isLegacyMessageLocked(event: NostrEvent): boolean;
+/**
+ * Returns the corraspondant of a legacy direct message
+ * @throws if no corraspondant is found
+ */
+export declare function getLegacyMessageCorraspondant(message: NostrEvent, self: string): string;
+/** Returns the parent message id of a legacy message */
+export declare function getLegacyMessageParent(message: NostrEvent): string | undefined;
+/**
+ * Returns the decrypted content of a direct message
+ * @param message - The message to decrypt
+ * @param self - The public key of the user
+ * @param signer - The signer to use to decrypt the message
+ * @returns The decrypted content of the message
+ */
+export declare function unlockLegacyMessage(message: NostrEvent, self: string, signer: EncryptedContentSigner): Promise<string>;
+/** Clears the cached plaintext of a direct message */
+export declare function lockLegacyMessage(message: NostrEvent): Promise<void>;

package/dist/helpers/legacy-messages.js

@@ -0,0 +1,39 @@
+import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
+import { getTagValue } from "./index.js";
+/** Checks if a legacy direct message content is encrypted */
+export function isLegacyMessageLocked(event) {
+    return isEncryptedContentLocked(event);
+}
+/**
+ * Returns the corraspondant of a legacy direct message
+ * @throws if no corraspondant is found
+ */
+export function getLegacyMessageCorraspondant(message, self) {
+    const corraspondant = message.pubkey === self ? getTagValue(message, "p") : message.pubkey;
+    if (!corraspondant)
+        throw new Error("No corraspondant found");
+    return corraspondant;
+}
+/** Returns the parent message id of a legacy message */
+export function getLegacyMessageParent(message) {
+    return getTagValue(message, "e");
+}
+/**
+ * Returns the decrypted content of a direct message
+ * @param message - The message to decrypt
+ * @param self - The public key of the user
+ * @param signer - The signer to use to decrypt the message
+ * @returns The decrypted content of the message
+ */
+export async function unlockLegacyMessage(message, self, signer) {
+    const cached = getEncryptedContent(message);
+    if (cached)
+        return cached;
+    const corraspondant = getLegacyMessageCorraspondant(message, self);
+    // Unlock the encrypted content
+    return await unlockEncryptedContent(message, corraspondant, signer);
+}
+/** Clears the cached plaintext of a direct message */
+export async function lockLegacyMessage(message) {
+    lockEncryptedContent(message);
+}

package/dist/helpers/lists.d.ts

@@ -1,5 +1,5 @@
-import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 export declare const FAVORITE_RELAYS_KIND = 10012;
 export type ReadListTags = "public" | "hidden" | "all";
 /** Returns all the tags of a list or set */