applesauce-core 1.0.0 → 2.0.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 getArticlePublishd(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 getArticlePublishd(article) {
+    const ts = getTagValue(article, "published_at");
+    if (ts && !Number.isNaN(parseInt(ts)))
+        return parseInt(ts);
+    else
+        return article.created_at;
+}

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/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

@@ -44,7 +44,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 +53,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,9 +1,9 @@
 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 EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
@@ -103,6 +103,12 @@ export function isFromCache(event) {
 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 +123,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++) {

package/dist/helpers/gift-wraps.d.ts

@@ -1,12 +1,24 @@
 import { NostrEvent, UnsignedEvent } from "nostr-tools";
-import { HiddenContentSigner } from "./hidden-content.js";
+import { EncryptedContentSigner } from "./encrypted-content.js";
+export type Rumor = UnsignedEvent & {
+    id: string;
+};
 export declare const GiftWrapSealSymbol: unique symbol;
-export declare const GiftWrapEventSymbol: unique symbol;
+export declare const GiftWrapRumorSymbol: unique symbol;
 /** Returns the unsigned seal event in a gift-wrap event */
 export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
-/** Returns the unsigned event in the gift-wrap seal */
-export declare function getGiftWrapEvent(gift: NostrEvent): UnsignedEvent | undefined;
+/** Checks if a seal event is locked */
+export declare function isSealLocked(seal: NostrEvent): boolean;
+/** Gets the rumor from a seal event */
+export declare function getSealRumor(seal: NostrEvent): Rumor | undefined;
+/**
+ * Returns the unsigned event in the gift-wrap seal
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function getGiftWrapRumor(gift: NostrEvent): Rumor | undefined;
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export declare function isGiftWrapLocked(gift: NostrEvent): boolean;
 /** Unlocks and returns the unsigned seal event in a gift-wrap */
-export declare function unlockGiftWrap(gift: NostrEvent, signer: HiddenContentSigner): Promise<UnsignedEvent>;
+export declare function unlockGiftWrap(gift: NostrEvent, signer: EncryptedContentSigner): Promise<UnsignedEvent>;
+/** Locks a gift-wrap event by removing its cached seal and encrypted content */
+export declare function lockGiftWrap(gift: NostrEvent): void;