applesauce-core 0.10.0 → 0.12.0

package/dist/helpers/gift-wraps.js

@@ -0,0 +1,49 @@
+import { verifyEvent } from "nostr-tools";
+import { getHiddenContent, isHiddenContentLocked, unlockHiddenContent } from "./hidden-content.js";
+import { getOrComputeCachedValue } from "./cache.js";
+export const GiftWrapSealSymbol = Symbol.for("gift-wrap-seal");
+export const GiftWrapEventSymbol = Symbol.for("gift-wrap-event");
+/** Returns the unsigned seal event in a gift-wrap event */
+export function getGiftWrapSeal(gift) {
+    if (isHiddenContentLocked(gift))
+        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))
+        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;
+    });
+}
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export function isGiftWrapLocked(gift) {
+    return isHiddenContentLocked(gift) || isHiddenContentLocked(getGiftWrapSeal(gift));
+}
+/** Unlocks and returns the unsigned seal event in a gift-wrap */
+export async function unlockGiftWrap(gift, signer) {
+    if (isHiddenContentLocked(gift))
+        await unlockHiddenContent(gift, signer);
+    const seal = getGiftWrapSeal(gift);
+    if (isHiddenContentLocked(seal))
+        await unlockHiddenContent(seal, signer);
+    return getGiftWrapEvent(gift);
+}

package/dist/helpers/groups.d.ts

@@ -0,0 +1,24 @@
+import { NostrEvent } from "nostr-tools";
+export declare const GROUPS_LIST_KIND = 10009;
+export declare const GROUP_MESSAGE_KIND = 9;
+/** NIP-29 group pointer */
+export type GroupPointer = {
+    id: string;
+    relay: string;
+    name?: string;
+};
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export declare function decodeGroupPointer(str: string): GroupPointer;
+/** Converts a group pointer into a group identifier */
+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 "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[];
+/** Returns all the hidden groups from a k:10009 list */
+export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;

package/dist/helpers/groups.js

@@ -0,0 +1,39 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { processTags } from "./tags.js";
+import { getHiddenTags } from "./hidden-tags.js";
+export const GROUPS_LIST_KIND = 10009;
+export const GROUP_MESSAGE_KIND = 9;
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export function decodeGroupPointer(str) {
+    const [relay, id] = str.split("'");
+    if (!relay)
+        throw new Error("Group pointer missing relay");
+    return { relay, id: id || "_" };
+}
+/** Converts a group pointer into a group identifier */
+export function encodeGroupPointer(pointer) {
+    const hostname = URL.canParse(pointer.relay) ? new URL(pointer.relay).hostname : pointer.relay;
+    return `${hostname}'${pointer.id}`;
+}
+export const GroupsPublicSymbol = Symbol.for("groups-public");
+export const GroupsHiddenSymbol = Symbol.for("groups-hidden");
+/** gets a {@link GroupPointer} from a "group" tag */
+export function getGroupPointerFromGroupTag(tag) {
+    const [_, id, relay, name] = tag;
+    return { id, relay, name };
+}
+/** Returns all the public groups from a k:10009 list */
+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) {
+    return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return (tags &&
+            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+    });
+}

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

@@ -0,0 +1,48 @@
+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;
+/** Checks if an event can have hidden content */
+export declare function canHaveHiddenContent(kind: number): boolean;
+/** Checks if an event has hidden content */
+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 */
+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 = {
+    kind: number;
+    pubkey: string;
+    content: string;
+};
+/**
+ * Unlocks the encrypted content in an event
+ * @param event The event with content to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @throws
+ */
+export declare function unlockHiddenContent<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string>;
+/** Removes the unencrypted hidden content on an event */
+export declare function lockHiddenContent<T extends object>(event: T): void;

package/dist/helpers/hidden-content.js

@@ -0,0 +1,88 @@
+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;
+}
+/** Checks if an event can have hidden content */
+export function canHaveHiddenContent(kind) {
+    return EventContentEncryptionMethod[kind] !== undefined;
+}
+/** Checks if an event has hidden content */
+export function hasHiddenContent(event) {
+    return canHaveHiddenContent(event.kind) && event.content.length > 0;
+}
+/** 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 */
+export function isHiddenContentLocked(event) {
+    return Reflect.has(event, HiddenContentSymbol) === false;
+}
+/** 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;
+}
+/**
+ * Unlocks the encrypted content in an event
+ * @param event The event with content to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @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 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);
+    }
+    return 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);
+    }
+}

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

@@ -1,27 +1,24 @@
-import { EventTemplate, NostrEvent, UnsignedEvent } from "nostr-tools";
-import { EventStore } from "applesauce-core";
-export type HiddenTagsSigner = {
-    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;
-    };
-};
-export type TagOperation = (tags: string[][]) => string[][];
+import { HiddenContentEvent, HiddenContentSigner } from "./hidden-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export declare const EventEncryptionMethod: Record<number, "nip04" | "nip44">;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Checks if an event has hidden tags */
-export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
+export declare function hasHiddenTags<T extends {
+    content: string;
+    kind: number;
+}>(event: T): boolean;
 /** Returns the hidden tags for an event if they are unlocked */
-export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+export declare function getHiddenTags<T extends object>(event: T): string[][] | undefined;
 /** Checks if the hidden tags are locked */
-export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+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): {
+    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;
+};
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
@@ -29,20 +26,5 @@ export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export declare function unlockHiddenTags(event: NostrEvent, signer: HiddenTagsSigner, store?: EventStore): Promise<NostrEvent>;
-/**
- * Modifies tags and returns an EventTemplate
- * @param event Event to modify
- * @param operations Operations for hidden and public tags
- * @param signer A signer to use to decrypt the tags
- * @throws
- */
-export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, operations: {
-    public?: TagOperation;
-    hidden?: TagOperation;
-}, signer?: HiddenTagsSigner): Promise<EventTemplate>;
-/**
- * Override the hidden tags in an event
- * @throws
- */
-export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenTagsSigner): Promise<EventTemplate>;
+export declare function unlockHiddenTags<T extends HiddenContentEvent>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+export declare function lockHiddenTags<T extends object>(event: T): void;

package/dist/helpers/hidden-tags.js

@@ -1,27 +1,9 @@
-import { unixNow } from "applesauce-core/helpers";
-import { kinds } from "nostr-tools";
+import { canHaveHiddenContent, getHiddenContent, getHiddenContentEncryptionMethods, isHiddenContentLocked, lockHiddenContent, unlockHiddenContent, } from "./hidden-content.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const HiddenTagsSymbol = Symbol.for("hidden-tags");
-/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
-export const EventEncryptionMethod = {
-    // NIP-60 wallet
-    37375: "nip44",
-    // NIP-51 lists
-    [kinds.BookmarkList]: "nip04",
-    [kinds.InterestsList]: "nip04",
-    [kinds.Mutelist]: "nip04",
-    [kinds.CommunitiesList]: "nip04",
-    [kinds.PublicChatsList]: "nip04",
-    [kinds.SearchRelaysList]: "nip04",
-    // NIP-51 sets
-    [kinds.Bookmarksets]: "nip04",
-    [kinds.Relaysets]: "nip04",
-    [kinds.Followsets]: "nip04",
-    [kinds.Curationsets]: "nip04",
-    [kinds.Interestsets]: "nip04",
-};
 /** Checks if an event can have hidden tags */
 export function canHaveHiddenTags(kind) {
-    return EventEncryptionMethod[kind] !== undefined;
+    return canHaveHiddenContent(kind);
 }
 /** Checks if an event has hidden tags */
 export function hasHiddenTags(event) {
@@ -29,18 +11,24 @@ export function hasHiddenTags(event) {
 }
 /** Returns the hidden tags for an event if they are unlocked */
 export function getHiddenTags(event) {
-    return Reflect.get(event, HiddenTagsSymbol);
+    if (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 hasHiddenTags(event) && getHiddenTags(event) === undefined;
+    return isHiddenContentLocked(event);
 }
-function getEventEncryption(kind, signer) {
-    const method = EventEncryptionMethod[kind];
-    const encryption = signer[method];
-    if (!encryption)
-        throw new Error(`Signer does not support ${method} encryption`);
-    return encryption;
+/** Returns either nip04 or nip44 encryption method depending on list kind */
+export function getHiddenTagsEncryptionMethods(kind, signer) {
+    return getHiddenContentEncryptionMethods(kind, signer);
 }
 /**
  * Decrypts the private list
@@ -49,60 +37,15 @@ function getEventEncryption(kind, signer) {
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export async function unlockHiddenTags(event, signer, store) {
+export async function unlockHiddenTags(event, signer) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
-    const encryption = getEventEncryption(event.kind, signer);
-    const plaintext = await encryption.decrypt(event.pubkey, event.content);
-    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[][]
-    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
-    Reflect.set(event, HiddenTagsSymbol, tags);
-    if (store)
-        store.update(event);
-    return event;
-}
-/**
- * Modifies tags and returns an EventTemplate
- * @param event Event to modify
- * @param operations Operations for hidden and public tags
- * @param signer A signer to use to decrypt the tags
- * @throws
- */
-export async function modifyEventTags(event, operations, signer) {
-    const draft = { content: event.content, tags: event.tags, kind: event.kind, created_at: unixNow() };
-    if (operations.public) {
-        draft.tags = operations.public(event.tags);
-    }
-    if (operations.hidden) {
-        if (!signer)
-            throw new Error("Missing signer for hidden tags");
-        if (!canHaveHiddenTags(event.kind))
-            throw new Error("Event kind does not support hidden tags");
-        const hidden = hasHiddenTags(event) ? getHiddenTags(event) : [];
-        if (!hidden)
-            throw new Error("Hidden tags are locked");
-        const newHidden = operations.hidden(hidden);
-        const encryption = getEventEncryption(event.kind, signer);
-        draft.content = await encryption.encrypt(event.pubkey, JSON.stringify(newHidden));
-    }
-    return draft;
-}
-/**
- * Override the hidden tags in an event
- * @throws
- */
-export async function overrideHiddenTags(event, hidden, signer) {
-    if (!canHaveHiddenTags(event.kind))
-        throw new Error("Event kind does not support hidden tags");
-    const encryption = getEventEncryption(event.kind, signer);
-    const ciphertext = await encryption.encrypt(event.pubkey, JSON.stringify(hidden));
-    return {
-        kind: event.kind,
-        content: ciphertext,
-        created_at: unixNow(),
-        tags: event.tags,
-    };
+    // unlock hidden content is needed
+    if (isHiddenContentLocked(event))
+        await unlockHiddenContent(event, signer);
+    return getHiddenTags(event);
+}
+export function lockHiddenTags(event) {
+    Reflect.deleteProperty(event, HiddenTagsSymbol);
+    lockHiddenContent(event);
 }

package/dist/helpers/index.d.ts

@@ -1,24 +1,39 @@
+export * from "./blossom.js";
 export * from "./bolt11.js";
+export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./channels.js";
 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 "./event.js";
 export * from "./external-id.js";
+export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./gift-wraps.js";
+export * from "./groups.js";
 export * from "./hashtag.js";
+export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lists.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./media-attachment.js";
+export * from "./mutes.js";
+export * from "./picture-post.js";
 export * from "./pointers.js";
 export * from "./profile.js";
 export * from "./relays.js";
+export * from "./share.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";
 export * from "./time.js";
 export * from "./url.js";
+export * from "./user-status.js";
 export * from "./zap.js";

package/dist/helpers/index.js

@@ -1,24 +1,39 @@
+export * from "./blossom.js";
 export * from "./bolt11.js";
+export * from "./bookmarks.js";
 export * from "./cache.js";
+export * from "./channels.js";
 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 "./event.js";
 export * from "./external-id.js";
+export * from "./file-metadata.js";
 export * from "./filter.js";
+export * from "./gift-wraps.js";
+export * from "./groups.js";
 export * from "./hashtag.js";
+export * from "./hidden-content.js";
 export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lists.js";
 export * from "./lnurl.js";
 export * from "./lru.js";
 export * from "./mailboxes.js";
-export * from "./media-attachment.js";
+export * from "./mutes.js";
+export * from "./picture-post.js";
 export * from "./pointers.js";
 export * from "./profile.js";
 export * from "./relays.js";
+export * from "./share.js";
 export * from "./string.js";
 export * from "./tags.js";
 export * from "./threading.js";
 export * from "./time.js";
 export * from "./url.js";
+export * from "./user-status.js";
 export * from "./zap.js";

package/dist/helpers/lists.d.ts

@@ -0,0 +1,28 @@
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isEventPointerInList(list: NostrEvent, pointer: string | EventPointer): boolean;
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isAddressPointerInList(list: NostrEvent, pointer: string | AddressPointer): boolean;
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export declare function isProfilePointerInList(list: NostrEvent, pointer: string | ProfilePointer): boolean;
+/** Returns all the EventPointer in a list or set */
+export declare function getEventPointersFromList(list: NostrEvent): EventPointer[];
+/** Returns all the AddressPointer in a list or set */
+export declare function getAddressPointersFromList(list: NostrEvent): AddressPointer[];
+/** Returns all the ProfilePointer in a list or set */
+export declare function getProfilePointersFromList(list: NostrEvent): ProfilePointer[];
+/** Returns if an event is a valid list or set */
+export declare function isValidList(event: NostrEvent): boolean;

package/dist/helpers/lists.js

@@ -0,0 +1,65 @@
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { getHiddenTags } from "./hidden-tags.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, getProfilePointerFromPTag, } from "./pointers.js";
+import { isATag, isETag, isPTag, processTags } from "./tags.js";
+import { getReplaceableIdentifier } from "./event.js";
+function listGetAllTags(list) {
+    const hidden = getHiddenTags(list);
+    return hidden ? [...hidden, ...list.tags] : list.tags;
+}
+/**
+ * Checks if an event pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in EventPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isEventPointerInList(list, pointer) {
+    const id = typeof pointer === "string" ? pointer : pointer.id;
+    return listGetAllTags(list).some((t) => t[0] === "e" && t[1] === id);
+}
+/**
+ * Checks if an address pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in AddressPointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isAddressPointerInList(list, pointer) {
+    const cord = typeof pointer === "string" ? pointer : getCoordinateFromAddressPointer(pointer);
+    return listGetAllTags(list).some((t) => t[0] === "a" && t[1] === cord);
+}
+/**
+ * Checks if an profile pointer is anywhere in a list or set
+ * NOTE: Ignores the `relay` field in ProfilePointer
+ * NOTE: This will check the hidden tags if the list has hidden tags and they are unlocked
+ */
+export function isProfilePointerInList(list, pointer) {
+    const pubkey = typeof pointer === "string" ? pointer : pointer.pubkey;
+    return listGetAllTags(list).some((t) => t[0] === "p" && t[1] === pubkey);
+}
+/** Returns all the EventPointer in a list or set */
+export function getEventPointersFromList(list) {
+    return processTags(listGetAllTags(list), (tag) => (isETag(tag) ? tag : undefined), getEventPointerFromETag);
+}
+/** Returns all the AddressPointer in a list or set */
+export function getAddressPointersFromList(list) {
+    return processTags(listGetAllTags(list), (t) => (isATag(t) ? t : undefined), getAddressPointerFromATag);
+}
+/** Returns all the ProfilePointer in a list or set */
+export function getProfilePointersFromList(list) {
+    return processTags(listGetAllTags(list), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+}
+/** Returns if an event is a valid list or set */
+export function isValidList(event) {
+    try {
+        if (isParameterizedReplaceableKind(event.kind)) {
+            // event is a set
+            // ensure the set has an identifier
+            getReplaceableIdentifier(event);
+            return true;
+        }
+        else if (isReplaceableKind(event.kind) && event.kind >= 10000 && event.kind < 20000) {
+            // event is a list
+            return true;
+        }
+    }
+    catch (error) { }
+    return false;
+}