applesauce-core 3.1.0 → 4.0.0

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");

package/dist/helpers/mailboxes.d.ts

@@ -1,11 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export declare function getInboxes(event: NostrEvent): string[];
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -1,41 +1,47 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isRTag } from "./tags.js";
 import { normalizeURL } from "./url.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
-/**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export function getInboxes(event) {
     return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !inboxes.includes(url) &&
-                (mode === "read" || mode === undefined)) {
-                inboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [, url, mode] = tag;
+                if (url && isSafeRelayURL(url) && !inboxes.includes(url) && (mode === "read" || mode === undefined)) {
+                    inboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return inboxes;
     });
 }
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export function getOutboxes(event) {
     return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !outboxes.includes(url) &&
-                (mode === "write" || mode === undefined)) {
-                outboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [name, url, mode] = tag;
+                if (name === "r" &&
+                    isSafeRelayURL(url) &&
+                    !outboxes.includes(url) &&
+                    (mode === "write" || mode === undefined)) {
+                    outboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return outboxes;

package/dist/helpers/mutes.d.ts

@@ -1,6 +1,11 @@
 import { NostrEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./index.js";
 export declare const MutePublicSymbol: unique symbol;
 export declare const MuteHiddenSymbol: unique symbol;
+/** Type for unlocked mute events */
+export type UnlockedMutes = {
+    [MuteHiddenSymbol]: Mutes;
+};
 export type Mutes = {
     pubkeys: Set<string>;
     threads: Set<string>;
@@ -15,8 +20,13 @@ export declare function parseMutedTags(tags: string[][]): Mutes;
 export declare function getMutedThings(mute: NostrEvent): Mutes;
 /** Returns only the public muted things from a mute event */
 export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
+/** Checks if the hidden mutes are unlocked */
+export declare function isHiddenMutesUnlocked<T extends NostrEvent>(mute: T): mute is T & UnlockedMutes;
 /** Returns the hidden muted content if the event is unlocked */
-export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;
+export declare function getHiddenMutedThings<T extends NostrEvent & UnlockedMutes>(mute: T): Mutes;
+export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): Mutes | undefined;
+/** Unlocks the hidden mutes */
+export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<Mutes>;
 /** Creates a RegExp for matching muted words */
 export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
 /** Returns true if the event matches the mutes */

package/dist/helpers/mutes.js

@@ -1,7 +1,7 @@
 import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
-import { getIndexableTags, getNip10References } from "./index.js";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "./hidden-tags.js";
+import { getIndexableTags, getNip10References, notifyEventUpdate } from "./index.js";
 import { isETag, isPTag, isTTag } from "./tags.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
@@ -40,11 +40,36 @@ export function getMutedThings(mute) {
 export function getPublicMutedThings(mute) {
     return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
 }
-/** Returns the hidden muted content if the event is unlocked */
+/** Checks if the hidden mutes are unlocked */
+export function isHiddenMutesUnlocked(mute) {
+    return isHiddenTagsUnlocked(mute) && Reflect.has(mute, MuteHiddenSymbol);
+}
 export function getHiddenMutedThings(mute) {
-    if (isHiddenTagsLocked(mute))
+    if (isHiddenMutesUnlocked(mute))
+        return mute[MuteHiddenSymbol];
+    // get hidden tags
+    const tags = getHiddenTags(mute);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => parseMutedTags(getHiddenTags(mute)));
+    // parse muted tags
+    const mutes = parseMutedTags(tags);
+    // set cached value
+    Reflect.set(mute, MuteHiddenSymbol, mutes);
+    return mutes;
+}
+/** Unlocks the hidden mutes */
+export async function unlockHiddenMutes(mute, signer) {
+    if (isHiddenMutesUnlocked(mute))
+        return mute[MuteHiddenSymbol];
+    // Unlock hidden tags
+    await unlockHiddenTags(mute, signer);
+    // get hidden mutes
+    const mutes = getHiddenMutedThings(mute);
+    if (!mutes)
+        throw new Error("Failed to unlock hidden mutes");
+    // Notify event store
+    notifyEventUpdate(mute);
+    return mutes;
 }
 /** Creates a RegExp for matching muted words */
 export function createMutedWordsRegExp(mutedWords) {

package/dist/helpers/picture-post.d.ts

@@ -1,4 +1,5 @@
 import { NostrEvent } from "nostr-tools";
+import { FileMetadata } from "./file-metadata.js";
 export declare const PICTURE_POST_KIND = 20;
 /** Return the media attachments from a kind 20 media post */
-export declare function getPicturePostAttachments(post: NostrEvent): import("./file-metadata.js").FileMetadata[];
+export declare function getPicturePostAttachments(post: NostrEvent): FileMetadata[];

package/dist/helpers/pointers.d.ts

@@ -15,7 +15,7 @@ export declare function parseCoordinate(a: string, requireD: false, silent: true
 /** Extra a pubkey from the result of nip19.decode */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
 /** Encodes the result of nip19.decode */
-export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1${string}` | `naddr1${string}` | `nprofile1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
 /**
  * Gets an EventPointer form a common "e" tag
  * @throws

package/dist/helpers/pointers.js

@@ -5,6 +5,7 @@ import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { hexToBytes } from "@noble/hashes/utils";
+import { normalizeURL } from "./url.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -117,7 +118,7 @@ export function getProfilePointerFromPTag(tag) {
         throw new Error("Invalid pubkey");
     const pointer = { pubkey: tag[1] };
     if (tag[2] && isSafeRelayURL(tag[2]))
-        pointer.relays = [tag[2]];
+        pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
 /** Checks if a pointer is an AddressPointer */