applesauce-core 1.2.0 → 2.1.0

package/dist/helpers/app-handlers.js

@@ -0,0 +1,68 @@
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, } from "nostr-tools/nip19";
+import { processTags } from "./tags.js";
+import { getDisplayName, getProfileContent, getProfilePicture, isValidProfile } from "./profile.js";
+import { isAddressPointer, isEventPointer } from "./pointers.js";
+/** Returns an array of supported kinds for a given handler */
+export function getHandlerSupportedKinds(handler) {
+    return processTags(handler.tags, (t) => (t[0] === "k" && t[1] ? parseInt(t[1]) : undefined));
+}
+/** Returns the name of the handler */
+export function getHandlerName(handler) {
+    return getDisplayName(handler);
+}
+/** Returns the picture of the handler */
+export function getHandlerPicture(handler, fallback) {
+    if (!isValidProfile(handler))
+        return fallback;
+    return getProfilePicture(handler, fallback);
+}
+/** Returns the description of the handler */
+export function getHandlerDescription(handler) {
+    if (!isValidProfile(handler))
+        return;
+    return getProfileContent(handler).about;
+}
+/** Returns the web link template for a handler and type */
+export function getHandlerLinkTemplate(handler, platform = "web", type) {
+    // Get all tags for this platform
+    const tags = handler.tags.filter((t) => t[0] === platform);
+    // Find the tag for this type, otherwise use default
+    if (type)
+        return tags.find((t) => t[2] === type)?.[1];
+    else
+        return tags.find((t) => t[2] === undefined || t[2] === "")?.[1];
+}
+/** Returns a link for a Profile Pointer */
+export function createHandlerProfileLink(handler, pointer, platform = "web") {
+    // First attempt to use a nprofile link, then fallback to npub
+    return (getHandlerLinkTemplate(handler, platform, "nprofile")?.replace("<bech32>", nprofileEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform, "npub")?.replace("<bech32>", npubEncode(pointer.pubkey)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", nprofileEncode(pointer)));
+}
+/** Returns a link for an Event Pointer */
+export function createHandlerEventLink(handler, pointer, platform = "web") {
+    // First attempt to use a nevent link, then fallback to note
+    return (getHandlerLinkTemplate(handler, platform, "nevent")?.replace("<bech32>", neventEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform, "note")?.replace("<bech32>", noteEncode(pointer.id)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", neventEncode(pointer)));
+}
+/** Returns a link for an Address Pointer */
+export function createHandlerAddressLink(handler, pointer, platform = "web") {
+    // First attempt to use a nevent link, then fallback to note
+    return (getHandlerLinkTemplate(handler, platform, "naddr")?.replace("<bech32>", naddrEncode(pointer)) ||
+        getHandlerLinkTemplate(handler, platform)?.replace("<bech32>", naddrEncode(pointer)));
+}
+/** Creates a handler link for a pointer and optionally fallsback to a web link */
+export function createHandlerLink(handler, pointer, platform, webFallback = true) {
+    let link = undefined;
+    if (isEventPointer(pointer))
+        link = createHandlerEventLink(handler, pointer, platform);
+    else if (isAddressPointer(pointer))
+        link = createHandlerAddressLink(handler, pointer, platform);
+    else
+        link = createHandlerProfileLink(handler, pointer, platform);
+    // Fallback to a web link if one cant be found for the platform
+    if (!link && platform && platform !== "web" && webFallback)
+        link = createHandlerLink(handler, pointer, "web");
+    return link;
+}

package/dist/helpers/article.d.ts

@@ -0,0 +1,9 @@
+import { NostrEvent } from "nostr-tools";
+/** Returns an articles title, if it exists */
+export declare function getArticleTitle(article: NostrEvent): string | undefined;
+/** Returns an articles image, if it exists */
+export declare function getArticleImage(article: NostrEvent): string | undefined;
+/** Returns an articles summary, if it exists */
+export declare function getArticleSummary(article: NostrEvent): string | undefined;
+/** Returns an articles published date, if it exists */
+export declare function getArticlePublished(article: NostrEvent): number;

package/dist/helpers/article.js

@@ -0,0 +1,21 @@
+import { getTagValue } from "./event.js";
+/** Returns an articles title, if it exists */
+export function getArticleTitle(article) {
+    return getTagValue(article, "title");
+}
+/** Returns an articles image, if it exists */
+export function getArticleImage(article) {
+    return getTagValue(article, "image");
+}
+/** Returns an articles summary, if it exists */
+export function getArticleSummary(article) {
+    return getTagValue(article, "summary");
+}
+/** Returns an articles published date, if it exists */
+export function getArticlePublished(article) {
+    const ts = getTagValue(article, "published_at");
+    if (ts && !Number.isNaN(parseInt(ts)))
+        return parseInt(ts);
+    else
+        return article.created_at;
+}

package/dist/helpers/bolt11.d.ts

@@ -4,6 +4,7 @@ export type ParsedInvoice = {
     amount?: number;
     timestamp: number;
     expiry: number;
+    paymentHash?: string;
 };
 /** Parses a lightning invoice */
 export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -5,11 +5,13 @@ export function parseBolt11(paymentRequest) {
     const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;
     const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
     const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    const paymentHash = decoded.sections.find((s) => s.name === "payment_hash");
     return {
         paymentRequest: decoded.paymentRequest,
         description: description,
         amount: amount,
         timestamp: timestamp,
         expiry: timestamp + decoded.expiry,
+        paymentHash: paymentHash?.value,
     };
 }

package/dist/helpers/bookmarks.js

@@ -1,8 +1,7 @@
 import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getHiddenTags, isHiddenTagsLocked } from "./index.js";
-import { mergeAddressPointers, mergeEventPointers } from "./nip-19.js";
-import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag } from "./pointers.js";
+import { getAddressPointerFromATag, getCoordinateFromAddressPointer, getEventPointerFromETag, mergeAddressPointers, mergeEventPointers, } 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 */

package/dist/helpers/emoji.d.ts

@@ -1,6 +1,12 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
+import { NostrEvent } from "nostr-tools";
 /** Gets an "emoji" tag that matches an emoji code */
-export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string] | undefined;
+export declare function getEmojiTag(tags: {
+    tags: string[][];
+} | string[][], code: string): ["emoji", string, string] | undefined;
+/** Gets an emoji for a shortcode from an array of tags or event */
+export declare function getEmojiFromTags(event: {
+    tags: string[][];
+} | string[][], code: string): Emoji | undefined;
 /** Returns the name of a NIP-30 emoji pack */
 export declare function getPackName(pack: NostrEvent): string | undefined;
 export type Emoji = {
@@ -11,3 +17,5 @@ export type Emoji = {
 };
 /** Returns an array of emojis from a NIP-30 emoji pack */
 export declare function getEmojis(pack: NostrEvent): Emoji[];
+/** Returns the custom emoji for a reaction event */
+export declare function getReactionEmoji(event: NostrEvent): Emoji | undefined;

package/dist/helpers/emoji.js

@@ -1,8 +1,18 @@
 import { getTagValue } from "./event.js";
 /** Gets an "emoji" tag that matches an emoji code */
-export function getEmojiTag(event, code) {
-    code = code.replace(/^:|:$/g, "").toLocaleLowerCase();
-    return event.tags.find((t) => t[0] === "emoji" && t.length >= 3 && t[1].toLowerCase() === code);
+export function getEmojiTag(tags, code) {
+    code = code.replace(/^:|:$/g, "").toLowerCase();
+    return (Array.isArray(tags) ? tags : tags.tags).find((t) => t[0] === "emoji" && t.length >= 3 && t[1].toLowerCase() === code);
+}
+/** Gets an emoji for a shortcode from an array of tags or event */
+export function getEmojiFromTags(event, code) {
+    const tag = getEmojiTag(event, code);
+    if (!tag)
+        return undefined;
+    return {
+        shortcode: tag[1],
+        url: tag[2],
+    };
 }
 /** Returns the name of a NIP-30 emoji pack */
 export function getPackName(pack) {
@@ -14,3 +24,11 @@ export function getEmojis(pack) {
         .filter((t) => t[0] === "emoji" && t[1] && t[2])
         .map((t) => ({ shortcode: t[1], url: t[2] }));
 }
+/** Returns the custom emoji for a reaction event */
+export function getReactionEmoji(event) {
+    // Trim and strip colons
+    const shortcode = /^:+(.+?):+$/g.exec(event.content.trim().toLowerCase())?.[1];
+    if (!shortcode)
+        return undefined;
+    return getEmojiFromTags(event, shortcode);
+}

package/dist/helpers/encrypted-content-cache.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from "rxjs";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/** A symbol that is used to mark encrypted content as being from a cache */
+export declare const EncryptedContentFromCacheSymbol: unique symbol;
+/** An interface that is used to cache encrypted content on events */
+export interface EncryptedContentCache {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<any>;
+}
+/** Marks the encrypted content as being from a cache */
+export declare function markEncryptedContentFromCache<T extends object>(event: T): void;
+/** Checks if the encrypted content is from a cache */
+export declare function isEncryptedContentFromCache<T extends object>(event: T): boolean;
+/** Starts a process that persists and restores all encrypted content */
+export declare function persistEncryptedContent(eventStore: IEventStoreStreams, storage: EncryptedContentCache | Observable<EncryptedContentCache>): () => void;

package/dist/helpers/encrypted-content-cache.js

@@ -0,0 +1,125 @@
+import { kinds } from "nostr-tools";
+import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map, merge, mergeMap, of, switchMap, } from "rxjs";
+import { logger } from "../logger.js";
+import { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentLocked, setEncryptedContentCache, } from "./encrypted-content.js";
+import { notifyEventUpdate } from "./event.js";
+import { getGiftWrapSeal } from "./gift-wraps.js";
+/** A symbol that is used to mark encrypted content as being from a cache */
+export const EncryptedContentFromCacheSymbol = Symbol.for("encrypted-content-from-cache");
+/** Marks the encrypted content as being from a cache */
+export function markEncryptedContentFromCache(event) {
+    Reflect.set(event, EncryptedContentFromCacheSymbol, true);
+}
+/** Checks if the encrypted content is from a cache */
+export function isEncryptedContentFromCache(event) {
+    return Reflect.has(event, EncryptedContentFromCacheSymbol);
+}
+const log = logger.extend("EncryptedContentCache");
+/** Starts a process that persists and restores all encrypted content */
+export function persistEncryptedContent(eventStore, storage) {
+    const storage$ = isObservable(storage) ? storage : of(storage);
+    // Restore encrypted content when it is inserted
+    const restore = eventStore.insert$
+        .pipe(
+    // Look for events that support encrypted content and are locked
+    filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentLocked(e)), 
+    // Get the encrypted content from storage
+    mergeMap((event) => 
+    // Wait for storage to be available
+    storage$.pipe(switchMap((storage) => combineLatest([of(event), storage.getItem(event.id)])), catchError((error) => {
+        log(`Failed to restore encrypted content for ${event.id}`, error);
+        return EMPTY;
+    }))))
+        .subscribe(async ([event, content]) => {
+        if (!content)
+            return;
+        // Restore the encrypted content and set it as from a cache
+        markEncryptedContentFromCache(event);
+        setEncryptedContentCache(event, content);
+        log(`Restored encrypted content for ${event.id}`);
+    });
+    // Restore seals when they are unlocked
+    const restoreSeals = eventStore.update$
+        .pipe(
+    // Look for gift wraps that are unlocked
+    filter((e) => e.kind === kinds.GiftWrap && !isEncryptedContentLocked(e)), 
+    // Get the seal event
+    map((gift) => [gift, getGiftWrapSeal(gift)]), 
+    // Look for gift wraps with locked seals
+    filter(([_gift, seal]) => seal !== undefined && isEncryptedContentLocked(seal)), 
+    // Only attempt to unlock seals once
+    distinct(([_gift, seal]) => seal.id), 
+    // Get encrypted content from storage
+    mergeMap(([gift, seal]) => 
+    // Wait for storage to be available
+    storage$.pipe(switchMap((storage) => combineLatest([of(gift), of(seal), storage.getItem(seal.id)])), catchError((error) => {
+        log(`Failed to restore encrypted content for ${seal.id}`, error);
+        return EMPTY;
+    }))))
+        .subscribe(async ([gift, seal, content]) => {
+        if (!seal || !content)
+            return;
+        markEncryptedContentFromCache(seal);
+        setEncryptedContentCache(seal, content);
+        // Trigger an update to the gift wrap event
+        notifyEventUpdate(gift);
+        log(`Restored encrypted content for ${seal.id}`);
+    });
+    // Persist encrypted content when it is updated or inserted
+    const persist = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
+        .pipe(
+    // Look for events that support encrypted content and are unlocked and not from the cache
+    filter(([event]) => canHaveEncryptedContent(event.kind) &&
+        !isEncryptedContentLocked(event) &&
+        !isEncryptedContentFromCache(event)), 
+    // Only persist the encrypted content once
+    distinct(([event]) => event.id))
+        .subscribe(async ([event, storage]) => {
+        try {
+            const content = getEncryptedContent(event);
+            if (content) {
+                await storage.setItem(event.id, content);
+                log(`Persisted encrypted content for ${event.id}`);
+            }
+        }
+        catch (error) {
+            // Ignore errors when saving encrypted content
+            log(`Failed to persist encrypted content for ${event.id}`, error);
+        }
+    });
+    // Persist seals when the gift warp is unlocked or inserted unlocked
+    // This relies on the gift wrap event being updated when a seal is unlocked
+    const persistSeals = combineLatest([merge(eventStore.update$, eventStore.insert$), storage$])
+        .pipe(
+    // Look for gift wraps that are unlocked
+    filter(([event]) => event.kind === kinds.GiftWrap && !isEncryptedContentLocked(event)), 
+    // Get the seal event
+    map(([gift, storage]) => [gift, getGiftWrapSeal(gift), storage]), 
+    // Make sure the seal is defined
+    filter(([_gift, seal]) => seal !== undefined), 
+    // Make sure seal is unlocked and not from cache
+    filter(([_gift, seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
+    // Only persist the seal once
+    distinct(([seal]) => seal.id))
+        .subscribe(async ([_gift, seal, storage]) => {
+        if (!seal)
+            return;
+        try {
+            const content = getEncryptedContent(seal);
+            if (content) {
+                await storage.setItem(seal.id, content);
+                log(`Persisted encrypted content for ${seal.id}`);
+            }
+        }
+        catch (error) {
+            // Ignore errors when saving encrypted content
+            log(`Failed to persist encrypted content for ${seal.id}`, error);
+        }
+    });
+    return () => {
+        restore.unsubscribe();
+        persist.unsubscribe();
+        restoreSeals.unsubscribe();
+        persistSeals.unsubscribe();
+    };
+}

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

@@ -0,0 +1,48 @@
+/** A symbol use to store the encrypted content of an event in memory */
+export declare const EncryptedContentSymbol: unique symbol;
+export interface EncryptedContentSigner {
+    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 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 setEncryptedContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+/** Returns either nip04 or nip44 encryption methods depending on event kind */
+export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner): {
+    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;
+};
+/** Checks if an event can have encrypted content */
+export declare function canHaveEncryptedContent(kind: number): boolean;
+/** Checks if an event has encrypted content */
+export declare function hasEncryptedContent<T extends {
+    content: string;
+}>(event: T): boolean;
+/** Returns the encrypted content for an event if it is unlocked */
+export declare function getEncryptedContent<T extends object>(event: T): string | undefined;
+/** Checks if the encrypted content is locked */
+export declare function isEncryptedContentLocked<T extends object>(event: T): boolean;
+/**
+ * Unlocks the encrypted content in an event and caches it
+ * @param event The event with content to decrypt
+ * @param pubkey The other pubkey that encrypted the content
+ * @param signer A signer to use to decrypt the content
+ */
+export declare function unlockEncryptedContent<T extends {
+    kind: number;
+    content: string;
+}>(event: T, pubkey: string, signer: EncryptedContentSigner): Promise<string>;
+/** Sets the encrypted content on an event and updates it if its part of an event store */
+export declare function setEncryptedContentCache<T extends object>(event: T, plaintext: string): void;
+/** Removes the encrypted content cache on an event */
+export declare function lockEncryptedContent<T extends object>(event: T): void;

package/dist/helpers/encrypted-content.js

@@ -0,0 +1,65 @@
+import { kinds } from "nostr-tools";
+import { isEvent, notifyEventUpdate } from "./event.js";
+/** A symbol use to store the encrypted content of an event in memory */
+export const EncryptedContentSymbol = Symbol.for("encrypted-content");
+/** Various event kinds that can have encrypted content and which encryption method they use */
+export const EventContentEncryptionMethod = {
+    [kinds.EncryptedDirectMessage]: "nip04",
+    [kinds.Seal]: "nip44",
+    [kinds.GiftWrap]: "nip44",
+};
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export function setEncryptedContentEncryptionMethod(kind, method) {
+    EventContentEncryptionMethod[kind] = method;
+    return kind;
+}
+/** Returns either nip04 or nip44 encryption methods depending on event kind */
+export function getEncryptedContentEncryptionMethods(kind, signer) {
+    const method = EventContentEncryptionMethod[kind];
+    const encryption = signer[method];
+    if (!encryption)
+        throw new Error(`Signer does not support ${method} encryption`);
+    return encryption;
+}
+/** Checks if an event can have encrypted content */
+export function canHaveEncryptedContent(kind) {
+    return EventContentEncryptionMethod[kind] !== undefined;
+}
+/** Checks if an event has encrypted content */
+export function hasEncryptedContent(event) {
+    return event.content.length > 0;
+}
+/** Returns the encrypted content for an event if it is unlocked */
+export function getEncryptedContent(event) {
+    return Reflect.get(event, EncryptedContentSymbol);
+}
+/** Checks if the encrypted content is locked */
+export function isEncryptedContentLocked(event) {
+    return Reflect.has(event, EncryptedContentSymbol) === false;
+}
+/**
+ * Unlocks the encrypted content in an event and caches it
+ * @param event The event with content to decrypt
+ * @param pubkey The other pubkey that encrypted the content
+ * @param signer A signer to use to decrypt the content
+ */
+export async function unlockEncryptedContent(event, pubkey, signer) {
+    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
+    const plaintext = await encryption.decrypt(pubkey, event.content);
+    setEncryptedContentCache(event, plaintext);
+    return plaintext;
+}
+/** Sets the encrypted content on an event and updates it if its part of an event store */
+export function setEncryptedContentCache(event, plaintext) {
+    Reflect.set(event, EncryptedContentSymbol, plaintext);
+    // if the event has been added to an event store, notify it
+    if (isEvent(event))
+        notifyEventUpdate(event);
+}
+/** Removes the encrypted content cache on an event */
+export function lockEncryptedContent(event) {
+    Reflect.deleteProperty(event, EncryptedContentSymbol);
+    // if the event has been added to an event store, notify it
+    if (isEvent(event))
+        notifyEventUpdate(event);
+}

package/dist/helpers/encryption.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if a string is encrypted with NIP-04 or NIP-44
+ * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
+ */
+export declare function isNIP04Encrypted(ciphertext: string): boolean;

package/dist/helpers/encryption.js

@@ -0,0 +1,10 @@
+/**
+ * Checks if a string is encrypted with NIP-04 or NIP-44
+ * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
+ */
+export function isNIP04Encrypted(ciphertext) {
+    const l = ciphertext.length;
+    if (l < 28)
+        return false;
+    return (ciphertext[l - 28] == "?" && ciphertext[l - 27] == "i" && ciphertext[l - 26] == "v" && ciphertext[l - 25] == "=");
+}

package/dist/helpers/event.d.ts

@@ -1,16 +1,10 @@
 import { NostrEvent, VerifiedEvent } from "nostr-tools";
 import { IEventStore } from "../event-store/interface.js";
 export declare const EventUIDSymbol: unique symbol;
+export declare const ReplaceableAddressSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
 export declare const ReplaceableIdentifierSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [EventUIDSymbol]?: string;
-        [EventIndexableTagsSymbol]?: Set<string>;
-        [FromCacheSymbol]?: boolean;
-    }
-}
 /**
  * Checks if an object is a nostr event
  * NOTE: does not validation the signature on the event
@@ -44,7 +38,6 @@ export declare function getTagValue<T extends {
     kind: number;
     tags: string[][];
     content: string;
-    pubkey: string;
 }>(event: T, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
@@ -54,8 +47,12 @@ export declare function markFromCache(event: NostrEvent): void;
 export declare function isFromCache(event: NostrEvent): boolean;
 /** Returns the EventStore of an event if its been added to one */
 export declare function getParentEventStore<T extends object>(event: T): IEventStore | undefined;
+/** Notifies the events parent store that an event has been updated */
+export declare function notifyEventUpdate(event: NostrEvent): void;
 /**
  * Returns the replaceable identifier for a replaceable event
  * @throws
  */
 export declare function getReplaceableIdentifier(event: NostrEvent): string;
+/** Checks if an event is a NIP-70 protected event */
+export declare function isProtectedEvent(event: NostrEvent): boolean;

package/dist/helpers/event.js

@@ -1,10 +1,11 @@
 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 { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { EventStoreSymbol } from "../event-store/event-store.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./hidden-tags.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
+export const ReplaceableAddressSymbol = Symbol.for("replaceable-address");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
 export const ReplaceableIdentifierSymbol = Symbol.for("replaceable-identifier");
@@ -38,13 +39,13 @@ export function isReplaceable(kind) {
  * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d )
  */
 export function getEventUID(event) {
-    let uid = event[EventUIDSymbol];
+    let uid = Reflect.get(event, EventUIDSymbol);
     if (!uid) {
         if (isReplaceable(event.kind))
             uid = getReplaceableAddress(event);
         else
             uid = event.id;
-        event[EventUIDSymbol] = uid;
+        Reflect.set(event, EventUIDSymbol, uid);
     }
     return uid;
 }
@@ -52,8 +53,10 @@ export function getEventUID(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);
+    return getOrComputeCachedValue(event, ReplaceableAddressSymbol, () => {
+        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) {
@@ -63,7 +66,7 @@ export function createReplaceableAddress(kind, pubkey, identifier) {
 export const getReplaceableUID = createReplaceableAddress;
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
-    let indexable = event[EventIndexableTagsSymbol];
+    let indexable = Reflect.get(event, EventIndexableTagsSymbol);
     if (!indexable) {
         const tags = new Set();
         for (const tag of event.tags) {
@@ -71,7 +74,8 @@ export function getIndexableTags(event) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
-        indexable = event[EventIndexableTagsSymbol] = tags;
+        indexable = tags;
+        Reflect.set(event, EventIndexableTagsSymbol, tags);
     }
     return indexable;
 }
@@ -93,16 +97,22 @@ export function fakeVerifyEvent(event) {
 }
 /** Marks an event as being from a cache */
 export function markFromCache(event) {
-    event[FromCacheSymbol] = true;
+    Reflect.set(event, FromCacheSymbol, true);
 }
 /** Returns if an event was from a cache */
 export function isFromCache(event) {
-    return !!event[FromCacheSymbol];
+    return Reflect.get(event, FromCacheSymbol) === true;
 }
 /** Returns the EventStore of an event if its been added to one */
 export function getParentEventStore(event) {
     return Reflect.get(event, EventStoreSymbol);
 }
+/** Notifies the events parent store that an event has been updated */
+export function notifyEventUpdate(event) {
+    const eventStore = getParentEventStore(event);
+    if (eventStore)
+        eventStore.update(event);
+}
 /**
  * Returns the replaceable identifier for a replaceable event
  * @throws
@@ -117,3 +127,7 @@ export function getReplaceableIdentifier(event) {
         return d;
     });
 }
+/** Checks if an event is a NIP-70 protected event */
+export function isProtectedEvent(event) {
+    return event.tags.some((t) => t[0] === "-");
+}

package/dist/helpers/expiration.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ExpirationTimestampSymbol: unique symbol;
+/** Returns the NIP-40 expiration timestamp for an event */
+export declare function getExpirationTimestamp(event: NostrEvent): number | undefined;
+/** Checks if an event has expired based on the NIP-40 expiration timestamp */
+export declare function isExpired(event: NostrEvent): boolean;

package/dist/helpers/expiration.js

@@ -0,0 +1,16 @@
+import { getTagValue } from "./event.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { unixNow } from "./time.js";
+export const ExpirationTimestampSymbol = Symbol("expiration-timestamp");
+/** Returns the NIP-40 expiration timestamp for an event */
+export function getExpirationTimestamp(event) {
+    return getOrComputeCachedValue(event, ExpirationTimestampSymbol, () => {
+        const expiration = getTagValue(event, "expiration");
+        return expiration ? parseInt(expiration) : undefined;
+    });
+}
+/** Checks if an event has expired based on the NIP-40 expiration timestamp */
+export function isExpired(event) {
+    const expiration = getExpirationTimestamp(event);
+    return expiration ? unixNow() > expiration : false;
+}

package/dist/helpers/filter.d.ts

@@ -6,9 +6,7 @@ import { Filter, NostrEvent } from "nostr-tools";
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
 /** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
-/**
- * Copied from nostr-tools and modified to support undefined
- */
+/** Copied from nostr-tools and modified to support undefined  */
 export declare function mergeFilters(...filters: Filter[]): Filter;
 /** Check if two filters are equal */
 export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -40,9 +40,7 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
-/**
- * Copied from nostr-tools and modified to support undefined
- */
+/** Copied from nostr-tools and modified to support undefined  */
 export function mergeFilters(...filters) {
     let result = {};
     for (let i = 0; i < filters.length; i++) {