applesauce-core 2.2.0 → 3.0.0

package/dist/helpers/calendar-rsvp.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export declare const CALENDAR_EVENT_RSVP_KIND = 31925;
+export type RSVPStatus = "accepted" | "declined" | "tentative";
+export type RSVPFreeBusy = "free" | "busy";
+/** Gets the RSVP status from a calendar event RSVP */
+export declare function getRSVPStatus(event: NostrEvent): RSVPStatus | undefined;
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export declare function getRSVPFreeBusy(event: NostrEvent): RSVPFreeBusy | undefined;
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export declare function getRSVPAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export declare function getRSVPEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Gets the profile pointer that the RSVP is responding to */
+export declare function getRSVPProfilePointer(event: NostrEvent): ProfilePointer | undefined;

package/dist/helpers/calendar-rsvp.js

@@ -0,0 +1,38 @@
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag, getEventPointerFromETag, getProfilePointerFromPTag } from "./pointers.js";
+import { isATag, isETag, isPTag } from "./tags.js";
+export const CALENDAR_EVENT_RSVP_KIND = 31925;
+/** Gets the RSVP status from a calendar event RSVP */
+export function getRSVPStatus(event) {
+    const status = getTagValue(event, "status");
+    return status && ["accepted", "declined", "tentative"].includes(status) ? status : undefined;
+}
+/** Gets the free/busy status from a calendar event RSVP (will be undefined if the RSVP is declined) */
+export function getRSVPFreeBusy(event) {
+    const status = getRSVPStatus(event);
+    if (status === "declined")
+        return undefined;
+    const fb = getTagValue(event, "fb");
+    return fb && ["free", "busy"].includes(fb) ? fb : undefined;
+}
+/** Gets the referenced calendar event coordinate that the RSVP is responding to */
+export function getRSVPAddressPointer(event) {
+    const tag = event.tags.find(isATag);
+    if (!tag)
+        return undefined;
+    return getAddressPointerFromATag(tag);
+}
+/** Gets the referenced calendar event pointer that the RSVP is responding to */
+export function getRSVPEventPointer(event) {
+    const tag = event.tags.find(isETag);
+    if (!tag)
+        return undefined;
+    return getEventPointerFromETag(tag);
+}
+/** Gets the profile pointer that the RSVP is responding to */
+export function getRSVPProfilePointer(event) {
+    const tag = event.tags.find(isPTag);
+    if (!tag)
+        return undefined;
+    return getProfilePointerFromPTag(tag);
+}

package/dist/helpers/calendar.d.ts

@@ -0,0 +1,6 @@
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer } from "nostr-tools/nip19";
+/** Gets the title of a calendar */
+export declare function getCalendarTitle(event: NostrEvent): string | undefined;
+/** Gets the address pointers to all the events on the calendar */
+export declare function getCalendarAddressPointers(event: NostrEvent): AddressPointer[];

package/dist/helpers/calendar.js

@@ -0,0 +1,11 @@
+import { getTagValue } from "./event-tags.js";
+import { getAddressPointerFromATag } from "./pointers.js";
+import { isATag } from "./tags.js";
+/** Gets the title of a calendar */
+export function getCalendarTitle(event) {
+    return getTagValue(event, "title");
+}
+/** Gets the address pointers to all the events on the calendar */
+export function getCalendarAddressPointers(event) {
+    return event.tags.filter(isATag).map(getAddressPointerFromATag);
+}

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

@@ -3,7 +3,7 @@ import { catchError, combineLatest, distinct, EMPTY, filter, isObservable, map,
 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";
+import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } 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 */
@@ -54,25 +54,29 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     // Look for gift wraps that are unlocked
     filter((e) => e.kind === kinds.GiftWrap && !isEncryptedContentLocked(e)), 
     // Get the seal event
-    map((gift) => [gift, getGiftWrapSeal(gift)]), 
+    map((gift) => getGiftWrapSeal(gift)), 
     // Look for gift wraps with locked seals
-    filter(([_gift, seal]) => seal !== undefined && isEncryptedContentLocked(seal)), 
+    filter((seal) => seal !== undefined && isEncryptedContentLocked(seal)), 
     // Only attempt to unlock seals once
-    distinct(([_gift, seal]) => seal.id), 
+    distinct((seal) => seal.id), 
     // Get encrypted content from storage
-    mergeMap(([gift, seal]) => 
+    mergeMap((seal) => 
     // Wait for storage to be available
-    storage$.pipe(switchMap((storage) => combineLatest([of(gift), of(seal), getItem(storage, seal)])), catchError((error) => {
+    storage$.pipe(switchMap((storage) => combineLatest([of(seal), getItem(storage, seal)])), catchError((error) => {
         log(`Failed to restore encrypted content for ${seal.id}`, error);
         return EMPTY;
     }))))
-        .subscribe(async ([gift, seal, content]) => {
+        .subscribe(async ([seal, content]) => {
         if (!seal || !content)
             return;
         markEncryptedContentFromCache(seal);
         setEncryptedContentCache(seal, content);
+        // Parse the rumor event
+        getSealRumor(seal);
         // Trigger an update to the gift wrap event
-        notifyEventUpdate(gift);
+        const gift = getSealGiftWrap(seal);
+        if (gift)
+            notifyEventUpdate(gift);
         log(`Restored encrypted content for ${seal.id}`);
     });
     // Persist encrypted content when it is updated or inserted
@@ -104,14 +108,14 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     // 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]), 
+    map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
     // Make sure the seal is defined
-    filter(([_gift, seal]) => seal !== undefined), 
+    filter(([seal]) => seal !== undefined), 
     // Make sure seal is unlocked and not from cache
-    filter(([_gift, seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
+    filter(([seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
     // Only persist the seal once
     distinct(([seal]) => seal.id))
-        .subscribe(async ([_gift, seal, storage]) => {
+        .subscribe(async ([seal, storage]) => {
         if (!seal)
             return;
         try {

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

@@ -10,18 +10,26 @@ export interface EncryptedContentSigner {
         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): {
+export type EncryptionMethod = "nip04" | "nip44";
+/** A pair of encryption methods for encrypting and decrypting event content */
+export interface EncryptionMethods {
     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;
-};
+}
+/** Various event kinds that can have encrypted content and which encryption method they use */
+export declare const EventContentEncryptionMethod: Record<number, EncryptionMethod>;
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export declare function setEncryptedContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner, override?: EncryptionMethod): EncryptionMethods;
 /** Checks if an event can have encrypted content */
 export declare function canHaveEncryptedContent(kind: number): boolean;
 /** Checks if an event has encrypted content */

package/dist/helpers/encrypted-content.js

@@ -13,9 +13,17 @@ 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];
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export function getEncryptedContentEncryptionMethods(kind, signer, override) {
+    const method = override ?? EventContentEncryptionMethod[kind];
     if (!method)
         throw new Error(`Event kind ${kind} does not support encrypted content`);
     const encryption = signer[method];

package/dist/helpers/event-cache.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export declare function presistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
+    maxBatchSize?: number;
+    batchTime?: number;
+}): () => void;

package/dist/helpers/event-cache.js

@@ -0,0 +1,32 @@
+import { bufferTime, filter } from "rxjs";
+import { logger } from "../logger.js";
+import { isFromCache } from "./index.js";
+const log = logger.extend("event-cache");
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export function presistEventsToCache(eventStore, write, opts) {
+    const time = opts?.batchTime ?? 5_000;
+    // Save all new events to the cache
+    const sub = eventStore.insert$
+        .pipe(
+    // Only select events that are not from the cache
+    filter((e) => !isFromCache(e)), 
+    // Buffer events for 5 seconds
+    opts?.maxBatchSize ? bufferTime(time, undefined, opts?.maxBatchSize ?? 100) : bufferTime(time), 
+    // Only select buffers with events
+    filter((b) => b.length > 0))
+        .subscribe((events) => {
+        // Save all new events to the cache
+        write(events)
+            .then(() => log(`Saved ${events.length} events to cache`))
+            .catch((e) => log(`Failed to save ${events.length} events to cache`, e));
+    });
+    return () => sub.unsubscribe();
+}

package/dist/helpers/event.d.ts

@@ -41,7 +41,7 @@ export declare function getParentEventStore<T extends object>(event: T): IEventS
 export declare function notifyEventUpdate(event: NostrEvent): void;
 /**
  * Returns the replaceable identifier for a replaceable event
- * @throws
+ * @throws {Error} if the event is not addressable or missing the "d" tag
  */
 export declare function getReplaceableIdentifier(event: NostrEvent): string;
 /** Checks if an event is a NIP-70 protected event */

package/dist/helpers/event.js

@@ -87,7 +87,7 @@ export function notifyEventUpdate(event) {
 }
 /**
  * Returns the replaceable identifier for a replaceable event
- * @throws
+ * @throws {Error} if the event is not addressable or missing the "d" tag
  */
 export function getReplaceableIdentifier(event) {
     if (!isAddressableKind(event.kind))

package/dist/helpers/expiration.js

@@ -1,11 +1,10 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { unixNow } from "./time.js";
-import { getTagValue } from "./event-tags.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");
+        const expiration = event.tags.find((t) => t[0] === "expiration")?.[1];
         return expiration ? parseInt(expiration) : undefined;
     });
 }

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

@@ -1,26 +1,46 @@
 import { NostrEvent, UnsignedEvent } from "nostr-tools";
+import { EventSet } from "../event-store/event-set.js";
 import { EncryptedContentSigner } from "./encrypted-content.js";
+/**
+ * An internal event set to keep track of seals and rumors
+ * This is intentially isolated from the main applications event store so to prevent seals and rumors from being leaked
+ */
+export declare const internalGiftWrapEvents: EventSet;
 export type Rumor = UnsignedEvent & {
     id: string;
 };
-export declare const GiftWrapSealSymbol: 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;
+/** Used to store a reference to the seal event on gift wraps (downstream) or the seal event on rumors (upstream[]) */
+export declare const SealSymbol: unique symbol;
+/** Used to store a reference to the rumor on seals (downstream) */
+export declare const RumorSymbol: unique symbol;
+/** Used to store a reference to the parent gift wrap event on seals (upstream) */
+export declare const GiftWrapSymbol: unique symbol;
+/** Checks if an event is a rumor (normal event with "id" and no "sig") */
+export declare function isRumor(event: any): event is Rumor;
+/** Returns all the parent gift wraps for a seal event */
+export declare function getSealGiftWrap(seal: NostrEvent): NostrEvent | undefined;
+/** Returns all the parent seals for a rumor event */
+export declare function getRumorSeals(rumor: Rumor): NostrEvent[];
+/** Returns all the parent gift wraps for a rumor event */
+export declare function getRumorGiftWraps(rumor: Rumor): NostrEvent[];
 /** 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
- */
+/** Returns the seal event in a gift-wrap event */
+export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
+/** Returns the unsigned rumor in the gift-wrap */
 export declare function getGiftWrapRumor(gift: NostrEvent): Rumor | undefined;
-/** Checks if an event is a rumor (normal event with "id" and no "sig") */
-export declare function isRumor(event: any): event is Rumor;
 /** 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: EncryptedContentSigner): Promise<UnsignedEvent>;
-/** Locks a gift-wrap event by removing its cached seal and encrypted content */
+/**
+ * Unlocks a seal event and returns the rumor event
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function unlockSeal(seal: NostrEvent, signer: EncryptedContentSigner): Promise<Rumor>;
+/**
+ * Unlocks and returns the unsigned seal event in a gift-wrap
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function unlockGiftWrap(gift: NostrEvent, signer: EncryptedContentSigner): Promise<Rumor>;
 export declare function lockGiftWrap(gift: NostrEvent): void;

package/dist/helpers/gift-wraps.js

@@ -1,51 +1,31 @@
 import { verifyEvent } from "nostr-tools";
-import { getOrComputeCachedValue } from "./cache.js";
+import { EventSet } from "../event-store/event-set.js";
 import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
-import { isEvent, notifyEventUpdate } from "./event.js";
-export const GiftWrapSealSymbol = Symbol.for("gift-wrap-seal");
-export const GiftWrapRumorSymbol = Symbol.for("gift-wrap-rumor");
-/** Returns the unsigned seal event in a gift-wrap event */
-export function getGiftWrapSeal(gift) {
-    if (isEncryptedContentLocked(gift))
-        return undefined;
-    const plaintext = getEncryptedContent(gift);
-    if (!plaintext)
-        return undefined;
-    return getOrComputeCachedValue(gift, GiftWrapSealSymbol, () => {
-        const seal = JSON.parse(plaintext);
-        verifyEvent(seal);
-        return seal;
-    });
-}
-/** Checks if a seal event is locked */
-export function isSealLocked(seal) {
-    return isEncryptedContentLocked(seal);
-}
-/** Gets the rumor from a seal event */
-export function getSealRumor(seal) {
-    if (isEncryptedContentLocked(seal))
-        return undefined;
-    const plaintext = getEncryptedContent(seal);
-    if (!plaintext)
-        return undefined;
-    return getOrComputeCachedValue(seal, GiftWrapRumorSymbol, () => {
-        const rumor = JSON.parse(plaintext);
-        if (rumor.pubkey !== seal.pubkey)
-            throw new Error("Seal author does not match rumor author");
-        return rumor;
-    });
-}
+import { notifyEventUpdate } from "./event.js";
 /**
- * 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
+ * An internal event set to keep track of seals and rumors
+ * This is intentially isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export function getGiftWrapRumor(gift) {
-    if (isEncryptedContentLocked(gift))
-        return undefined;
-    const seal = getGiftWrapSeal(gift);
-    if (!seal || isSealLocked(seal))
-        return undefined;
-    return getOrComputeCachedValue(gift, GiftWrapRumorSymbol, () => getSealRumor(seal));
+export const internalGiftWrapEvents = new EventSet();
+/** Used to store a reference to the seal event on gift wraps (downstream) or the seal event on rumors (upstream[]) */
+export const SealSymbol = Symbol.for("seal");
+/** Used to store a reference to the rumor on seals (downstream) */
+export const RumorSymbol = Symbol.for("rumor");
+/** Used to store a reference to the parent gift wrap event on seals (upstream) */
+export const GiftWrapSymbol = Symbol.for("gift-wrap");
+/** Adds a parent reference to a seal or rumor */
+function addParentSealReference(rumor, seal) {
+    const parents = Reflect.get(rumor, SealSymbol);
+    if (!parents)
+        Reflect.set(rumor, SealSymbol, new Set([seal]));
+    else
+        parents.add(seal);
+}
+/** Removes a parent reference from a seal or rumor */
+function removeParentSealReference(rumor, seal) {
+    const parents = Reflect.get(rumor, SealSymbol);
+    if (parents)
+        parents.delete(seal);
 }
 /** Checks if an event is a rumor (normal event with "id" and no "sig") */
 export function isRumor(event) {
@@ -60,41 +40,157 @@ export function isRumor(event) {
         typeof event.created_at === "number" &&
         event.created_at > 0);
 }
+/** Returns all the parent gift wraps for a seal event */
+export function getSealGiftWrap(seal) {
+    return Reflect.get(seal, GiftWrapSymbol);
+}
+/** Returns all the parent seals for a rumor event */
+export function getRumorSeals(rumor) {
+    let set = Reflect.get(rumor, SealSymbol);
+    if (!set) {
+        set = new Set();
+        Reflect.set(rumor, SealSymbol, set);
+    }
+    return Array.from(set);
+}
+/** Returns all the parent gift wraps for a rumor event */
+export function getRumorGiftWraps(rumor) {
+    const giftWraps = new Set();
+    const seals = getRumorSeals(rumor);
+    for (const seal of seals) {
+        const upstream = getSealGiftWrap(seal);
+        if (upstream)
+            giftWraps.add(upstream);
+    }
+    return Array.from(giftWraps);
+}
+/** Checks if a seal event is locked */
+export function isSealLocked(seal) {
+    return isEncryptedContentLocked(seal);
+}
+/** Gets the rumor from a seal event */
+export function getSealRumor(seal) {
+    // Returned cached rumor if it exists (downstream)
+    const cached = Reflect.get(seal, RumorSymbol);
+    if (cached)
+        return cached;
+    // Get the encrypted content plaintext
+    const plaintext = getEncryptedContent(seal);
+    if (!plaintext)
+        return undefined;
+    let rumor = JSON.parse(plaintext);
+    // Check if the rumor event already exists in the internal event set
+    const existing = internalGiftWrapEvents.getEvent(rumor.id);
+    if (existing)
+        // Reuse the existing rumor instance
+        rumor = existing;
+    else
+        // Add to the internal event set
+        internalGiftWrapEvents.add(rumor);
+    // Save a reference to the parent seal event
+    addParentSealReference(rumor, seal);
+    // Save a reference to the rumor on the seal (downstream)
+    Reflect.set(seal, RumorSymbol, rumor);
+    return rumor;
+}
+/** Returns the seal event in a gift-wrap event */
+export function getGiftWrapSeal(gift) {
+    // Returned cached seal if it exists (downstream)
+    const cached = Reflect.get(gift, SealSymbol);
+    if (cached)
+        return cached;
+    // Get the encrypted content plaintext
+    const plaintext = getEncryptedContent(gift);
+    if (!plaintext)
+        return undefined;
+    let seal = JSON.parse(plaintext);
+    // Check if the seal event already exists in the internal event set
+    const existing = internalGiftWrapEvents.getEvent(seal.id);
+    if (existing) {
+        // Reuse the existing seal instance
+        seal = existing;
+    }
+    else {
+        // Verify the seal event
+        verifyEvent(seal);
+        // Add to the internal event set
+        internalGiftWrapEvents.add(seal);
+        // Set the reference to the parent gift wrap event (upstream)
+        Reflect.set(seal, GiftWrapSymbol, gift);
+    }
+    // Save a reference to the seal on the gift wrap (downstream)
+    Reflect.set(gift, SealSymbol, seal);
+    return seal;
+}
+/** Returns the unsigned rumor in the gift-wrap */
+export function getGiftWrapRumor(gift) {
+    const seal = getGiftWrapSeal(gift);
+    if (!seal)
+        return undefined;
+    return getSealRumor(seal);
+}
 /** Returns if a gift-wrap event or gift-wrap seal is locked */
 export function isGiftWrapLocked(gift) {
     if (isEncryptedContentLocked(gift))
         return true;
     else {
         const seal = getGiftWrapSeal(gift);
-        if (!seal || isEncryptedContentLocked(seal))
+        if (!seal || isSealLocked(seal))
             return true;
         else
             return false;
     }
 }
-/** Unlocks and returns the unsigned seal event in a gift-wrap */
+/**
+ * Unlocks a seal event and returns the rumor event
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export async function unlockSeal(seal, signer) {
+    if (isEncryptedContentLocked(seal))
+        await unlockEncryptedContent(seal, seal.pubkey, signer);
+    // Parse the rumor event
+    const rumor = getSealRumor(seal);
+    if (!rumor)
+        throw new Error("Failed to read rumor in gift wrap");
+    // Check if the seal and rumor authors match
+    if (rumor.pubkey !== seal.pubkey)
+        throw new Error("Seal author does not match rumor author");
+    return rumor;
+}
+/**
+ * Unlocks and returns the unsigned seal event in a gift-wrap
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
 export async function unlockGiftWrap(gift, signer) {
     // First unlock the gift-wrap event
     if (isEncryptedContentLocked(gift))
         await unlockEncryptedContent(gift, gift.pubkey, signer);
-    // Next get and unlock the seal
+    // Get the seal event
     const seal = getGiftWrapSeal(gift);
     if (!seal)
         throw new Error("Failed to read seal in gift wrap");
-    if (isEncryptedContentLocked(seal))
-        await unlockEncryptedContent(seal, seal.pubkey, signer);
-    // Finally get the rumor event
-    const rumor = getGiftWrapRumor(gift);
-    if (!rumor)
-        throw new Error("Failed to read rumor in gift wrap");
+    // Unlock the seal event
+    const rumor = await unlockSeal(seal, signer);
     // if the event has been added to an event store, notify it
-    if (isEvent(gift))
-        notifyEventUpdate(gift);
+    notifyEventUpdate(gift);
     return rumor;
 }
-/** Locks a gift-wrap event by removing its cached seal and encrypted content */
 export function lockGiftWrap(gift) {
-    Reflect.deleteProperty(gift, GiftWrapSealSymbol);
-    Reflect.deleteProperty(gift, GiftWrapRumorSymbol);
+    const seal = getGiftWrapSeal(gift);
+    if (seal) {
+        const rumor = getSealRumor(seal);
+        // Remove the rumors parent seal reference (upstream)
+        if (rumor)
+            removeParentSealReference(rumor, seal);
+        // Remove the seal's parent gift wrap reference (upstream)
+        Reflect.deleteProperty(seal, GiftWrapSymbol);
+        // Remove the seal's rumor reference (downstream)
+        Reflect.deleteProperty(seal, RumorSymbol);
+        // Lock the seal's encrypted content
+        lockEncryptedContent(seal);
+    }
+    // Remove the gift wrap's seal reference (downstream)
+    Reflect.deleteProperty(gift, SealSymbol);
+    // Lock the gift wrap's encrypted content
     lockEncryptedContent(gift);
 }

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

@@ -1,4 +1,4 @@
-import { EncryptedContentSigner, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
+import { EncryptedContentSigner, EncryptionMethod, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
 export declare const HiddenContentSymbol: symbol;
 export interface HiddenContentSigner extends EncryptedContentSigner {
 }
@@ -6,7 +6,7 @@ export declare const getHiddenContentEncryptionMethods: typeof getEncryptedConte
 /** Various event kinds that can have hidden content */
 export declare const HiddenContentKinds: Set<number>;
 /** Sets the encryption method for hidden content on a kind */
-export declare function setHiddenContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event can have hidden content */
 export declare function canHaveHiddenContent(kind: number): boolean;
 /** Checks if an event has hidden content */
@@ -31,7 +31,7 @@ export declare function unlockHiddenContent<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: EncryptedContentSigner): Promise<string>;
+}>(event: T, signer: EncryptedContentSigner, override?: EncryptionMethod): Promise<string>;
 /**
  * Sets the hidden content on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-content.js

@@ -34,10 +34,10 @@ export function getHiddenContent(event) {
  * @param signer A signer to use to decrypt the content
  * @throws
  */
-export async function unlockHiddenContent(event, signer) {
+export async function unlockHiddenContent(event, signer, override) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
-    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
+    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer, override);
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
     setHiddenContentCache(event, plaintext);
     return plaintext;