applesauce-core 3.0.1 → 4.0.0

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

@@ -1,7 +1,7 @@
 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 { canHaveEncryptedContent, getEncryptedContent, isEncryptedContentUnlocked, setEncryptedContentCache, } from "./encrypted-content.js";
 import { notifyEventUpdate } from "./event.js";
 import { getGiftWrapSeal, getSealGiftWrap, getSealRumor } from "./gift-wraps.js";
 /** A symbol that is used to mark encrypted content as being from a cache */
@@ -32,7 +32,7 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     const restore = eventStore.insert$
         .pipe(
     // Look for events that support encrypted content and are locked
-    filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentLocked(e)), 
+    filter((e) => canHaveEncryptedContent(e.kind) && isEncryptedContentUnlocked(e) === false), 
     // Get the encrypted content from storage
     mergeMap((event) => 
     // Wait for storage to be available
@@ -52,11 +52,11 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     const restoreSeals = eventStore.update$
         .pipe(
     // Look for gift wraps that are unlocked
-    filter((e) => e.kind === kinds.GiftWrap && !isEncryptedContentLocked(e)), 
+    filter((e) => e.kind === kinds.GiftWrap && isEncryptedContentUnlocked(e)), 
     // Get the seal event
     map((gift) => getGiftWrapSeal(gift)), 
     // Look for gift wraps with locked seals
-    filter((seal) => seal !== undefined && isEncryptedContentLocked(seal)), 
+    filter((seal) => seal !== undefined && isEncryptedContentUnlocked(seal) === false), 
     // Only attempt to unlock seals once
     distinct((seal) => seal.id), 
     // Get encrypted content from storage
@@ -84,7 +84,7 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
         .pipe(
     // Look for events that support encrypted content and are unlocked and not from the cache
     filter(([event]) => canHaveEncryptedContent(event.kind) &&
-        !isEncryptedContentLocked(event) &&
+        isEncryptedContentUnlocked(event) &&
         !isEncryptedContentFromCache(event)), 
     // Only persist the encrypted content once
     distinct(([event]) => event.id))
@@ -106,13 +106,13 @@ export function persistEncryptedContent(eventStore, storage, fallback) {
     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)), 
+    filter(([event]) => event.kind === kinds.GiftWrap && isEncryptedContentUnlocked(event)), 
     // Get the seal event
     map(([gift, storage]) => [getGiftWrapSeal(gift), storage]), 
     // Make sure the seal is defined
     filter(([seal]) => seal !== undefined), 
     // Make sure seal is unlocked and not from cache
-    filter(([seal]) => !isEncryptedContentLocked(seal) && !isEncryptedContentFromCache(seal)), 
+    filter(([seal]) => isEncryptedContentUnlocked(seal) && !isEncryptedContentFromCache(seal)), 
     // Only persist the seal once
     distinct(([seal]) => seal.id))
         .subscribe(async ([seal, storage]) => {

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

@@ -10,7 +10,12 @@ export interface EncryptedContentSigner {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 }
+/** Encryption method types */
 export type EncryptionMethod = "nip04" | "nip44";
+/** Type for an event who's encrypted content is unlocked */
+export type UnlockedEncryptedContent = {
+    [EncryptedContentSymbol]: string;
+};
 /** A pair of encryption methods for encrypting and decrypting event content */
 export interface EncryptionMethods {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
@@ -37,14 +42,16 @@ 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 UnlockedEncryptedContent>(event: T): string;
 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;
+/** Checks if the encrypted content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export declare function isEncryptedContentUnlocked<T extends object>(event: T): event is T & UnlockedEncryptedContent;
 /**
  * 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
+ * @throws If the event kind does not support encrypted content
  */
 export declare function unlockEncryptedContent<T extends {
     kind: number;

package/dist/helpers/encrypted-content.js

@@ -1,5 +1,5 @@
 import { kinds } from "nostr-tools";
-import { isEvent, notifyEventUpdate } from "./event.js";
+import { 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 */
@@ -39,37 +39,40 @@ export function canHaveEncryptedContent(kind) {
 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;
+/** Checks if the encrypted content is unlocked and casts it to the {@link UnlockedEncryptedContent} type */
+export function isEncryptedContentUnlocked(event) {
+    return Reflect.has(event, EncryptedContentSymbol) === true;
 }
 /**
  * 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
+ * @throws If the event kind does not support encrypted content
  */
 export async function unlockEncryptedContent(event, pubkey, signer) {
+    if (!canHaveEncryptedContent(event.kind))
+        throw new Error("Event kind does not support encrypted content");
+    // Get the encryption methods from the signer
     const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
     const plaintext = await encryption.decrypt(pubkey, event.content);
+    // Set the cached value and trigger update
     setEncryptedContentCache(event, plaintext);
+    // Return the decrypted content
     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);
+    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);
+    notifyEventUpdate(event);
 }

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

@@ -9,7 +9,9 @@ import { IEventStoreStreams } from "../event-store/interface.js";
  * @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?: {
+export declare function persistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
     maxBatchSize?: number;
     batchTime?: number;
 }): () => void;
+/** @deprecated Use persistEventsToCache instead */
+export declare const presistEventsToCache: typeof persistEventsToCache;

package/dist/helpers/event-cache.js

@@ -11,7 +11,7 @@ const log = logger.extend("event-cache");
  * @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) {
+export function persistEventsToCache(eventStore, write, opts) {
     const time = opts?.batchTime ?? 5_000;
     // Save all new events to the cache
     const sub = eventStore.insert$
@@ -30,3 +30,5 @@ export function presistEventsToCache(eventStore, write, opts) {
     });
     return () => sub.unsubscribe();
 }
+/** @deprecated Use persistEventsToCache instead */
+export const presistEventsToCache = persistEventsToCache;

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

@@ -10,5 +10,11 @@ export declare function getTagValue<T extends {
     tags: string[][];
     content: string;
 }>(event: T, name: string): string | undefined;
+/** Checks if an event has a public name / value tag*/
+export declare function hasNameValueTag<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+}>(event: T, name: string, value: string): boolean;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;

package/dist/helpers/event-tags.js

@@ -13,6 +13,10 @@ export function getTagValue(event, name) {
         return hiddenValue;
     return event.tags.find((t) => t[0] === name)?.[1];
 }
+/** Checks if an event has a public name / value tag*/
+export function hasNameValueTag(event, name, value) {
+    return event.tags.some((t) => t[0] === name && t[1] === value);
+}
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
     let indexable = Reflect.get(event, EventIndexableTagsSymbol);

package/dist/helpers/event.d.ts

@@ -1,5 +1,12 @@
 import { NostrEvent, VerifiedEvent } from "nostr-tools";
 import { IEventStore } from "../event-store/interface.js";
+export { NostrEvent, EventTemplate, UnsignedEvent, verifiedSymbol, verifyEvent, VerifiedEvent } from "nostr-tools/pure";
+export { bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch, } from "nostr-tools/utils";
+export * as kinds from "nostr-tools/kinds";
+/** An event with a known kind. this is used to know if events have been validated */
+export type KnownEvent<K extends number> = Omit<NostrEvent, "kind"> & {
+    kind: K;
+};
 /** A symbol on an event that marks which event store its part of */
 export declare const EventStoreSymbol: unique symbol;
 export declare const EventUIDSymbol: unique symbol;
@@ -38,7 +45,7 @@ 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;
+export declare function notifyEventUpdate(event: any): void;
 /** Returns the replaceable identifier for a replaceable event */
 export declare function getReplaceableIdentifier(event: NostrEvent): string;
 /** Checks if an event is a NIP-70 protected event */

package/dist/helpers/event.js

@@ -1,6 +1,10 @@
 import { verifiedSymbol } from "nostr-tools";
 import { isAddressableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { getOrComputeCachedValue } from "./cache.js";
+// Re-export types from nostr-tools
+export { verifiedSymbol, verifyEvent } from "nostr-tools/pure";
+export { bytesToHex, hexToBytes, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch, } from "nostr-tools/utils";
+export * as kinds from "nostr-tools/kinds";
 /** A symbol on an event that marks which event store its part of */
 export const EventStoreSymbol = Symbol.for("event-store");
 export const EventUIDSymbol = Symbol.for("event-uid");
@@ -81,6 +85,8 @@ export function getParentEventStore(event) {
 }
 /** Notifies the events parent store that an event has been updated */
 export function notifyEventUpdate(event) {
+    if (!isEvent(event))
+        return;
     const eventStore = getParentEventStore(event);
     if (eventStore)
         eventStore.update(event);

package/dist/helpers/file-metadata.d.ts

@@ -1,7 +1,7 @@
 import { NostrEvent } from "nostr-tools";
 export type FileMetadata = {
     /** URL of the file */
-    url: string;
+    url?: string;
     /** MIME type */
     type?: string;
     /** sha256 hash of the file */
@@ -32,24 +32,19 @@ export type FileMetadata = {
     /** fallback URLs */
     fallback?: string[];
 };
+/** Alias for {@link FileMetadata} */
 export type MediaAttachment = FileMetadata;
 /**
  * Parses file metadata tags into {@link FileMetadata}
  * @throws
  */
 export declare function parseFileMetadataTags(tags: string[][]): FileMetadata;
-/**
- * Parses a imeta tag into a {@link FileMetadata}
- * @throws
- */
+/** Parses a imeta tag into a {@link FileMetadata} */
 export declare function getFileMetadataFromImetaTag(tag: string[]): FileMetadata;
 export declare const MediaAttachmentsSymbol: unique symbol;
 /** Gets all the media attachments on an event */
 export declare function getMediaAttachments(event: NostrEvent): FileMetadata[];
-/**
- * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
- * @throws
- */
+/** Gets {@link FileMetadata} for a NIP-94 kind 1063 event */
 export declare function getFileMetadata(file: NostrEvent): FileMetadata;
 /** Returns the last 64 length hex string in a URL */
 export declare function getSha256FromURL(url: string | URL): string | undefined;

package/dist/helpers/file-metadata.js

@@ -16,8 +16,6 @@ export function parseFileMetadataTags(tags) {
                 break;
         }
     }
-    if (!fields.url)
-        throw new Error("Missing required url in file metadata");
     const metadata = { url: fields.url, fallback };
     // parse size
     if (fields.size)
@@ -47,10 +45,7 @@ export function parseFileMetadataTags(tags) {
         metadata.blurhash = fields.blurhash;
     return metadata;
 }
-/**
- * Parses a imeta tag into a {@link FileMetadata}
- * @throws
- */
+/** Parses a imeta tag into a {@link FileMetadata} */
 export function getFileMetadataFromImetaTag(tag) {
     const parts = tag.slice(1);
     const tags = [];
@@ -81,10 +76,7 @@ export function getMediaAttachments(event) {
             .filter((a) => !!a);
     });
 }
-/**
- * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
- * @throws
- */
+/** Gets {@link FileMetadata} for a NIP-94 kind 1063 event */
 export function getFileMetadata(file) {
     return parseFileMetadataTags(file.tags);
 }

package/dist/helpers/filter.d.ts

@@ -1,12 +1,13 @@
 import { Filter, NostrEvent } from "nostr-tools";
+export { Filter } from "nostr-tools/filter";
 /**
- * Copied from nostr-tools and modified to use getIndexableTags
+ * Copied from nostr-tools and modified to use {@link getIndexableTags}
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
-/** Copied from nostr-tools */
+/** Copied from nostr-tools and modified to use {@link matchFilter} */
 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 values */
 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

@@ -1,7 +1,7 @@
 import equal from "fast-deep-equal";
 import { getIndexableTags } from "./event-tags.js";
 /**
- * Copied from nostr-tools and modified to use getIndexableTags
+ * Copied from nostr-tools and modified to use {@link getIndexableTags}
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
  */
 export function matchFilter(filter, event) {
@@ -31,7 +31,7 @@ export function matchFilter(filter, event) {
         return false;
     return true;
 }
-/** Copied from nostr-tools */
+/** Copied from nostr-tools and modified to use {@link matchFilter} */
 export function matchFilters(filters, event) {
     for (let i = 0; i < filters.length; i++) {
         if (matchFilter(filters[i], event)) {
@@ -40,7 +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 values */
 export function mergeFilters(...filters) {
     let result = {};
     for (let i = 0; i < filters.length; i++) {

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

@@ -1,11 +1,12 @@
-import { NostrEvent, UnsignedEvent } from "nostr-tools";
-import { EventSet } from "../event-store/event-set.js";
+import { kinds, NostrEvent, UnsignedEvent } from "nostr-tools";
+import { EventMemory } from "../event-store/event-memory.js";
 import { EncryptedContentSigner } from "./encrypted-content.js";
+import { KnownEvent } from "./event.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
+ * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export declare const internalGiftWrapEvents: EventSet;
+export declare const internalGiftWrapEvents: EventMemory;
 export type Rumor = UnsignedEvent & {
     id: string;
 };
@@ -15,24 +16,43 @@ export declare const SealSymbol: unique symbol;
 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;
+/** A gift wrap event that knows its seal event */
+export type UnlockedGiftWrapEvent = KnownEvent<kinds.GiftWrap> & {
+    /** Downstream seal event */
+    [SealSymbol]: UnlockedSeal;
+};
+/** A seal that knows its parent gift wrap event */
+export type UnlockedSeal = KnownEvent<kinds.Seal> & {
+    /** Upstream gift wrap event */
+    [SealSymbol]: UnlockedGiftWrapEvent;
+    /** Downstream rumor event */
+    [RumorSymbol]: Rumor;
+};
 /** 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;
+export declare function getSealGiftWrap(seal: UnlockedSeal): UnlockedGiftWrapEvent;
+export declare function getSealGiftWrap(seal: NostrEvent): UnlockedGiftWrapEvent | undefined;
 /** Returns all the parent seals for a rumor event */
-export declare function getRumorSeals(rumor: Rumor): NostrEvent[];
+export declare function getRumorSeals(rumor: Rumor): UnlockedSeal[];
 /** 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 getRumorGiftWraps(rumor: Rumor): UnlockedGiftWrapEvent[];
+/** Checks if a seal event is locked and casts it to the {@link UnlockedSeal} type */
+export declare function isSealUnlocked(seal: NostrEvent): seal is UnlockedSeal;
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export declare function isGiftWrapUnlocked(gift: NostrEvent): gift is UnlockedGiftWrapEvent;
+/**
+ * Gets the rumor from a seal event
+ * @throws {Error} If the author of the rumor event does not match the author of the seal
+ */
+export declare function getSealRumor(seal: UnlockedSeal): Rumor;
 export declare function getSealRumor(seal: NostrEvent): Rumor | undefined;
-/** Returns the seal event in a gift-wrap event */
+/** Returns the seal event in a gift-wrap -> seal (downstream) */
+export declare function getGiftWrapSeal(gift: UnlockedGiftWrapEvent): UnlockedSeal;
 export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
-/** Returns the unsigned rumor in the gift-wrap */
+/** Returns the unsigned rumor in the gift-wrap -> seal -> rumor (downstream) */
+export declare function getGiftWrapRumor(gift: UnlockedGiftWrapEvent): Rumor;
 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 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
@@ -43,4 +63,5 @@ export declare function unlockSeal(seal: NostrEvent, signer: EncryptedContentSig
  * @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>;
+/** Locks a gift-wrap event and seals its seal event */
 export declare function lockGiftWrap(gift: NostrEvent): void;

package/dist/helpers/gift-wraps.js

@@ -1,12 +1,12 @@
-import { verifyEvent } from "nostr-tools";
-import { EventSet } from "../event-store/event-set.js";
-import { getEncryptedContent, isEncryptedContentLocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
+import { kinds, verifyEvent } from "nostr-tools";
+import { EventMemory } from "../event-store/event-memory.js";
+import { getEncryptedContent, isEncryptedContentUnlocked, lockEncryptedContent, unlockEncryptedContent, } from "./encrypted-content.js";
 import { notifyEventUpdate } from "./event.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
+ * This is intentionally isolated from the main applications event store so to prevent seals and rumors from being leaked
  */
-export const internalGiftWrapEvents = new EventSet();
+export const internalGiftWrapEvents = new EventMemory();
 /** 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) */
@@ -40,7 +40,6 @@ 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);
 }
@@ -64,21 +63,37 @@ export function getRumorGiftWraps(rumor) {
     }
     return Array.from(giftWraps);
 }
-/** Checks if a seal event is locked */
-export function isSealLocked(seal) {
-    return isEncryptedContentLocked(seal);
+/** Checks if a seal event is locked and casts it to the {@link UnlockedSeal} type */
+export function isSealUnlocked(seal) {
+    return isEncryptedContentUnlocked(seal) === true && Reflect.has(seal, RumorSymbol) === true;
+}
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export function isGiftWrapUnlocked(gift) {
+    if (isEncryptedContentUnlocked(gift) === false)
+        return false;
+    // Get the seal event
+    const seal = getGiftWrapSeal(gift);
+    if (!seal)
+        return false;
+    // If seal is locked, return false
+    if (!isSealUnlocked(seal))
+        return false;
+    return true;
 }
-/** 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;
+    // Non seal events cant have rumors
+    if (seal.kind !== kinds.Seal)
+        return undefined;
+    // If unlocked return the rumor
+    if (isSealUnlocked(seal))
+        return seal[RumorSymbol];
     // Get the encrypted content plaintext
-    const plaintext = getEncryptedContent(seal);
-    if (!plaintext)
+    const content = getEncryptedContent(seal);
+    // Return undefined if the content is not found
+    if (!content)
         return undefined;
-    let rumor = JSON.parse(plaintext);
+    // Parse the content as a rumor event
+    let rumor = JSON.parse(content);
     // Check if the rumor event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(rumor.id);
     if (existing)
@@ -87,23 +102,26 @@ export function getSealRumor(seal) {
     else
         // Add to the internal event set
         internalGiftWrapEvents.add(rumor);
+    // Throw an error if the seal and rumor authors do not match
+    if (rumor.pubkey !== seal.pubkey)
+        throw new Error("Seal author does not match rumor author");
     // Save a reference to the parent seal event
     addParentSealReference(rumor, seal);
-    // Save a reference to the rumor on the seal (downstream)
+    // Cache the rumor event
     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)
+    if (Reflect.has(gift, SealSymbol))
+        return Reflect.get(gift, SealSymbol);
+    // Get the encrypted content
+    const content = getEncryptedContent(gift);
+    // Return undefined if the content is not found
+    if (!content)
         return undefined;
-    let seal = JSON.parse(plaintext);
+    // Parse seal as nostr event
+    let seal = JSON.parse(content);
     // Check if the seal event already exists in the internal event set
     const existing = internalGiftWrapEvents.getEvent(seal.id);
     if (existing) {
@@ -122,39 +140,27 @@ export function getGiftWrapSeal(gift) {
     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 || isSealLocked(seal))
-            return true;
-        else
-            return false;
-    }
-}
 /**
  * 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
+    // If already unlocked, return the rumor
+    if (isSealUnlocked(seal))
+        return seal[RumorSymbol];
+    // unlock encrypted content as needed
+    await unlockEncryptedContent(seal, seal.pubkey, signer);
     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");
+    // Notify event store
+    notifyEventUpdate(seal);
     return rumor;
 }
 /**
@@ -162,11 +168,13 @@ export async function unlockSeal(seal, signer) {
  * @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);
-    // Get the seal event
-    const seal = getGiftWrapSeal(gift);
+    // If already unlocked, return the rumor
+    if (isGiftWrapUnlocked(gift))
+        return getGiftWrapRumor(gift);
+    // Unlock the encrypted content
+    await unlockEncryptedContent(gift, gift.pubkey, signer);
+    // Parse seal as nostr event
+    let seal = getGiftWrapSeal(gift);
     if (!seal)
         throw new Error("Failed to read seal in gift wrap");
     // Unlock the seal event
@@ -175,6 +183,7 @@ export async function unlockGiftWrap(gift, signer) {
     notifyEventUpdate(gift);
     return rumor;
 }
+/** Locks a gift-wrap event and seals its seal event */
 export function lockGiftWrap(gift) {
     const seal = getGiftWrapSeal(gift);
     if (seal) {

package/dist/helpers/groups.d.ts

@@ -10,11 +10,8 @@ export type GroupPointer = {
     /** The name of the group */
     name?: string;
 };
-/**
- * decodes a group identifier into a group pointer object
- * @throws
- */
-export declare function decodeGroupPointer(str: string): GroupPointer;
+/** decodes a group identifier into a group pointer object */
+export declare function decodeGroupPointer(str: string): GroupPointer | null;
 /** Converts a group pointer into a group identifier */
 export declare function encodeGroupPointer(pointer: GroupPointer): string;
 export declare const GroupsPublicSymbol: unique symbol;