applesauce-common 0.0.0-next-20251203172109

package/dist/helpers/messages.d.ts

@@ -0,0 +1,31 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { Rumor } from "./gift-wrap.js";
+/**
+ * Groups messages into bubble sets based on the pubkey and time
+ *
+ * @param messages - The messages to group
+ * @param buffer - Minimum number of seconds between message groups
+ * @returns The grouped messages
+ */
+export declare function groupMessageEvents<T extends {
+    created_at: number;
+    pubkey: string;
+}>(messages: T[], buffer?: number): T[][];
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - A conversation identifier (pubkey1:pubkey2:pubkey3), or a users pubkey, or a list of participant pubkeys, or a rumor message
+ * @returns The participants of the conversation
+ */
+export declare function getConversationParticipants(participants: string | string[] | Rumor | NostrEvent): string[];
+/**
+ * Creates a conversation identifier from a users pubkey and alist of correspondants
+ * @param participants - The participants of the conversation
+ * @returns The conversation identifier
+ */
+export declare function createConversationIdentifier(...participants: (string | string[])[]): string;
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The NIP-17 Rumor or NIP-04 message event
+ * @returns The conversation identifier
+ */
+export declare function getConversationIdentifierFromMessage(message: Rumor | NostrEvent): string;

package/dist/helpers/messages.js

@@ -0,0 +1,57 @@
+import { kinds } from "applesauce-core/helpers/event";
+import { isPTag } from "applesauce-core/helpers/tags";
+/**
+ * Groups messages into bubble sets based on the pubkey and time
+ *
+ * @param messages - The messages to group
+ * @param buffer - Minimum number of seconds between message groups
+ * @returns The grouped messages
+ */
+export function groupMessageEvents(messages, buffer = 5 * 60) {
+    const groups = [];
+    for (const message of messages) {
+        const group = groups[groups.length - 1];
+        const last = group?.[0];
+        if (group && last?.pubkey === message.pubkey && Math.abs(message.created_at - last.created_at) < buffer)
+            group.push(message);
+        else
+            groups.push([message]);
+    }
+    return groups;
+}
+/**
+ * Returns all pubkeys of participants of a conversation
+ * @param participants - A conversation identifier (pubkey1:pubkey2:pubkey3), or a users pubkey, or a list of participant pubkeys, or a rumor message
+ * @returns The participants of the conversation
+ */
+export function getConversationParticipants(participants) {
+    let participantList;
+    if (typeof participants === "string") {
+        participantList = participants.split(":");
+    }
+    else if (Array.isArray(participants)) {
+        participantList = participants;
+    }
+    else {
+        if (participants.kind !== kinds.EncryptedDirectMessage && participants.kind !== kinds.PrivateDirectMessage)
+            throw new Error("Can only get participants from direct message event (4, 14)");
+        participantList = [participants.pubkey, ...participants.tags.filter(isPTag).map((t) => t[1])];
+    }
+    return Array.from(new Set(participantList));
+}
+/**
+ * Creates a conversation identifier from a users pubkey and alist of correspondants
+ * @param participants - The participants of the conversation
+ * @returns The conversation identifier
+ */
+export function createConversationIdentifier(...participants) {
+    return Array.from(new Set(participants.flat())).sort().join(":");
+}
+/**
+ * Returns the conversation identifier for a wrapped direct message
+ * @param message - The NIP-17 Rumor or NIP-04 message event
+ * @returns The conversation identifier
+ */
+export function getConversationIdentifierFromMessage(message) {
+    return createConversationIdentifier(getConversationParticipants(message));
+}

package/dist/helpers/mute.d.ts

@@ -0,0 +1,33 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { HiddenContentSigner } from "applesauce-core/helpers/hidden-content";
+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>;
+    hashtags: Set<string>;
+    words: Set<string>;
+};
+/** Merges any number of mute sets */
+export declare function mergeMutes(...mutes: Mutes[]): Mutes;
+/** Parses mute tags */
+export declare function parseMutedTags(tags: string[][]): Mutes;
+/** Returns muted things */
+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<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 */
+export declare function matchMutes(mutes: Mutes, event: NostrEvent): boolean;

package/dist/helpers/mute.js

@@ -0,0 +1,111 @@
+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 { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers/hidden-tags";
+import { getNip10References } from "./threading.js";
+export const MutePublicSymbol = Symbol.for("mute-public");
+export const MuteHiddenSymbol = Symbol.for("mute-hidden");
+/** Merges any number of mute sets */
+export function mergeMutes(...mutes) {
+    const mute = { pubkeys: new Set(), threads: new Set(), hashtags: new Set(), words: new Set() };
+    for (const m of mutes) {
+        for (const pubkey of m.pubkeys)
+            mute.pubkeys.add(pubkey);
+        for (const thread of m.threads)
+            mute.threads.add(thread);
+        for (const hashtag of m.hashtags)
+            mute.hashtags.add(hashtag);
+        for (const word of m.words)
+            mute.words.add(word);
+    }
+    return mute;
+}
+/** Parses mute tags */
+export function parseMutedTags(tags) {
+    const pubkeys = new Set(tags.filter(isPTag).map((t) => t[1]));
+    const threads = new Set(tags.filter(isETag).map((t) => t[1]));
+    const hashtags = new Set(tags.filter(isTTag).map((t) => t[1].toLocaleLowerCase()));
+    const words = new Set(tags.filter((t) => t[0] === "word" && t[1]).map((t) => t[1].toLocaleLowerCase()));
+    return { pubkeys, threads, hashtags, words };
+}
+/** Returns muted things */
+export function getMutedThings(mute) {
+    const hidden = getHiddenMutedThings(mute);
+    const mutes = getPublicMutedThings(mute);
+    if (hidden)
+        return mergeMutes(hidden, mutes);
+    return mutes;
+}
+/** Returns only the public muted things from a mute event */
+export function getPublicMutedThings(mute) {
+    return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
+}
+/** Checks if the hidden mutes are unlocked */
+export function isHiddenMutesUnlocked(mute) {
+    return isHiddenTagsUnlocked(mute) && Reflect.has(mute, MuteHiddenSymbol);
+}
+export function getHiddenMutedThings(mute) {
+    if (isHiddenMutesUnlocked(mute))
+        return mute[MuteHiddenSymbol];
+    // get hidden tags
+    const tags = getHiddenTags(mute);
+    if (!tags)
+        return undefined;
+    // 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) {
+    // Escape special characters and join with |
+    const escapedWords = mutedWords.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    // Create the RegExp with word boundaries and case insensitive flag
+    return new RegExp(`\\b(${escapedWords.join("|")})\\b`, "gi");
+}
+/** Returns true if the event matches the mutes */
+export function matchMutes(mutes, event) {
+    // Filter on muted pubkeys
+    if (mutes.pubkeys.size > 0) {
+        if (mutes.pubkeys.has(event.pubkey))
+            return true;
+    }
+    // Filter on muted hashtags`
+    if (mutes.hashtags.size > 0) {
+        const tags = getIndexableTags(event);
+        for (let tag of mutes.hashtags) {
+            if (tags.has("t:" + tag))
+                return true;
+        }
+    }
+    // Filter on muted threads
+    if (mutes.threads.size > 0 && event.kind === kinds.ShortTextNote) {
+        const refs = getNip10References(event);
+        if (refs.root?.e && mutes.threads.has(refs.root.e.id))
+            return true;
+    }
+    // Filter on muted words
+    if (mutes.words.size > 0) {
+        const regExp = createMutedWordsRegExp(Array.from(mutes.words));
+        if (regExp.test(event.content))
+            return true;
+    }
+    // Event does not match any mutes
+    return false;
+}

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

@@ -0,0 +1,5 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+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): FileMetadata[];

package/dist/helpers/picture-post.js

@@ -0,0 +1,6 @@
+import { getMediaAttachments } from "./file-metadata.js";
+export const PICTURE_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export function getPicturePostAttachments(post) {
+    return getMediaAttachments(post);
+}

package/dist/helpers/poll.d.ts

@@ -0,0 +1,46 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare const POLL_KIND = 1068;
+export declare const POLL_RESPONSE_KIND = 1018;
+export declare const PollOptionsSymbol: unique symbol;
+export interface PollOption {
+    id: string;
+    label: string;
+}
+export type PollType = "singlechoice" | "multiplechoice";
+/**
+ * Get the poll question/label from a poll event
+ * Returns the content field which contains the poll question
+ */
+export declare function getPollQuestion(event: NostrEvent): string;
+/**
+ * Get the poll options from a poll event
+ * Returns array of options with id and label
+ */
+export declare function getPollOptions(event: NostrEvent): PollOption[];
+/**
+ * Get the relays specified for poll responses (from 'relay' tags)
+ * Returns undefined if no relays are specified
+ */
+export declare function getPollRelays(event: NostrEvent): string[];
+/**
+ * Get the poll type from a poll event (from 'polltype' tag)
+ * Returns "singlechoice" or "multiplechoice", defaults to "singlechoice"
+ */
+export declare function getPollType(event: NostrEvent): PollType;
+/**
+ * Get the poll expiration timestamp (from 'endsAt' tag)
+ * Returns undefined if no expiration is set
+ */
+export declare function getPollEndsAt(event: NostrEvent): number | undefined;
+/**
+ * Get the poll ID that a response is referencing (from 'e' tag)
+ * Returns undefined if no poll reference is found
+ */
+export declare function getPollResponsePollId(event: NostrEvent): string | undefined;
+/** Get the selected option IDs from a poll response event (from 'response' tags) */
+export declare function getPollResponseOptions(event: NostrEvent): string[];
+/**
+ * Gets the options that a user has voted for in a poll event
+ * Returns undefined if the response is not valid
+ */
+export declare function getPollResponseVotes(poll: NostrEvent, response: NostrEvent): string[] | undefined;

package/dist/helpers/poll.js

@@ -0,0 +1,78 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getTagValue } from "applesauce-core/helpers/event";
+// NIP-88 Poll kinds
+export const POLL_KIND = 1068;
+export const POLL_RESPONSE_KIND = 1018;
+// Cache symbols
+export const PollOptionsSymbol = Symbol.for("poll-options");
+/**
+ * Get the poll question/label from a poll event
+ * Returns the content field which contains the poll question
+ */
+export function getPollQuestion(event) {
+    return event.content;
+}
+/**
+ * Get the poll options from a poll event
+ * Returns array of options with id and label
+ */
+export function getPollOptions(event) {
+    return getOrComputeCachedValue(event, PollOptionsSymbol, () => {
+        return event.tags
+            .filter((tag) => tag[0] === "option" && tag.length >= 3)
+            .map((tag) => ({
+            id: tag[1],
+            label: tag[2],
+        }));
+    });
+}
+/**
+ * Get the relays specified for poll responses (from 'relay' tags)
+ * Returns undefined if no relays are specified
+ */
+export function getPollRelays(event) {
+    return event.tags.filter((tag) => tag[0] === "relay" && tag.length >= 2).map((tag) => tag[1]);
+}
+/**
+ * Get the poll type from a poll event (from 'polltype' tag)
+ * Returns "singlechoice" or "multiplechoice", defaults to "singlechoice"
+ */
+export function getPollType(event) {
+    const type = getTagValue(event, "polltype");
+    return type === "multiplechoice" || type === "singlechoice" ? type : "singlechoice";
+}
+/**
+ * Get the poll expiration timestamp (from 'endsAt' tag)
+ * Returns undefined if no expiration is set
+ */
+export function getPollEndsAt(event) {
+    const endsAt = getTagValue(event, "endsAt");
+    return endsAt ? parseInt(endsAt, 10) : undefined;
+}
+/**
+ * Get the poll ID that a response is referencing (from 'e' tag)
+ * Returns undefined if no poll reference is found
+ */
+export function getPollResponsePollId(event) {
+    return getTagValue(event, "e");
+}
+/** Get the selected option IDs from a poll response event (from 'response' tags) */
+export function getPollResponseOptions(event) {
+    return event.tags.filter((tag) => tag[0] === "response" && tag.length >= 2).map((tag) => tag[1]);
+}
+/**
+ * Gets the options that a user has voted for in a poll event
+ * Returns undefined if the response is not valid
+ */
+export function getPollResponseVotes(poll, response) {
+    if (poll.id !== getPollResponsePollId(response))
+        return;
+    const pollOptions = getPollOptions(poll);
+    const responseOptions = getPollResponseOptions(response);
+    const votes = responseOptions.filter((opts) => pollOptions.some((option) => option.id === opts));
+    const type = getPollType(poll);
+    // If its a single choice poll, return the first vote
+    if (type === "singlechoice")
+        return votes.length === 1 ? [votes[0]] : undefined;
+    return Array.from(new Set(votes));
+}

package/dist/helpers/reaction.d.ts

@@ -0,0 +1,8 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer, EventPointer } from "applesauce-core/helpers/pointers";
+export declare const ReactionEventPointerSymbol: unique symbol;
+export declare const ReactionAddressPointerSymbol: unique symbol;
+/** Returns the EventPointer for a reaction event */
+export declare function getReactionEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Returns the AddressPointer for a reaction event */
+export declare function getReactionAddressPointer(event: NostrEvent): AddressPointer | undefined;

package/dist/helpers/reaction.js

@@ -0,0 +1,56 @@
+import { getOrComputeCachedValue } from "applesauce-core/helpers/cache";
+import { getTagValue } from "applesauce-core/helpers/event";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag, } from "applesauce-core/helpers/pointers";
+import { mergeRelaySets } from "applesauce-core/helpers/relays";
+import { isATag, isETag, isPTag } from "applesauce-core/helpers/tags";
+const isInteger = (str) => Number.isInteger(Number(str));
+export const ReactionEventPointerSymbol = Symbol("reaction-event-pointer");
+export const ReactionAddressPointerSymbol = Symbol("reaction-address-pointer");
+/** Returns the EventPointer for a reaction event */
+export function getReactionEventPointer(event) {
+    return getOrComputeCachedValue(event, ReactionEventPointerSymbol, () => {
+        const eTag = event.tags.find(isETag);
+        if (!eTag)
+            return undefined;
+        // Get the event pointer from the e tag
+        const pointer = getEventPointerFromETag(eTag);
+        if (!pointer)
+            return undefined;
+        // set the kind if there is a k tag
+        const k = getTagValue(event, "k");
+        if (k && isInteger(k))
+            pointer.kind = parseInt(k);
+        // Get the author from the p tag if not set
+        if (!pointer.author) {
+            const p = event.tags.find(isPTag);
+            if (p) {
+                const author = getProfilePointerFromPTag(p);
+                pointer.author = author.pubkey;
+                // Copy relay hints from "p" tag
+                if (author.relays)
+                    pointer.relays = mergeRelaySets(author.relays, pointer.relays);
+            }
+        }
+        return pointer;
+    });
+}
+/** Returns the AddressPointer for a reaction event */
+export function getReactionAddressPointer(event) {
+    return getOrComputeCachedValue(event, ReactionAddressPointerSymbol, () => {
+        const aTag = event.tags.find(isATag);
+        if (!aTag)
+            return undefined;
+        const pointer = getAddressPointerFromATag(aTag);
+        if (!pointer)
+            return undefined;
+        // Get extra relay hints from the p tag
+        const p = event.tags.find(isPTag);
+        if (p) {
+            const author = getProfilePointerFromPTag(p);
+            // Copy relay hints from "p" tag
+            if (author.relays)
+                pointer.relays = mergeRelaySets(author.relays, pointer.relays);
+        }
+        return pointer;
+    });
+}

package/dist/helpers/relay-discovery.d.ts

@@ -0,0 +1,87 @@
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+export declare const RELAY_DISCOVERY_KIND = 30166;
+export declare const RELAY_MONITOR_ANNOUNCEMENT_KIND = 10166;
+export type RelayDiscoveryEvent = KnownEvent<typeof RELAY_DISCOVERY_KIND>;
+export type RelayMonitorAnnouncementEvent = KnownEvent<typeof RELAY_MONITOR_ANNOUNCEMENT_KIND>;
+/**
+ * Gets the relay URL from a relay discovery event (from the `d` tag)
+ * This is the normalized relay URL or hex-encoded pubkey for non-URL relays
+ */
+export declare function getRelayDiscoveryURL(event: NostrEvent): string | undefined;
+/**
+ * Gets the round-trip time (RTT) for a specific operation type
+ * @param event - The relay discovery event
+ * @param type - The RTT type: 'open', 'read', or 'write'
+ * @returns The RTT in milliseconds, or undefined if not found
+ */
+export declare function getRelayDiscoveryRTT(event: NostrEvent, type: "open" | "read" | "write"): number | undefined;
+/**
+ * Gets the network type from a relay discovery event (from the `n` tag)
+ * Should be one of: clearnet, tor, i2p, loki
+ */
+export declare function getRelayDiscoveryNetworkType(event: NostrEvent): string | undefined;
+/**
+ * Gets all relay attributes from a relay discovery event (from `W` tags)
+ * Attributes describe the relay type/characteristics
+ */
+export declare function getRelayDiscoveryAttributes(event: NostrEvent): string[];
+/**
+ * Gets all supported NIPs from a relay discovery event (from `N` tags)
+ * Returns an array of NIP numbers as strings
+ */
+export declare function getRelayDiscoverySupportedNIPs(event: NostrEvent): string[];
+/**
+ * Gets all requirements from a relay discovery event (from `R` tags)
+ * False values are prefixed with `!` (e.g., `!payment`, `!auth`)
+ * Returns an array of requirement strings
+ */
+export declare function getRelayDiscoveryRequirements(event: NostrEvent): string[];
+/**
+ * Gets all topics from a relay discovery event (from `t` tags)
+ */
+export declare function getRelayDiscoveryTopics(event: NostrEvent): string[];
+/**
+ * Gets all accepted and unaccepted kinds from a relay discovery event (from `k` tags)
+ * Unaccepted kinds are prefixed with `!`
+ * Returns an array of kind strings
+ */
+export declare function getRelayDiscoveryAcceptedKinds(event: NostrEvent): string[];
+/**
+ * Gets the geohash from a relay discovery event (from the `g` tag)
+ * This is a NIP-52 geohash
+ */
+export declare function getRelayDiscoveryGeohash(event: NostrEvent): string | undefined;
+/**
+ * Validates that an event is a proper relay discovery event
+ * Checks that the event is kind 30166 and has the required `d` tag
+ */
+export declare function isValidRelayDiscovery(event?: NostrEvent): event is RelayDiscoveryEvent;
+/**
+ * Gets the frequency at which a monitor publishes events (from the `frequency` tag)
+ * Returns the frequency in seconds
+ */
+export declare function getMonitorFrequency(event: NostrEvent): number | undefined;
+/**
+ * Gets all timeout values from a relay monitor announcement (from `timeout` tags)
+ * Returns an array of objects with optional test type and timeout value
+ * Index 1 is the timeout in milliseconds, index 2 (optional) is the test type
+ */
+export declare function getMonitorTimeouts(event: NostrEvent): Array<{
+    test?: string;
+    timeout: number;
+}>;
+/**
+ * Gets all checks conducted by a monitor (from `c` tags)
+ * Examples include: open, read, write, auth, nip11, dns, geo
+ */
+export declare function getMonitorChecks(event: NostrEvent): string[];
+/**
+ * Gets the geohash from a relay monitor announcement (from the `g` tag)
+ * This is a NIP-52 geohash
+ */
+export declare function getMonitorGeohash(event: NostrEvent): string | undefined;
+/**
+ * Validates that an event is a proper relay monitor announcement
+ * Checks that the event is kind 10166
+ */
+export declare function isValidRelayMonitorAnnouncement(event?: NostrEvent): event is RelayMonitorAnnouncementEvent;

package/dist/helpers/relay-discovery.js

@@ -0,0 +1,126 @@
+import { getTagValue } from "applesauce-core/helpers/event";
+// NIP-66 Relay Discovery Kinds
+export const RELAY_DISCOVERY_KIND = 30166;
+export const RELAY_MONITOR_ANNOUNCEMENT_KIND = 10166;
+/**
+ * Gets the relay URL from a relay discovery event (from the `d` tag)
+ * This is the normalized relay URL or hex-encoded pubkey for non-URL relays
+ */
+export function getRelayDiscoveryURL(event) {
+    return getTagValue(event, "d");
+}
+/**
+ * Gets the round-trip time (RTT) for a specific operation type
+ * @param event - The relay discovery event
+ * @param type - The RTT type: 'open', 'read', or 'write'
+ * @returns The RTT in milliseconds, or undefined if not found
+ */
+export function getRelayDiscoveryRTT(event, type) {
+    const value = getTagValue(event, `rtt-${type}`);
+    return value ? parseInt(value, 10) : undefined;
+}
+/**
+ * Gets the network type from a relay discovery event (from the `n` tag)
+ * Should be one of: clearnet, tor, i2p, loki
+ */
+export function getRelayDiscoveryNetworkType(event) {
+    return getTagValue(event, "n");
+}
+/**
+ * Gets all relay attributes from a relay discovery event (from `W` tags)
+ * Attributes describe the relay type/characteristics
+ */
+export function getRelayDiscoveryAttributes(event) {
+    return event.tags.filter((t) => t[0] === "W" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets all supported NIPs from a relay discovery event (from `N` tags)
+ * Returns an array of NIP numbers as strings
+ */
+export function getRelayDiscoverySupportedNIPs(event) {
+    return event.tags.filter((t) => t[0] === "N" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets all requirements from a relay discovery event (from `R` tags)
+ * False values are prefixed with `!` (e.g., `!payment`, `!auth`)
+ * Returns an array of requirement strings
+ */
+export function getRelayDiscoveryRequirements(event) {
+    return event.tags.filter((t) => t[0] === "R" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets all topics from a relay discovery event (from `t` tags)
+ */
+export function getRelayDiscoveryTopics(event) {
+    return event.tags.filter((t) => t[0] === "t" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets all accepted and unaccepted kinds from a relay discovery event (from `k` tags)
+ * Unaccepted kinds are prefixed with `!`
+ * Returns an array of kind strings
+ */
+export function getRelayDiscoveryAcceptedKinds(event) {
+    return event.tags.filter((t) => t[0] === "k" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets the geohash from a relay discovery event (from the `g` tag)
+ * This is a NIP-52 geohash
+ */
+export function getRelayDiscoveryGeohash(event) {
+    return getTagValue(event, "g");
+}
+/**
+ * Validates that an event is a proper relay discovery event
+ * Checks that the event is kind 30166 and has the required `d` tag
+ */
+export function isValidRelayDiscovery(event) {
+    if (!event)
+        return false;
+    if (event.kind !== RELAY_DISCOVERY_KIND)
+        return false;
+    return !!getRelayDiscoveryURL(event);
+}
+/**
+ * Gets the frequency at which a monitor publishes events (from the `frequency` tag)
+ * Returns the frequency in seconds
+ */
+export function getMonitorFrequency(event) {
+    const value = getTagValue(event, "frequency");
+    return value ? parseInt(value, 10) : undefined;
+}
+/**
+ * Gets all timeout values from a relay monitor announcement (from `timeout` tags)
+ * Returns an array of objects with optional test type and timeout value
+ * Index 1 is the timeout in milliseconds, index 2 (optional) is the test type
+ */
+export function getMonitorTimeouts(event) {
+    return event.tags
+        .filter((t) => t[0] === "timeout" && t[1])
+        .map((t) => ({
+        timeout: parseInt(t[1], 10),
+        test: t[2] || undefined,
+    }));
+}
+/**
+ * Gets all checks conducted by a monitor (from `c` tags)
+ * Examples include: open, read, write, auth, nip11, dns, geo
+ */
+export function getMonitorChecks(event) {
+    return event.tags.filter((t) => t[0] === "c" && t[1]).map((t) => t[1]);
+}
+/**
+ * Gets the geohash from a relay monitor announcement (from the `g` tag)
+ * This is a NIP-52 geohash
+ */
+export function getMonitorGeohash(event) {
+    return getTagValue(event, "g");
+}
+/**
+ * Validates that an event is a proper relay monitor announcement
+ * Checks that the event is kind 10166
+ */
+export function isValidRelayMonitorAnnouncement(event) {
+    if (!event)
+        return false;
+    return event.kind === RELAY_MONITOR_ANNOUNCEMENT_KIND;
+}