applesauce-core 0.12.1 → 1.2.0

package/dist/helpers/__tests__/exports.test.js

@@ -0,0 +1,220 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "AUDIO_EXT",
+        "BLOSSOM_SERVER_LIST_KIND",
+        "BookmarkHiddenSymbol",
+        "BookmarkPublicSymbol",
+        "COMMENT_KIND",
+        "ChannelMetadataSymbol",
+        "CommentReplyPointerSymbol",
+        "CommentRootPointerSymbol",
+        "ContactsRelaysSymbol",
+        "EventContentEncryptionMethod",
+        "EventIndexableTagsSymbol",
+        "EventUIDSymbol",
+        "FAVORITE_RELAYS_KIND",
+        "FromCacheSymbol",
+        "GROUPS_LIST_KIND",
+        "GROUP_MESSAGE_KIND",
+        "GiftWrapEventSymbol",
+        "GiftWrapSealSymbol",
+        "GroupsHiddenSymbol",
+        "GroupsPublicSymbol",
+        "HiddenContactsSymbol",
+        "HiddenContentSymbol",
+        "HiddenTagsSymbol",
+        "IMAGE_EXT",
+        "LRU",
+        "MailboxesInboxesSymbol",
+        "MailboxesOutboxesSymbol",
+        "MediaAttachmentsSymbol",
+        "MuteHiddenSymbol",
+        "MutePublicSymbol",
+        "NIP05_REGEX",
+        "Nip10ThreadRefsSymbol",
+        "PICTURE_POST_KIND",
+        "ProfileContentSymbol",
+        "PublicContactsSymbol",
+        "ReplaceableIdentifierSymbol",
+        "STREAM_EXT",
+        "SeenRelaysSymbol",
+        "SharedEventSymbol",
+        "UserStatusPointerSymbol",
+        "VIDEO_EXT",
+        "ZapAddressPointerSymbol",
+        "ZapEventPointerSymbol",
+        "ZapFromSymbol",
+        "ZapInvoiceSymbol",
+        "ZapRequestSymbol",
+        "addSeenRelay",
+        "areBlossomServersEqual",
+        "canHaveHiddenContent",
+        "canHaveHiddenTags",
+        "convertToUrl",
+        "createMutedWordsRegExp",
+        "createReplaceableAddress",
+        "decodeGroupPointer",
+        "decodeLNURL",
+        "decryptDirectMessage",
+        "encodeDecodeResult",
+        "encodeGroupPointer",
+        "fakeVerifyEvent",
+        "getAddressPointerForEvent",
+        "getAddressPointerFromATag",
+        "getAddressPointersFromList",
+        "getBlossomServersFromList",
+        "getBookmarks",
+        "getCachedValue",
+        "getChannelMetadataContent",
+        "getChannelPointer",
+        "getCommentAddressPointer",
+        "getCommentEventPointer",
+        "getCommentExternalPointer",
+        "getCommentReplyPointer",
+        "getCommentRootPointer",
+        "getContacts",
+        "getContentWarning",
+        "getCoordinateFromAddressPointer",
+        "getDeleteCoordinates",
+        "getDeleteIds",
+        "getDisplayName",
+        "getEmojiTag",
+        "getEmojis",
+        "getEventPointerForEvent",
+        "getEventPointerFromETag",
+        "getEventPointerFromQTag",
+        "getEventPointerFromThreadTag",
+        "getEventPointersFromList",
+        "getEventUID",
+        "getExternalPointerFromTag",
+        "getFileMetadata",
+        "getFileMetadataFromImetaTag",
+        "getGiftWrapEvent",
+        "getGiftWrapSeal",
+        "getGroupPointerFromGroupTag",
+        "getHashtagTag",
+        "getHiddenBookmarks",
+        "getHiddenContacts",
+        "getHiddenContent",
+        "getHiddenContentEncryptionMethods",
+        "getHiddenGroups",
+        "getHiddenMutedThings",
+        "getHiddenTags",
+        "getHiddenTagsEncryptionMethods",
+        "getInboxes",
+        "getIndexableTags",
+        "getInvoice",
+        "getListTags",
+        "getMediaAttachments",
+        "getMutedThings",
+        "getNip10References",
+        "getOrComputeCachedValue",
+        "getOutboxes",
+        "getPackName",
+        "getParentEventStore",
+        "getPicturePostAttachments",
+        "getPointerForEvent",
+        "getPointerFromTag",
+        "getProfileContent",
+        "getProfilePointerFromPTag",
+        "getProfilePointersFromList",
+        "getPubkeyFromDecodeResult",
+        "getPublicBookmarks",
+        "getPublicContacts",
+        "getPublicGroups",
+        "getPublicMutedThings",
+        "getRelaysFromContactsEvent",
+        "getRelaysFromList",
+        "getReplaceableAddress",
+        "getReplaceableIdentifier",
+        "getReplaceableUID",
+        "getSeenRelays",
+        "getSha256FromURL",
+        "getTagValue",
+        "getURLFilename",
+        "getUserStatusPointer",
+        "getZapAddressPointer",
+        "getZapEventPointer",
+        "getZapPayment",
+        "getZapPreimage",
+        "getZapRecipient",
+        "getZapRequest",
+        "getZapSender",
+        "getZapSplits",
+        "hasHiddenContent",
+        "hasHiddenTags",
+        "interpretThreadTags",
+        "isATag",
+        "isAddressPointer",
+        "isAddressPointerInList",
+        "isAudioURL",
+        "isCommentAddressPointer",
+        "isCommentEventPointer",
+        "isDTag",
+        "isETag",
+        "isEvent",
+        "isEventPointer",
+        "isEventPointerInList",
+        "isFilterEqual",
+        "isFromCache",
+        "isGiftWrapLocked",
+        "isHex",
+        "isHexKey",
+        "isHiddenContentLocked",
+        "isHiddenTagsLocked",
+        "isImageURL",
+        "isNameValueTag",
+        "isNip05",
+        "isPTag",
+        "isProfilePointerInList",
+        "isRTag",
+        "isReplaceable",
+        "isSafeRelayURL",
+        "isSameURL",
+        "isSha256",
+        "isStreamURL",
+        "isTTag",
+        "isValidList",
+        "isValidProfile",
+        "isValidZap",
+        "isVideoURL",
+        "lockHiddenContent",
+        "lockHiddenTags",
+        "markFromCache",
+        "matchFilter",
+        "matchFilters",
+        "matchMutes",
+        "mergeBlossomServers",
+        "mergeBookmarks",
+        "mergeContacts",
+        "mergeFilters",
+        "mergeMutes",
+        "mergeRelaySets",
+        "normalizeURL",
+        "parseBolt11",
+        "parseBookmarkTags",
+        "parseCoordinate",
+        "parseExternalPointer",
+        "parseFileMetadataTags",
+        "parseLNURLOrAddress",
+        "parseLightningAddress",
+        "parseMutedTags",
+        "parseNIP05Address",
+        "parseSharedEvent",
+        "processTags",
+        "safeParse",
+        "setCachedValue",
+        "setEventContentEncryptionMethod",
+        "stripInvisibleChar",
+        "unixNow",
+        "unlockGiftWrap",
+        "unlockHiddenContent",
+        "unlockHiddenTags",
+      ]
+    `);
+    });
+});

package/dist/helpers/__tests__/mutes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/mutes.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { matchMutes } from "../mutes.js";
+import { FakeUser } from "../../__tests__/fixtures.js";
+const mutedUser = new FakeUser();
+const nonMutedUser = new FakeUser();
+const thread = nonMutedUser.note("Hello world");
+// Create a mutes object with a pubkey to mute
+const mutes = {
+    pubkeys: new Set([mutedUser.pubkey]),
+    threads: new Set([thread.id]),
+    hashtags: new Set(["nostr"]),
+    words: new Set(["GM"]),
+};
+describe("matchMutes", () => {
+    it("should match events with muted pubkeys", () => {
+        const mutedEvent = mutedUser.note("Hello world");
+        const nonMutedEvent = nonMutedUser.note("Hello world");
+        // The event with the muted pubkey should match
+        expect(matchMutes(mutes, mutedEvent)).toBe(true);
+        // The event with a different pubkey should not match
+        expect(matchMutes(mutes, nonMutedEvent)).toBe(false);
+    });
+    it("should match events with muted hashtags", () => {
+        // Create events with and without the muted hashtag
+        const eventWithMutedHashtag = nonMutedUser.note("Hello world");
+        eventWithMutedHashtag.tags.push(["t", "nostr"]);
+        const eventWithDifferentHashtag = nonMutedUser.note("Hello world");
+        eventWithDifferentHashtag.tags.push(["t", "bitcoin"]);
+        const eventWithNoHashtag = nonMutedUser.note("Hello world");
+        // The event with the muted hashtag should match
+        expect(matchMutes(mutes, eventWithMutedHashtag)).toBe(true);
+        // The events without the muted hashtag should not match
+        expect(matchMutes(mutes, eventWithDifferentHashtag)).toBe(false);
+        expect(matchMutes(mutes, eventWithNoHashtag)).toBe(false);
+    });
+    it("should match events within threads", () => {
+        // Create a reply to the thread
+        const reply = nonMutedUser.note("Hello world");
+        reply.tags.push(["e", thread.id, "", "root"]);
+        // The reply should match the mute
+        expect(matchMutes(mutes, reply)).toBe(true);
+        // The thread should not match the mute
+        expect(matchMutes(mutes, thread)).toBe(false);
+    });
+    it("should match events with muted words", () => {
+        // The event with the muted word should match
+        expect(matchMutes(mutes, nonMutedUser.note("GM"))).toBe(true);
+        // Should not match other words that contain the muted word
+        expect(matchMutes(mutes, nonMutedUser.note("GMing"))).toBe(false);
+        // Should be case-insensitive
+        expect(matchMutes(mutes, nonMutedUser.note("gm"))).toBe(true);
+        // Should match if the muted word
+        expect(matchMutes(mutes, nonMutedUser.note("Hello GM world"))).toBe(true);
+    });
+});

package/dist/helpers/blossom.d.ts

@@ -7,3 +7,5 @@ export declare function isSha256(str: string): boolean;
 export declare function getBlossomServersFromList(event: {
     tags: string[][];
 } | string[][]): URL[];
+/** A method that merges multiple arrays of blossom servers into a single array of unique servers */
+export declare function mergeBlossomServers<T extends URL | string | (string | URL)>(...servers: (T | null | undefined | T[])[]): T[];

package/dist/helpers/blossom.js

@@ -20,3 +20,21 @@ export function getBlossomServersFromList(event) {
             return undefined;
     });
 }
+/** A method that merges multiple arrays of blossom servers into a single array of unique servers */
+export function mergeBlossomServers(...servers) {
+    let merged = [];
+    const seen = new Set();
+    for (const arg of servers) {
+        let arr = Array.isArray(arg) ? arg : [arg];
+        for (const s of arr) {
+            if (s === null || s === undefined)
+                continue;
+            const key = new URL("/", s).toString();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            merged.push(s);
+        }
+    }
+    return merged;
+}

package/dist/helpers/bookmarks.d.ts

@@ -8,8 +8,13 @@ export type Bookmarks = {
     hashtags: string[];
     urls: string[];
 };
+/** Parses an array of tags into a {@link Bookmarks} object */
 export declare function parseBookmarkTags(tags: string[][]): Bookmarks;
-/** Returns the public bookmarks of the event */
+/** Merges any number of {@link Bookmarks} objects */
+export declare function mergeBookmarks(...bookmarks: (Bookmarks | undefined)[]): Bookmarks;
+/** Returns all the bookmarks of the event */
 export declare function getBookmarks(bookmark: NostrEvent): Bookmarks;
+/** Returns the public bookmarks of the event */
+export declare function getPublicBookmarks(bookmark: NostrEvent): Bookmarks;
 /** Returns the bookmarks of the event if its unlocked */
 export declare function getHiddenBookmarks(bookmark: NostrEvent): Bookmarks | undefined;

package/dist/helpers/bookmarks.js

@@ -1,9 +1,11 @@
 import { kinds } from "nostr-tools";
-import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags } from "./index.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
+import { mergeAddressPointers, mergeEventPointers } from "./nip-19.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag } from "./pointers.js";
 export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
 export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+/** Parses an array of tags into a {@link Bookmarks} object */
 export function parseBookmarkTags(tags) {
     const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
     const articles = tags
@@ -14,14 +16,57 @@ export function parseBookmarkTags(tags) {
     const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
     return { notes, articles, hashtags, urls };
 }
-/** Returns the public bookmarks of the event */
+/** Merges any number of {@link Bookmarks} objects */
+export function mergeBookmarks(...bookmarks) {
+    const notes = new Map();
+    const articles = new Map();
+    const hashtags = new Set();
+    const urls = new Set();
+    for (const bookmark of bookmarks) {
+        if (!bookmark)
+            continue;
+        for (const note of bookmark.notes) {
+            const existing = notes.get(note.id);
+            if (existing)
+                notes.set(note.id, mergeEventPointers(existing, note));
+            else
+                notes.set(note.id, note);
+        }
+        for (const article of bookmark.articles) {
+            const coord = getCoordinateFromAddressPointer(article);
+            const existing = articles.get(coord);
+            if (existing)
+                articles.set(coord, mergeAddressPointers(existing, article));
+            else
+                articles.set(coord, article);
+        }
+        for (const hashtag of bookmark.hashtags)
+            hashtags.add(hashtag);
+        for (const url of bookmark.urls)
+            urls.add(url);
+    }
+    return {
+        notes: Array.from(notes.values()),
+        articles: Array.from(articles.values()),
+        hashtags: Array.from(hashtags),
+        urls: Array.from(urls),
+    };
+}
+/** Returns all the bookmarks of the event */
 export function getBookmarks(bookmark) {
+    const hidden = getHiddenBookmarks(bookmark);
+    if (hidden)
+        return mergeBookmarks(hidden, getPublicBookmarks(bookmark));
+    else
+        return getPublicBookmarks(bookmark);
+}
+/** Returns the public bookmarks of the event */
+export function getPublicBookmarks(bookmark) {
     return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
 }
 /** Returns the bookmarks of the event if its unlocked */
 export function getHiddenBookmarks(bookmark) {
-    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
-        const tags = getHiddenTags(bookmark);
-        return tags && parseBookmarkTags(tags);
-    });
+    if (isHiddenTagsLocked(bookmark))
+        return undefined;
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => parseBookmarkTags(getHiddenTags(bookmark)));
 }

package/dist/helpers/comment.d.ts

@@ -2,20 +2,24 @@ import { NostrEvent } from "nostr-tools";
 import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
 export declare const COMMENT_KIND = 1111;
 export type CommentEventPointer = {
+    type: "event";
     id: string;
     kind: number;
     pubkey?: string;
     relay?: string;
 };
 export type CommentAddressPointer = {
+    type: "address";
     id?: string;
     kind: number;
     pubkey: string;
     identifier: string;
     relay?: string;
 };
-export type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
-export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
+export type CommentExternalPointer<T extends keyof ExternalIdentifiers> = ExternalPointer<T> & {
+    type: "external";
+};
+export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer<keyof ExternalIdentifiers>;
 export declare const CommentRootPointerSymbol: unique symbol;
 export declare const CommentReplyPointerSymbol: unique symbol;
 /**
@@ -32,7 +36,7 @@ export declare function getCommentAddressPointer(tags: string[][], root?: boolea
  * Gets the ExternalPointer from an array of tags
  * @throws
  */
-export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer | null;
+export declare function getCommentExternalPointer(tags: string[][], root?: boolean): CommentExternalPointer<keyof ExternalIdentifiers> | null;
 /**
  * Returns the root pointer for a comment
  * @throws

package/dist/helpers/comment.js

@@ -18,6 +18,7 @@ export function getCommentEventPointer(tags, root = false) {
         // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
         const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
         const pointer = {
+            type: "event",
             id: eTag[1],
             kind: parseInt(kind),
             pubkey: eTag[3] || rootPubkey || undefined,
@@ -40,6 +41,7 @@ export function getCommentAddressPointer(tags, root = false) {
             throw new Error("Missing kind tag");
         const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
+            type: "address",
             id: eTag?.[1],
             pubkey: addressPointer.pubkey,
             identifier: addressPointer.identifier,
@@ -60,7 +62,10 @@ export function getCommentExternalPointer(tags, root = false) {
     if (iTag) {
         if (!kind)
             throw new Error("Missing kind tag");
-        return getExternalPointerFromTag(iTag);
+        return {
+            type: "external",
+            ...getExternalPointerFromTag(iTag),
+        };
     }
     return null;
 }

package/dist/helpers/contacts.d.ts

@@ -1,3 +1,14 @@
 import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
 export declare const ContactsRelaysSymbol: unique symbol;
+export declare const PublicContactsSymbol: unique symbol;
+export declare const HiddenContactsSymbol: unique symbol;
 export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;
+/** Merges any number of contact lists into a single list */
+export declare function mergeContacts(...pointers: (ProfilePointer | undefined | (ProfilePointer | undefined)[])[]): ProfilePointer[];
+/** Returns all public and hidden contacts from a contacts list event */
+export declare function getContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the public contacts from a contacts list event */
+export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
+/** Returns only the hidden contacts from a contacts list event */
+export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;

package/dist/helpers/contacts.js

@@ -1,6 +1,11 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isPTag, processTags } from "./tags.js";
+import { getProfilePointerFromPTag } from "./pointers.js";
+import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
 export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
+export const PublicContactsSymbol = Symbol.for("public-contacts");
+export const HiddenContactsSymbol = Symbol.for("hidden-contacts");
 export function getRelaysFromContactsEvent(event) {
     return getOrComputeCachedValue(event, ContactsRelaysSymbol, () => {
         try {
@@ -23,3 +28,32 @@ export function getRelaysFromContactsEvent(event) {
         }
     });
 }
+/** Merges any number of contact lists into a single list */
+export function mergeContacts(...pointers) {
+    const merged = new Map();
+    for (const arr of pointers) {
+        if (Array.isArray(arr)) {
+            for (const pointer of arr)
+                if (pointer)
+                    merged.set(pointer.pubkey, pointer);
+        }
+        else if (arr) {
+            merged.set(arr.pubkey, arr);
+        }
+    }
+    return Array.from(merged.values());
+}
+/** Returns all public and hidden contacts from a contacts list event */
+export function getContacts(event) {
+    return mergeContacts(getPublicContacts(event), getHiddenContacts(event));
+}
+/** Returns only the public contacts from a contacts list event */
+export function getPublicContacts(event) {
+    return getOrComputeCachedValue(event, PublicContactsSymbol, () => processTags(event.tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}
+/** Returns only the hidden contacts from a contacts list event */
+export function getHiddenContacts(event) {
+    if (isHiddenTagsLocked(event))
+        return undefined;
+    return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+}

package/dist/helpers/event.d.ts

@@ -24,11 +24,16 @@ export declare function isReplaceable(kind: number): boolean;
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export declare function getEventUID(event: NostrEvent): string;
-export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
+/** Returns the replaceable event address for an addressable event */
+export declare function getReplaceableAddress(event: NostrEvent): string;
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export declare function createReplaceableAddress(kind: number, pubkey: string, identifier?: string): string;
+/** @deprecated use createReplaceableAddress instead */
+export declare const getReplaceableUID: typeof createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
 /**

package/dist/helpers/event.js

@@ -1,8 +1,8 @@
-import { kinds, verifiedSymbol } from "nostr-tools";
+import { verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
 import { getOrComputeCachedValue } from "./cache.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { EventStoreSymbol } from "../event-store/event-store.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
@@ -29,30 +29,38 @@ export function isEvent(event) {
  * or parameterized replaceable ( 30000 <= n < 40000 )
  */
 export function isReplaceable(kind) {
-    return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
+    return isReplaceableKind(kind) || isAddressableKind(kind);
 }
 /**
  * Returns the events Unique ID
  * For normal or ephemeral events this is ( event.id )
- * For replaceable events this is ( event.kind + ":" + event.pubkey )
- * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
+ * For replaceable events this is ( event.kind + ":" + event.pubkey + ":" )
+ * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export function getEventUID(event) {
     let uid = event[EventUIDSymbol];
     if (!uid) {
-        if (isReplaceable(event.kind)) {
-            let d = event.tags.find((t) => t[0] === "d")?.[1];
-            uid = getReplaceableUID(event.kind, event.pubkey, d);
-        }
+        if (isReplaceable(event.kind))
+            uid = getReplaceableAddress(event);
         else
             uid = event.id;
         event[EventUIDSymbol] = uid;
     }
     return uid;
 }
-export function getReplaceableUID(kind, pubkey, d) {
-    return d ? kind + ":" + pubkey + ":" + d : kind + ":" + pubkey;
+/** Returns the replaceable event address for an addressable event */
+export function getReplaceableAddress(event) {
+    if (!isReplaceable(event.kind))
+        throw new Error("Event is not replaceable or addressable");
+    const identifier = isAddressableKind(event.kind) ? getReplaceableIdentifier(event) : undefined;
+    return createReplaceableAddress(event.kind, event.pubkey, identifier);
+}
+/** Creates a replaceable event address from a kind, pubkey, and identifier */
+export function createReplaceableAddress(kind, pubkey, identifier) {
+    return kind + ":" + pubkey + ":" + (identifier ?? "");
 }
+/** @deprecated use createReplaceableAddress instead */
+export const getReplaceableUID = createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
     let indexable = event[EventIndexableTagsSymbol];
@@ -100,8 +108,8 @@ export function getParentEventStore(event) {
  * @throws
  */
 export function getReplaceableIdentifier(event) {
-    if (!isParameterizedReplaceableKind(event.kind))
-        throw new Error("Event is not replaceable");
+    if (!isAddressableKind(event.kind))
+        throw new Error("Event is not addressable");
     return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
         const d = getTagValue(event, "d");
         if (d === undefined)