applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/helpers/groups.d.ts

@@ -1,7 +1,20 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
-import { NameValueTag } from "applesauce-core/helpers/tags";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
 export declare const GROUPS_LIST_KIND = 10009;
 export declare const GROUP_MESSAGE_KIND = 9;
+export declare const GROUP_METADATA_KIND = 39000;
+export declare const GROUP_ADMINS_KIND = 39001;
+export declare const GROUP_MEMBERS_KIND = 39002;
+export declare const GROUP_ROLES_KIND = 39003;
+export declare const JOIN_REQUEST_KIND = 9021;
+export declare const LEAVE_REQUEST_KIND = 9022;
+export declare const PUT_USER_KIND = 9000;
+export declare const REMOVE_USER_KIND = 9001;
+export declare const EDIT_METADATA_KIND = 9002;
+export declare const DELETE_EVENT_KIND = 9005;
+export declare const CREATE_GROUP_KIND = 9007;
+export declare const DELETE_GROUP_KIND = 9008;
+export declare const CREATE_INVITE_KIND = 9009;
 /** NIP-29 group pointer */
 export type GroupPointer = {
     /** the id of the group */
@@ -18,16 +31,125 @@ 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;
+export declare function getGroupPointerFromHTag(tag: string[], hint?: 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 */
 export declare function getPublicGroups(bookmark: NostrEvent): GroupPointer[];
+/** Type for unlocked groups */
+export type UnlockedGroups = {
+    [GroupsHiddenSymbol]: GroupPointer[];
+};
 /** Returns all the hidden groups from a k:10009 list */
-export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;
+export declare function getHiddenGroups<T extends NostrEvent & UnlockedGroups>(bookmark: T): GroupPointer[];
+export declare function getHiddenGroups<T extends NostrEvent>(bookmark: T): GroupPointer[] | undefined;
+/** Checks if the hidden groups are unlocked */
+export declare function isHiddenGroupsUnlocked<T extends NostrEvent>(bookmark: T): bookmark is T & UnlockedGroups;
+/** Unlocks the hidden groups on a groups event */
+export declare function unlockHiddenGroups(bookmark: NostrEvent, signer: HiddenContentSigner): Promise<GroupPointer[]>;
+/** Gets a {@link GroupPointer} from a group event by reading the "h" tag */
+export declare function getGroupPointer(event: NostrEvent, relay?: string): GroupPointer | undefined;
+/** Gets the group id from a group event by reading the "h" tag */
+export declare function getGroupId(event: NostrEvent): string | undefined;
 /** Gets a {@link GroupPointer} from a kind 39000 group metadata event */
 export declare function getGroupPointerFromMetadata(event: NostrEvent, relay: string): GroupPointer | undefined;
-/** Creates a "h" tag for chat messages from a {@link GroupPointer} */
-export declare function createGroupHTagFromGroupPointer(group: GroupPointer): NameValueTag;
-/** Creates a "group" tag from a {@link GroupPointer} */
-export declare function createGroupTagFromGroupPointer(group: GroupPointer): NameValueTag;
+/** Group metadata structure from kind 39000 */
+export type GroupMetadata = {
+    id: string;
+    name?: string;
+    picture?: string;
+    about?: string;
+    isPublic: boolean;
+    isPrivate: boolean;
+    isOpen: boolean;
+    isClosed: boolean;
+};
+/** Group admin with roles from kind 39001 */
+export type GroupAdmin = {
+    pubkey: string;
+    roles: string[];
+};
+/** Group role definition from kind 39003 */
+export type GroupRole = {
+    name: string;
+    description?: string;
+};
+/** Join request event information (kind 9021) */
+export type GroupJoinRequestInfo = {
+    groupId: string;
+    reason?: string;
+    inviteCode?: string;
+};
+/** Leave request event information (kind 9022) */
+export type GroupLeaveRequestInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Put user event information (kind 9000) */
+export type GroupPutUserInfo = {
+    groupId: string;
+    pubkey: string;
+    roles?: string[];
+    reason?: string;
+};
+/** Remove user event information (kind 9001) */
+export type GroupRemoveUserInfo = {
+    groupId: string;
+    pubkey: string;
+    reason?: string;
+};
+/** Edit metadata event information (kind 9002) */
+export type GroupEditMetadataInfo = {
+    groupId: string;
+    metadataFields: Partial<GroupMetadata>;
+    reason?: string;
+};
+/** Delete event information (kind 9005) */
+export type GroupDeleteEventInfo = {
+    groupId: string;
+    eventId: string;
+    reason?: string;
+};
+/** Create group event information (kind 9007) */
+export type GroupCreateGroupInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Delete group event information (kind 9008) */
+export type GroupDeleteGroupInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Create invite event information (kind 9009) */
+export type GroupCreateInviteInfo = {
+    groupId: string;
+    reason?: string;
+};
+/** Gets group metadata from a kind 39000 event */
+export declare function getGroupMetadata(event: NostrEvent): GroupMetadata | undefined;
+/** Gets group admins from a kind 39001 event */
+export declare function getGroupAdmins(event: NostrEvent): GroupAdmin[] | undefined;
+/** Gets group members from a kind 39002 event */
+export declare function getGroupMembers(event: NostrEvent): string[] | undefined;
+/** Gets group roles from a kind 39003 event */
+export declare function getGroupRoles(event: NostrEvent): GroupRole[] | undefined;
+/** Gets join request information from a kind 9021 event */
+export declare function getGroupJoinRequestInfo(event: NostrEvent): GroupJoinRequestInfo | undefined;
+/** Gets leave request information from a kind 9022 event */
+export declare function getGroupLeaveRequestInfo(event: NostrEvent): GroupLeaveRequestInfo | undefined;
+/** Gets put user event information from a kind 9000 event */
+export declare function getGroupPutUserInfo(event: NostrEvent): GroupPutUserInfo | undefined;
+/** Gets remove user event information from a kind 9001 event */
+export declare function getGroupRemoveUserInfo(event: NostrEvent): GroupRemoveUserInfo | undefined;
+/** Gets edit metadata event information from a kind 9002 event */
+export declare function getGroupEditMetadataInfo(event: NostrEvent): GroupEditMetadataInfo | undefined;
+/** Gets delete event information from a kind 9005 event */
+export declare function getGroupDeleteEventInfo(event: NostrEvent): GroupDeleteEventInfo | undefined;
+/** Gets create group event information from a kind 9007 event */
+export declare function getGroupCreateGroupInfo(event: NostrEvent): GroupCreateGroupInfo | undefined;
+/** Gets delete group event information from a kind 9008 event */
+export declare function getGroupDeleteGroupInfo(event: NostrEvent): GroupDeleteGroupInfo | undefined;
+/** Gets create invite event information from a kind 9009 event */
+export declare function getGroupCreateInviteInfo(event: NostrEvent): GroupCreateInviteInfo | undefined;
+/** Checks group membership status from kind 9000/9001 events */
+export declare function checkGroupMembership(events: NostrEvent[], pubkey: string): boolean | undefined;

package/dist/helpers/groups.js

@@ -1,10 +1,24 @@
-import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getOrComputeCachedValue, notifyEventUpdate } from "applesauce-core/helpers";
 import { getReplaceableIdentifier, getTagValue } from "applesauce-core/helpers/event";
-import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { fillAndTrimTag, processTags } from "applesauce-core/helpers/tags";
-import { ensureWebSocketURL, normalizeURL } from "applesauce-core/helpers/url";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
+import { processTags } from "applesauce-core/helpers/tags";
+import { normalizeURL } from "applesauce-core/helpers/url";
 export const GROUPS_LIST_KIND = 10009;
 export const GROUP_MESSAGE_KIND = 9;
+// NIP-29 Group event kinds
+export const GROUP_METADATA_KIND = 39000;
+export const GROUP_ADMINS_KIND = 39001;
+export const GROUP_MEMBERS_KIND = 39002;
+export const GROUP_ROLES_KIND = 39003;
+export const JOIN_REQUEST_KIND = 9021;
+export const LEAVE_REQUEST_KIND = 9022;
+export const PUT_USER_KIND = 9000;
+export const REMOVE_USER_KIND = 9001;
+export const EDIT_METADATA_KIND = 9002;
+export const DELETE_EVENT_KIND = 9005;
+export const CREATE_GROUP_KIND = 9007;
+export const DELETE_GROUP_KIND = 9008;
+export const CREATE_INVITE_KIND = 9009;
 /** decodes a group identifier into a group pointer object */
 export function decodeGroupPointer(str) {
     let [relay, id] = str.split("'");
@@ -25,8 +39,10 @@ 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;
+export function getGroupPointerFromHTag(tag, hint) {
+    let [_, id, relay] = tag;
+    if (!relay && hint)
+        relay = hint;
     if (!id || !relay)
         return undefined;
     return { id, relay };
@@ -40,14 +56,53 @@ export function getGroupPointerFromGroupTag(tag) {
 export function getPublicGroups(bookmark) {
     return getOrComputeCachedValue(bookmark, GroupsPublicSymbol, () => processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
 }
-/** Returns all the hidden groups from a k:10009 list */
 export function getHiddenGroups(bookmark) {
+    if (GroupsHiddenSymbol in bookmark)
+        return bookmark[GroupsHiddenSymbol];
     return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        //get hidden tags
         const tags = getHiddenTags(bookmark);
-        return (tags &&
-            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+        if (!tags)
+            return undefined;
+        // parse groups from hidden tags
+        const groups = processTags(tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag);
+        // set cached value
+        Reflect.set(bookmark, GroupsHiddenSymbol, groups);
+        return groups;
     });
 }
+/** Checks if the hidden groups are unlocked */
+export function isHiddenGroupsUnlocked(bookmark) {
+    return isHiddenTagsUnlocked(bookmark) && (GroupsHiddenSymbol in bookmark || getHiddenGroups(bookmark) !== undefined);
+}
+/** Unlocks the hidden groups on a groups event */
+export async function unlockHiddenGroups(bookmark, signer) {
+    if (isHiddenGroupsUnlocked(bookmark))
+        return bookmark[GroupsHiddenSymbol];
+    // unlock hidden tags
+    await unlockHiddenTags(bookmark, signer);
+    // get hidden groups
+    const groups = getHiddenGroups(bookmark);
+    if (!groups)
+        throw new Error("Failed to unlock hidden groups");
+    // notify event store
+    notifyEventUpdate(bookmark);
+    return groups;
+}
+/** Gets a {@link GroupPointer} from a group event by reading the "h" tag */
+export function getGroupPointer(event, relay) {
+    const hTag = event.tags.find((t) => t[0] === "h");
+    if (!hTag)
+        return undefined;
+    return getGroupPointerFromHTag(hTag, relay);
+}
+/** Gets the group id from a group event by reading the "h" tag */
+export function getGroupId(event) {
+    const hTag = event.tags.find((t) => t[0] === "h");
+    if (!hTag)
+        return undefined;
+    return hTag[1];
+}
 /** Gets a {@link GroupPointer} from a kind 39000 group metadata event */
 export function getGroupPointerFromMetadata(event, relay) {
     // Use the "d" tag for the group ID and the provided relay
@@ -59,11 +114,258 @@ export function getGroupPointerFromMetadata(event, relay) {
         name: name,
     };
 }
-/** Creates a "h" tag for chat messages from a {@link GroupPointer} */
-export function createGroupHTagFromGroupPointer(group) {
-    return fillAndTrimTag(["h", group.id, ensureWebSocketURL(group.relay)]);
+// Symbols for caching parsed data
+const GroupMetadataSymbol = Symbol.for("group-metadata");
+const GroupAdminsSymbol = Symbol.for("group-admins");
+const GroupMembersSymbol = Symbol.for("group-members");
+const GroupRolesSymbol = Symbol.for("group-roles");
+const JoinRequestSymbol = Symbol.for("join-request");
+const LeaveRequestSymbol = Symbol.for("leave-request");
+const PutUserSymbol = Symbol.for("put-user");
+const RemoveUserSymbol = Symbol.for("remove-user");
+const EditMetadataSymbol = Symbol.for("edit-metadata");
+const DeleteEventSymbol = Symbol.for("delete-event");
+const CreateGroupSymbol = Symbol.for("create-group");
+const DeleteGroupSymbol = Symbol.for("delete-group");
+const CreateInviteSymbol = Symbol.for("create-invite");
+/** Gets group metadata from a kind 39000 event */
+export function getGroupMetadata(event) {
+    if (event.kind !== GROUP_METADATA_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupMetadataSymbol, () => {
+        const id = getReplaceableIdentifier(event) || "_";
+        const name = getTagValue(event, "name");
+        const picture = getTagValue(event, "picture");
+        const about = getTagValue(event, "about");
+        const publicTag = event.tags.find((t) => t[0] === "public");
+        const privateTag = event.tags.find((t) => t[0] === "private");
+        const openTag = event.tags.find((t) => t[0] === "open");
+        const closedTag = event.tags.find((t) => t[0] === "closed");
+        return {
+            id,
+            name,
+            picture,
+            about,
+            isPublic: !!publicTag,
+            isPrivate: !!privateTag,
+            isOpen: !!openTag,
+            isClosed: !!closedTag,
+        };
+    });
+}
+/** Gets group admins from a kind 39001 event */
+export function getGroupAdmins(event) {
+    if (event.kind !== GROUP_ADMINS_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupAdminsSymbol, () => {
+        const adminsMap = new Map();
+        for (const tag of event.tags) {
+            if (tag[0] === "p" && tag[1]) {
+                const pubkey = tag[1];
+                const roles = tag.slice(2).filter((r) => r.length > 0);
+                if (adminsMap.has(pubkey)) {
+                    const existingRoles = adminsMap.get(pubkey);
+                    adminsMap.set(pubkey, [...new Set([...existingRoles, ...roles])]);
+                }
+                else {
+                    adminsMap.set(pubkey, roles);
+                }
+            }
+        }
+        return Array.from(adminsMap.entries()).map(([pubkey, roles]) => ({
+            pubkey,
+            roles,
+        }));
+    });
+}
+/** Gets group members from a kind 39002 event */
+export function getGroupMembers(event) {
+    if (event.kind !== GROUP_MEMBERS_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupMembersSymbol, () => {
+        return event.tags.filter((t) => t[0] === "p" && t[1]).map((t) => t[1]);
+    });
+}
+/** Gets group roles from a kind 39003 event */
+export function getGroupRoles(event) {
+    if (event.kind !== GROUP_ROLES_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, GroupRolesSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "role" && t[1])
+            .map((t) => ({
+            name: t[1],
+            description: t[2],
+        }));
+    });
+}
+/** Gets join request information from a kind 9021 event */
+export function getGroupJoinRequestInfo(event) {
+    if (event.kind !== JOIN_REQUEST_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, JoinRequestSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+            inviteCode: getTagValue(event, "code"),
+        };
+    });
+}
+/** Gets leave request information from a kind 9022 event */
+export function getGroupLeaveRequestInfo(event) {
+    if (event.kind !== LEAVE_REQUEST_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, LeaveRequestSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
 }
-/** Creates a "group" tag from a {@link GroupPointer} */
-export function createGroupTagFromGroupPointer(group) {
-    return fillAndTrimTag(["group", group.id, ensureWebSocketURL(group.relay), group.name], 3);
+/** Gets put user event information from a kind 9000 event */
+export function getGroupPutUserInfo(event) {
+    if (event.kind !== PUT_USER_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, PutUserSymbol, () => {
+        const groupId = getGroupId(event);
+        const pubkey = getTagValue(event, "p");
+        if (!groupId || !pubkey)
+            return undefined;
+        const roles = event.tags.filter((t) => t[0] === "p" && t.length > 2).flatMap((t) => t.slice(2));
+        return {
+            groupId,
+            pubkey,
+            roles: roles.length > 0 ? roles : undefined,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets remove user event information from a kind 9001 event */
+export function getGroupRemoveUserInfo(event) {
+    if (event.kind !== REMOVE_USER_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, RemoveUserSymbol, () => {
+        const groupId = getGroupId(event);
+        const pubkey = getTagValue(event, "p");
+        if (!groupId || !pubkey)
+            return undefined;
+        return {
+            groupId,
+            pubkey,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets edit metadata event information from a kind 9002 event */
+export function getGroupEditMetadataInfo(event) {
+    if (event.kind !== EDIT_METADATA_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, EditMetadataSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        const metadataFields = {};
+        const name = getTagValue(event, "name");
+        const picture = getTagValue(event, "picture");
+        const about = getTagValue(event, "about");
+        const publicTag = event.tags.find((t) => t[0] === "public");
+        const privateTag = event.tags.find((t) => t[0] === "private");
+        const openTag = event.tags.find((t) => t[0] === "open");
+        const closedTag = event.tags.find((t) => t[0] === "closed");
+        if (name !== undefined)
+            metadataFields.name = name;
+        if (picture !== undefined)
+            metadataFields.picture = picture;
+        if (about !== undefined)
+            metadataFields.about = about;
+        if (publicTag)
+            metadataFields.isPublic = true;
+        if (privateTag)
+            metadataFields.isPrivate = true;
+        if (openTag)
+            metadataFields.isOpen = true;
+        if (closedTag)
+            metadataFields.isClosed = true;
+        return {
+            groupId,
+            metadataFields,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets delete event information from a kind 9005 event */
+export function getGroupDeleteEventInfo(event) {
+    if (event.kind !== DELETE_EVENT_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, DeleteEventSymbol, () => {
+        const groupId = getGroupId(event);
+        const eventId = getTagValue(event, "e");
+        if (!groupId || !eventId)
+            return undefined;
+        return {
+            groupId,
+            eventId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets create group event information from a kind 9007 event */
+export function getGroupCreateGroupInfo(event) {
+    if (event.kind !== CREATE_GROUP_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, CreateGroupSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets delete group event information from a kind 9008 event */
+export function getGroupDeleteGroupInfo(event) {
+    if (event.kind !== DELETE_GROUP_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, DeleteGroupSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Gets create invite event information from a kind 9009 event */
+export function getGroupCreateInviteInfo(event) {
+    if (event.kind !== CREATE_INVITE_KIND)
+        return undefined;
+    return getOrComputeCachedValue(event, CreateInviteSymbol, () => {
+        const groupId = getGroupId(event);
+        if (!groupId)
+            return undefined;
+        return {
+            groupId,
+            reason: event.content || undefined,
+        };
+    });
+}
+/** Checks group membership status from kind 9000/9001 events */
+export function checkGroupMembership(events, pubkey) {
+    // Filter to only membership-related events
+    const membershipEvents = events.filter((e) => (e.kind === PUT_USER_KIND || e.kind === REMOVE_USER_KIND) && getTagValue(e, "p") === pubkey);
+    if (membershipEvents.length === 0)
+        return undefined;
+    // Sort by created_at descending to get the latest event
+    const sorted = membershipEvents.sort((a, b) => b.created_at - a.created_at);
+    const latest = sorted[0];
+    // Latest event determines membership status
+    return latest.kind === PUT_USER_KIND;
 }

package/dist/helpers/index.d.ts

@@ -19,7 +19,6 @@ export * from "./highlight.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
-export * from "./mailboxes.js";
 export * from "./messages.js";
 export * from "./mute.js";
 export * from "./picture-post.js";
@@ -35,3 +34,4 @@ export * from "./torrent.js";
 export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zap.js";
+export * from "./relay-list.js";

package/dist/helpers/index.js

@@ -19,7 +19,6 @@ export * from "./highlight.js";
 export * from "./legacy-messages.js";
 export * from "./lists.js";
 export * from "./lnurl.js";
-export * from "./mailboxes.js";
 export * from "./messages.js";
 export * from "./mute.js";
 export * from "./picture-post.js";
@@ -35,3 +34,4 @@ export * from "./torrent.js";
 export * from "./user-status.js";
 export * from "./wrapped-messages.js";
 export * from "./zap.js";
+export * from "./relay-list.js";

package/dist/helpers/lists.d.ts

@@ -1,6 +1,5 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { AddressPointer, EventPointer, ProfilePointer } from "applesauce-core/helpers/pointers";
-export declare const FAVORITE_RELAYS_KIND = 10012;
 export type ReadListTags = "public" | "hidden" | "all";
 /** Returns all the tags of a list or set */
 export declare function getListTags(list: NostrEvent, type?: ReadListTags): string[][];

package/dist/helpers/lists.js

@@ -1,17 +1,16 @@
 import { getReplaceableIdentifier, isAddressableKind, isReplaceable, isReplaceableKind, } from "applesauce-core/helpers/event";
 import { getHiddenTags } from "applesauce-core/helpers/hidden-tags";
-import { getAddressPointerForEvent, getAddressPointerFromATag, getReplaceableAddressFromPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
-import { mergeRelaySets } from "applesauce-core/helpers/relays";
+import { getAddressPointerForEvent, getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag, getReplaceableAddressFromPointer, } from "applesauce-core/helpers/pointers";
+import { relaySet } from "applesauce-core/helpers/relays";
 import { isATag, isETag, isPTag, processTags } from "applesauce-core/helpers/tags";
-export const FAVORITE_RELAYS_KIND = 10012;
 /** Returns all the tags of a list or set */
 export function getListTags(list, type) {
     switch (type) {
+        default:
         case "public":
             return list.tags;
         case "hidden":
             return getHiddenTags(list) ?? [];
-        default:
         case "all":
             return [...(getHiddenTags(list) ?? []), ...list.tags];
     }
@@ -91,7 +90,7 @@ export function getProfilePointersFromList(list, type) {
  * @param type - Which types of tags to read
  */
 export function getRelaysFromList(list, type) {
-    return mergeRelaySets(processTags(getListTags(list, type), (t) => (t[0] === "relay" ? t[1] : undefined)));
+    return relaySet(processTags(getListTags(list, type), (t) => (t[0] === "relay" ? t[1] : undefined)));
 }
 /** Returns if an event is a valid list or set */
 export function isValidList(event) {

package/dist/helpers/mute.d.ts

@@ -1,33 +1,36 @@
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+export type MuteListEvent = KnownEvent<typeof kinds.Mutelist>;
+/** Validates that an event is a valid mute list */
+export declare function isValidMuteList(event: NostrEvent): event is MuteListEvent;
 export declare const MutePublicSymbol: unique symbol;
 export declare const MuteHiddenSymbol: unique symbol;
 /** Type for unlocked mute events */
 export type UnlockedMutes = {
-    [MuteHiddenSymbol]: Mutes;
+    [MuteHiddenSymbol]: MutedThings;
 };
-export type Mutes = {
+export type MutedThings = {
     pubkeys: Set<string>;
     threads: Set<string>;
     hashtags: Set<string>;
     words: Set<string>;
 };
 /** Merges any number of mute sets */
-export declare function mergeMutes(...mutes: Mutes[]): Mutes;
+export declare function mergeMutes(...mutes: MutedThings[]): MutedThings;
 /** Parses mute tags */
-export declare function parseMutedTags(tags: string[][]): Mutes;
+export declare function parseMutedTags(tags: string[][]): MutedThings;
 /** Returns muted things */
-export declare function getMutedThings(mute: NostrEvent): Mutes;
+export declare function getMutedThings(mute: NostrEvent): MutedThings;
 /** Returns only the public muted things from a mute event */
-export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
+export declare function getPublicMutedThings(mute: NostrEvent): MutedThings;
 /** 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<T extends NostrEvent & UnlockedMutes>(mute: T): Mutes;
-export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): Mutes | undefined;
+export declare function getHiddenMutedThings<T extends NostrEvent & UnlockedMutes>(mute: T): MutedThings;
+export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): MutedThings | undefined;
 /** Unlocks the hidden mutes */
-export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<Mutes>;
+export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<MutedThings>;
 /** Creates a RegExp for matching muted words */
 export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
 /** Returns true if the event matches the mutes */
-export declare function matchMutes(mutes: Mutes, event: NostrEvent): boolean;
+export declare function matchMutes(mutes: MutedThings, event: NostrEvent): boolean;

package/dist/helpers/mute.js

@@ -1,9 +1,13 @@
 import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
 import { kinds, notifyEventUpdate } from "applesauce-core/helpers/event";
-import { isETag, isPTag, isTTag } from "applesauce-core/helpers/tags";
 import { getIndexableTags } from "applesauce-core/helpers/filter";
+import { isETag, isPTag, isTTag } from "applesauce-core/helpers/tags";
 import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
 import { getNip10References } from "./threading.js";
+/** Validates that an event is a valid mute list */
+export function isValidMuteList(event) {
+    return event.kind === kinds.Mutelist;
+}
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
 /** Merges any number of mute sets */
@@ -43,10 +47,11 @@ export function getPublicMutedThings(mute) {
 }
 /** Checks if the hidden mutes are unlocked */
 export function isHiddenMutesUnlocked(mute) {
-    return isHiddenTagsUnlocked(mute) && Reflect.has(mute, MuteHiddenSymbol);
+    // No need for try catch or proactivly parsing here since it only depends on hidden tags
+    return MuteHiddenSymbol in mute || isHiddenTagsUnlocked(mute);
 }
 export function getHiddenMutedThings(mute) {
-    if (isHiddenMutesUnlocked(mute))
+    if (MuteHiddenSymbol in mute)
         return mute[MuteHiddenSymbol];
     // get hidden tags
     const tags = getHiddenTags(mute);
@@ -60,7 +65,7 @@ export function getHiddenMutedThings(mute) {
 }
 /** Unlocks the hidden mutes */
 export async function unlockHiddenMutes(mute, signer) {
-    if (isHiddenMutesUnlocked(mute))
+    if (MuteHiddenSymbol in mute)
         return mute[MuteHiddenSymbol];
     // Unlock hidden tags
     await unlockHiddenTags(mute, signer);