applesauce-core 2.2.0 → 2.3.0

package/dist/event-store/event-set.d.ts

@@ -79,4 +79,6 @@ export declare class EventSet implements IEventSet {
     getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
     /** Remove the oldest events that are not claimed */
     prune(limit?: number): number;
+    /** Resets the event set */
+    reset(): void;
 }

package/dist/event-store/event-set.js

@@ -344,4 +344,14 @@ export class EventSet {
         }
         return removed;
     }
+    /** Resets the event set */
+    reset() {
+        this.events.clear();
+        this.kinds.clear();
+        this.authors.clear();
+        this.tags.clear();
+        this.created_at = [];
+        this.replaceable.clear();
+        this.claims = new WeakMap();
+    }
 }

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",