applesauce-core 3.1.0 → 4.1.0

package/dist/helpers/gift-wraps.js

@@ -1,12 +1,12 @@
-import { verifyEvent } from "nostr-tools";
-import { EventSet } from "../event-store/event-set.js";
-import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
+import { kinds, verifyEvent } from "nostr-tools";
+import { EventMemory } from "../event-store/event-memory.js";
+import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
 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
+ * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export const internalGiftWrapEvents = new EventSet();
+export const internalGiftWrapEvents = new EventMemory();
 /** 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) */
@@ -40,7 +40,6 @@ export function isRumor(event) {
         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);
 }
@@ -64,21 +63,37 @@ export function getRumorGiftWraps(rumor) {
     }
     return Array.from(giftWraps);
 }
-/** Checks if a seal event is locked */
-export function isSealLocked(seal) {
-    return isEncryptedContentLocked(seal);
+/** Checks if a seal event is locked and casts it to the {@link UnlockedSeal} type */
+export function isSealUnlocked(seal) {
+    return isEncryptedContentUnlocked(seal) === true && Reflect.has(seal, RumorSymbol) === true;
+}
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export function isGiftWrapUnlocked(gift) {
+    if (isEncryptedContentUnlocked(gift) === false)
+        return false;
+    // Get the seal event
+    const seal = getGiftWrapSeal(gift);
+    if (!seal)
+        return false;
+    // If seal is locked, return false
+    if (!isSealUnlocked(seal))
+        return false;
+    return true;
 }
-/** Gets the rumor from a seal event */
 export function getSealRumor(seal) {
-    // Returned cached rumor if it exists (downstream)
-    const cached = Reflect.get(seal, RumorSymbol);
-    if (cached)
-        return cached;
+    // Non seal events cant have rumors
+    if (seal.kind !== kinds.Seal)
+        return undefined;
+    // If unlocked return the rumor
+    if (isSealUnlocked(seal))
+        return seal[RumorSymbol];
     // Get the encrypted content plaintext
-    const plaintext = getEncryptedContent(seal);
-    if (!plaintext)
+    const content = getEncryptedContent(seal);
+    // Return undefined if the content is not found
+    if (!content)
         return undefined;
-    let rumor = JSON.parse(plaintext);
+    // Parse the content as a rumor event
+    let rumor = JSON.parse(content);
     // Check if the rumor event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(rumor.id);
     if (existing)
@@ -87,23 +102,26 @@ export function getSealRumor(seal) {
     else
         // Add to the internal event set
         internalGiftWrapEvents.add(rumor);
+    // Throw an error if the seal and rumor authors do not match
+    if (rumor.pubkey !== seal.pubkey)
+        throw new Error("Seal author does not match rumor author");
     // Save a reference to the parent seal event
     addParentSealReference(rumor, seal);
-    // Save a reference to the rumor on the seal (downstream)
+    // Cache the rumor event
     Reflect.set(seal, RumorSymbol, rumor);
     return rumor;
 }
-/** 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)
+    if (Reflect.has(gift, SealSymbol))
+        return Reflect.get(gift, SealSymbol);
+    // Get the encrypted content
+    const content = getEncryptedContent(gift);
+    // Return undefined if the content is not found
+    if (!content)
         return undefined;
-    let seal = JSON.parse(plaintext);
+    // Parse seal as nostr event
+    let seal = JSON.parse(content);
     // Check if the seal event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(seal.id);
     if (existing) {
@@ -122,39 +140,27 @@ export function getGiftWrapSeal(gift) {
     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)
         return undefined;
     return getSealRumor(seal);
 }
-/** Returns if a gift-wrap event or gift-wrap seal is locked */
-export function isGiftWrapLocked(gift) {
-    if (isEncryptedContentLocked(gift))
-        return true;
-    else {
-        const seal = getGiftWrapSeal(gift);
-        if (!seal || isSealLocked(seal))
-            return true;
-        else
-            return false;
-    }
-}
 /**
  * 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
+    // If already unlocked, return the rumor
+    if (isSealUnlocked(seal))
+        return seal[RumorSymbol];
+    // unlock encrypted content as needed
+    await unlockEncryptedContent(seal, seal.pubkey, signer);
     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");
+    // Notify event store
+    notifyEventUpdate(seal);
     return rumor;
 }
 /**
@@ -162,11 +168,13 @@ export async function unlockSeal(seal, signer) {
  * @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);
-    // Get the seal event
-    const seal = getGiftWrapSeal(gift);
+    // If already unlocked, return the rumor
+    if (isGiftWrapUnlocked(gift))
+        return getGiftWrapRumor(gift);
+    // Unlock the encrypted content
+    await unlockEncryptedContent(gift, gift.pubkey, signer);
+    // Parse seal as nostr event
+    let seal = getGiftWrapSeal(gift);
     if (!seal)
         throw new Error("Failed to read seal in gift wrap");
     // Unlock the seal event
@@ -175,6 +183,7 @@ export async function unlockGiftWrap(gift, signer) {
     notifyEventUpdate(gift);
     return rumor;
 }
+/** Locks a gift-wrap event and seals its seal event */
 export function lockGiftWrap(gift) {
     const seal = getGiftWrapSeal(gift);
     if (seal) {

package/dist/helpers/groups.d.ts

@@ -10,11 +10,8 @@ export type GroupPointer = {
     /** The name of the group */
     name?: string;
 };
-/**
- * decodes a group identifier into a group pointer object
- * @throws
- */
-export declare function decodeGroupPointer(str: string): GroupPointer;
+/** decodes a group identifier into a group pointer object */
+export declare function decodeGroupPointer(str: string): GroupPointer | null;
 /** Converts a group pointer into a group identifier */
 export declare function encodeGroupPointer(pointer: GroupPointer): string;
 export declare const GroupsPublicSymbol: unique symbol;

package/dist/helpers/groups.js

@@ -4,14 +4,11 @@ import { processTags } from "./tags.js";
 import { normalizeURL } from "./url.js";
 export const GROUPS_LIST_KIND = 10009;
 export const GROUP_MESSAGE_KIND = 9;
-/**
- * decodes a group identifier into a group pointer object
- * @throws
- */
+/** decodes a group identifier into a group pointer object */
 export function decodeGroupPointer(str) {
     let [relay, id] = str.split("'");
     if (!relay)
-        throw new Error("Group pointer missing relay");
+        return null;
     // Prepend wss:// if missing
     if (!relay.match(/^wss?:/))
         relay = `wss://${relay}`;

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

@@ -1,8 +1,13 @@
-import { EncryptedContentSigner, EncryptionMethod, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
+import { EncryptedContentSigner, EncryptionMethod, getEncryptedContentEncryptionMethods, UnlockedEncryptedContent } from "./encrypted-content.js";
+/** Symbol for caching hidden content. Alias for {@link EncryptedContentSymbol} */
 export declare const HiddenContentSymbol: symbol;
+/** Alias for {@link EncryptedContentSigner} */
 export interface HiddenContentSigner extends EncryptedContentSigner {
 }
+/** Alias for {@link getEncryptedContentEncryptionMethods} */
 export declare const getHiddenContentEncryptionMethods: typeof getEncryptedContentEncryptionMethods;
+/** Type for events with unlocked hidden content. alias for {@link UnlockedEncryptedContent} */
+export type UnlockedHiddenContent = UnlockedEncryptedContent;
 /** Various event kinds that can have hidden content */
 export declare const HiddenContentKinds: Set<number>;
 /** Sets the encryption method for hidden content on a kind */
@@ -14,12 +19,16 @@ export declare function hasHiddenContent<T extends {
     kind: number;
     content: string;
 }>(event: T): boolean;
-/** Checks if the hidden content is locked */
-export declare function isHiddenContentLocked<T extends object>(event: T): boolean;
+/** Checks if the hidden content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export declare function isHiddenContentUnlocked<T extends {
+    kind: number;
+}>(event: T): event is T & UnlockedEncryptedContent;
 /** Returns the hidden content for an event if they are unlocked */
 export declare function getHiddenContent<T extends {
     kind: number;
-    content: string;
+} & UnlockedHiddenContent>(event: T): string;
+export declare function getHiddenContent<T extends {
+    kind: number;
 }>(event: T): string | undefined;
 /**
  * Unlocks the hidden content in the event
@@ -34,7 +43,7 @@ export declare function unlockHiddenContent<T extends {
 }>(event: T, signer: EncryptedContentSigner, override?: EncryptionMethod): Promise<string>;
 /**
  * Sets the hidden content on an event and updates it if its part of an event store
- * @throws
+ * @throws If the event kind does not support hidden content
  */
 export declare function setHiddenContentCache<T extends {
     kind: number;

package/dist/helpers/hidden-content.js

@@ -1,7 +1,8 @@
 import { kinds } from "nostr-tools";
-import { canHaveEncryptedContent, EncryptedContentSymbol, getEncryptedContent, getEncryptedContentEncryptionMethods, hasEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, setEncryptedContentCache, setEncryptedContentEncryptionMethod, } from "./encrypted-content.js";
-// reexport from encrypted-content
+import { canHaveEncryptedContent, EncryptedContentSymbol, getEncryptedContent, getEncryptedContentEncryptionMethods, hasEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, setEncryptedContentCache, setEncryptedContentEncryptionMethod, } from "./encrypted-content.js";
+/** Symbol for caching hidden content. Alias for {@link EncryptedContentSymbol} */
 export const HiddenContentSymbol = EncryptedContentSymbol;
+/** Alias for {@link getEncryptedContentEncryptionMethods} */
 export const getHiddenContentEncryptionMethods = getEncryptedContentEncryptionMethods;
 /** Various event kinds that can have hidden content */
 export const HiddenContentKinds = new Set([setEncryptedContentEncryptionMethod(kinds.DraftLong, "nip04")]);
@@ -18,14 +19,17 @@ export function canHaveHiddenContent(kind) {
 export function hasHiddenContent(event) {
     return canHaveHiddenContent(event.kind) && hasEncryptedContent(event);
 }
-/** Checks if the hidden content is locked */
-export function isHiddenContentLocked(event) {
-    return isEncryptedContentLocked(event);
+/** Checks if the hidden content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export function isHiddenContentUnlocked(event) {
+    if (!canHaveHiddenContent(event.kind))
+        return false;
+    return isEncryptedContentUnlocked(event) && Reflect.has(event, HiddenContentSymbol) === true;
 }
-/** Returns the hidden content for an event if they are unlocked */
 export function getHiddenContent(event) {
-    if (!canHaveHiddenContent(event.kind) || isHiddenContentLocked(event))
+    if (!canHaveHiddenContent(event.kind))
         return undefined;
+    if (isHiddenContentUnlocked(event))
+        return event[EncryptedContentSymbol];
     return getEncryptedContent(event);
 }
 /**
@@ -37,14 +41,21 @@ export function getHiddenContent(event) {
 export async function unlockHiddenContent(event, signer, override) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
+    // If the encrypted content is already unlocked, return the cached value
+    if (isEncryptedContentUnlocked(event))
+        return event[EncryptedContentSymbol];
+    // Get the encryption method from the signer
     const encryption = getEncryptedContentEncryptionMethods(event.kind, signer, override);
+    // Decrypt the content using the events pubkey
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
+    // Set the cached value
     setHiddenContentCache(event, plaintext);
+    // Return the decrypted content
     return plaintext;
 }
 /**
  * Sets the hidden content on an event and updates it if its part of an event store
- * @throws
+ * @throws If the event kind does not support hidden content
  */
 export function setHiddenContentCache(event, plaintext) {
     if (!canHaveHiddenContent(event.kind))

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

@@ -1,6 +1,11 @@
-import { HiddenContentSigner } from "./hidden-content.js";
 import { EncryptionMethod } from "./encrypted-content.js";
+import { HiddenContentSigner, UnlockedHiddenContent } from "./hidden-content.js";
+/** Symbol for caching hidden tags. */
 export declare const HiddenTagsSymbol: unique symbol;
+/** Type for events with unlocked hidden tags */
+export type UnlockedHiddenTags = UnlockedHiddenContent & {
+    [HiddenTagsSymbol]: string[][];
+};
 /** Various event kinds that can have hidden tags */
 export declare const HiddenTagsKinds: Set<number>;
 /** Checks if an event can have hidden tags */
@@ -12,15 +17,19 @@ export declare function hasHiddenTags<T extends {
     kind: number;
     content: string;
 }>(event: T): boolean;
+/** Returns either nip04 or nip44 encryption method depending on list kind */
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): import("./encrypted-content.js").EncryptionMethods;
+/** Checks if the hidden tags are locked and casts it to the {@link UnlockedHiddenTags} type */
+export declare function isHiddenTagsUnlocked<T extends {
+    kind: number;
+}>(event: T): event is T & UnlockedHiddenTags;
 /** Returns the hidden tags for an event if they are unlocked */
 export declare function getHiddenTags<T extends {
     kind: number;
-    content: string;
+} & UnlockedHiddenTags>(event: T): string[][];
+export declare function getHiddenTags<T extends {
+    kind: number;
 }>(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 */
-export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): import("./encrypted-content.js").EncryptionMethods;
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
@@ -35,7 +44,7 @@ export declare function unlockHiddenTags<T extends {
 }>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<string[][]>;
 /**
  * Sets the hidden tags on an event and updates it if its part of an event store
- * @throws
+ * @throws If the event kind does not support hidden tags
  */
 export declare function setHiddenTagsCache<T extends {
     kind: number;

package/dist/helpers/hidden-tags.js

@@ -1,7 +1,7 @@
 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";
+import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, hasHiddenContent, isHiddenContentUnlocked, lockHiddenContent, setHiddenContentCache, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "./hidden-content.js";
+/** Symbol for caching hidden tags. */
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
 /** Various event kinds that can have hidden tags */
 export const HiddenTagsKinds = new Set([
@@ -33,27 +33,38 @@ export function setHiddenTagsEncryptionMethod(kind, method) {
 export function hasHiddenTags(event) {
     return canHaveHiddenTags(event.kind) && hasHiddenContent(event);
 }
-/** Returns the hidden tags for an event if they are unlocked */
-export function getHiddenTags(event) {
-    if (!canHaveHiddenTags(event.kind) || isHiddenTagsLocked(event))
-        return undefined;
-    return getOrComputeCachedValue(event, HiddenTagsSymbol, () => {
-        const plaintext = getHiddenContent(event);
-        const parsed = JSON.parse(plaintext);
-        if (!Array.isArray(parsed))
-            throw new Error("Content is not an array of tags");
-        // Convert array to tags array string[][]
-        return parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
-    });
-}
-/** Checks if the hidden tags are locked */
-export function isHiddenTagsLocked(event) {
-    return isHiddenContentLocked(event);
-}
 /** Returns either nip04 or nip44 encryption method depending on list kind */
 export function getHiddenTagsEncryptionMethods(kind, signer) {
     return getHiddenContentEncryptionMethods(kind, signer);
 }
+/** Checks if the hidden tags are locked and casts it to the {@link UnlockedHiddenTags} type */
+export function isHiddenTagsUnlocked(event) {
+    if (!canHaveHiddenTags(event.kind))
+        return false;
+    return isHiddenContentUnlocked(event) && Reflect.has(event, `HiddenTagsSymbol`);
+}
+export function getHiddenTags(event) {
+    if (!canHaveHiddenTags(event.kind))
+        return undefined;
+    // If the hidden tags are already unlocked, return the cached value
+    if (isHiddenTagsUnlocked(event))
+        return event[HiddenTagsSymbol];
+    // unlock hidden content is needed
+    const content = getHiddenContent(event);
+    // Return undefined if the hidden content is not unlocked
+    if (content === undefined)
+        return undefined;
+    // Parse the hidden content as an array of tags
+    const parsed = JSON.parse(content);
+    // Throw error if content is not an array of tags
+    if (!Array.isArray(parsed))
+        throw new Error("Content is not an array of tags");
+    // Convert array to tags array string[][]
+    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
+    // Set the cached value
+    Reflect.set(event, HiddenTagsSymbol, tags);
+    return tags;
+}
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
@@ -64,20 +75,30 @@ export function getHiddenTagsEncryptionMethods(kind, signer) {
 export async function unlockHiddenTags(event, signer, override) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
-    // unlock hidden content is needed
-    if (isHiddenContentLocked(event))
-        await unlockHiddenContent(event, signer, override);
-    return getHiddenTags(event);
+    // Return the cached value if the hidden tags are already unlocked
+    if (isHiddenTagsUnlocked(event))
+        return event[HiddenTagsSymbol];
+    // Unlock hidden content
+    await unlockHiddenContent(event, signer, override);
+    // Parse the hidden tags
+    const tags = getHiddenTags(event);
+    if (tags === undefined)
+        throw new Error("Failed to unlock hidden tags");
+    // Set cache an notify event store
+    setHiddenTagsCache(event, tags);
+    return tags;
 }
 /**
  * Sets the hidden tags on an event and updates it if its part of an event store
- * @throws
+ * @throws If the event kind does not support hidden tags
  */
 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);
+    // Set the cached value
+    Reflect.set(event, HiddenTagsSymbol, tags);
+    // Set the cached content
+    setHiddenContentCache(event, JSON.stringify(tags));
 }
 /** Clears the cached hidden tags on an event */
 export function lockHiddenTags(event) {

package/dist/helpers/index.d.ts

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

package/dist/helpers/index.js

@@ -43,6 +43,7 @@ export * from "./pointers.js";
 export * from "./poll.js";
 export * from "./profile.js";
 export * from "./reactions.js";
+export * from "./relay-selection.js";
 export * from "./relays.js";
 export * from "./reports.js";
 export * from "./share.js";

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

@@ -1,21 +1,25 @@
-import { NostrEvent } from "nostr-tools";
-import { EncryptedContentSigner } from "./encrypted-content.js";
+import { kinds, NostrEvent } from "nostr-tools";
+import { EncryptedContentSigner, UnlockedEncryptedContent } from "./encrypted-content.js";
+import { KnownEvent } from "./index.js";
+/** Type for valid legacy direct messages */
+export type LegacyMessage = KnownEvent<kinds.EncryptedDirectMessage>;
+/** Type for a legacy direct message with unlocked encrypted content */
+export type UnlockedLegacyMessage = LegacyMessage & UnlockedEncryptedContent;
 /** 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 receiver of a legacy direct message
- * @throws if no receiver is found
- */
-export declare const getLegacyMessageReceiver: typeof getLegacyMessageCorraspondant;
+export declare function isLegacyMessageUnlocked<T extends NostrEvent>(event: T): event is T & UnlockedEncryptedContent;
+/** Returns the correspondent of a legacy direct message */
+export declare function getLegacyMessageCorrespondent<T extends LegacyMessage>(message: T, self: string): string;
+export declare function getLegacyMessageCorrespondent<T extends NostrEvent>(message: T, self: string): string | undefined;
+/** Returns the receiver of a legacy direct me */
+export declare const getLegacyMessageReceiver: typeof getLegacyMessageCorrespondent;
+/** @deprecated use {@link getLegacyMessageCorrespondent} instead */
+export declare const getLegacyMessageCorraspondant: typeof getLegacyMessageCorrespondent;
 /** Returns the sender of a legacy direct message */
 export declare function getLegacyMessageSender(message: NostrEvent): string;
 /** Returns the parent message id of a legacy message */
 export declare function getLegacyMessageParent(message: NostrEvent): string | undefined;
+/** Checks if a legacy message is valid */
+export declare function isValidLegacyMessage(event: any): event is LegacyMessage;
 /**
  * Returns the decrypted content of a direct message
  * @param message - The message to decrypt

package/dist/helpers/legacy-messages.js

@@ -1,24 +1,17 @@
-import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
+import { kinds } from "nostr-tools";
+import { getEncryptedContent, isEncryptedContentUnlocked, 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);
+export function isLegacyMessageUnlocked(event) {
+    return isEncryptedContentUnlocked(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;
+export function getLegacyMessageCorrespondent(message, self) {
+    return message.pubkey === self ? getTagValue(message, "p") : message.pubkey;
 }
-/**
- * Returns the receiver of a legacy direct message
- * @throws if no receiver is found
- */
-export const getLegacyMessageReceiver = getLegacyMessageCorraspondant;
+/** Returns the receiver of a legacy direct me */
+export const getLegacyMessageReceiver = getLegacyMessageCorrespondent;
+/** @deprecated use {@link getLegacyMessageCorrespondent} instead */
+export const getLegacyMessageCorraspondant = getLegacyMessageCorrespondent;
 /** Returns the sender of a legacy direct message */
 export function getLegacyMessageSender(message) {
     return message.pubkey;
@@ -27,6 +20,12 @@ export function getLegacyMessageSender(message) {
 export function getLegacyMessageParent(message) {
     return getTagValue(message, "e");
 }
+/** Checks if a legacy message is valid */
+export function isValidLegacyMessage(event) {
+    return (event.kind === kinds.EncryptedDirectMessage &&
+        getLegacyMessageCorrespondent(event, event.pubkey) !== undefined &&
+        event.content.length > 0);
+}
 /**
  * Returns the decrypted content of a direct message
  * @param message - The message to decrypt
@@ -38,9 +37,12 @@ export async function unlockLegacyMessage(message, self, signer) {
     const cached = getEncryptedContent(message);
     if (cached)
         return cached;
-    const corraspondant = getLegacyMessageCorraspondant(message, self);
+    // Get the correspondent
+    const correspondent = getLegacyMessageCorrespondent(message, self);
+    if (!correspondent)
+        throw new Error("No correspondent found");
     // Unlock the encrypted content
-    return await unlockEncryptedContent(message, corraspondant, signer);
+    return await unlockEncryptedContent(message, correspondent, signer);
 }
 /** Clears the cached plaintext of a direct message */
 export async function lockLegacyMessage(message) {

package/dist/helpers/lists.js

@@ -97,7 +97,8 @@ export function isValidList(event) {
         if (isAddressableKind(event.kind)) {
             // event is a set
             // ensure the set has an identifier
-            getReplaceableIdentifier(event);
+            if (!getReplaceableIdentifier(event))
+                return false;
             return true;
         }
         else if (isReplaceableKind(event.kind) && event.kind >= 10000 && event.kind < 20000) {

package/dist/helpers/lnurl.d.ts

@@ -1,4 +1,8 @@
+/** Parses a lightning address (lud16) into a LNURLp */
 export declare function parseLightningAddress(address: string): URL | undefined;
+/** Parses a LNURLp into a URL */
 export declare function decodeLNURL(lnurl: string): URL | undefined;
+/** Parses a lightning address or LNURLp into a URL */
 export declare function parseLNURLOrAddress(addressOrLNURL: string): URL | undefined;
+/** Requests a bolt11 invoice from a LNURLp callback URL */
 export declare function getInvoice(callback: URL): Promise<string>;

package/dist/helpers/lnurl.js

@@ -1,12 +1,14 @@
 import { bech32 } from "@scure/base";
 import { parseBolt11 } from "./bolt11.js";
 const decoder = new TextDecoder();
+/** Parses a lightning address (lud16) into a LNURLp */
 export function parseLightningAddress(address) {
     let [name, domain] = address.split("@");
     if (!name || !domain)
         return;
     return new URL(`https://${domain}/.well-known/lnurlp/${name}`);
 }
+/** Parses a LNURLp into a URL */
 export function decodeLNURL(lnurl) {
     try {
         const { words, prefix } = bech32.decode(lnurl);
@@ -18,12 +20,14 @@ export function decodeLNURL(lnurl) {
     catch (error) { }
     return undefined;
 }
+/** Parses a lightning address or LNURLp into a URL */
 export function parseLNURLOrAddress(addressOrLNURL) {
-    if (addressOrLNURL.includes("@")) {
+    if (addressOrLNURL.includes("@"))
         return parseLightningAddress(addressOrLNURL);
-    }
-    return decodeLNURL(addressOrLNURL);
+    else
+        return decodeLNURL(addressOrLNURL);
 }
+/** Requests a bolt11 invoice from a LNURLp callback URL */
 export async function getInvoice(callback) {
     const { pr: payRequest } = await fetch(callback).then((res) => res.json());
     const amount = callback.searchParams.get("amount");