applesauce-core 3.1.0 → 4.1.0

package/dist/helpers/comment.js

@@ -5,16 +5,14 @@ import { isSafeRelayURL } from "./relays.js";
 export const COMMENT_KIND = 1111;
 export const CommentRootPointerSymbol = Symbol.for("comment-root-pointer");
 export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
-/**
- * Gets the EventPointer from an array of tags
- * @throws
- */
+/** Gets the EventPointer from an array of tags */
 export function getCommentEventPointer(tags, root = false) {
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (eTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         // only the root pubkey can be gotten from the tags, since due to quotes and mentions there will be many "p" tags for replies
         const rootPubkey = root ? tags.find((t) => t[0] === "P")?.[1] : undefined;
         const pointer = {
@@ -28,17 +26,15 @@ export function getCommentEventPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the AddressPointer from an array of tags
- * @throws
- */
+/** Gets the AddressPointer from an array of tags */
 export function getCommentAddressPointer(tags, root = false) {
     const aTag = tags.find((t) => t[0] === (root ? "A" : "a"));
     const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (aTag) {
+        // Missing kind tag, return null
         if (!kind)
-            throw new Error("Missing kind tag");
+            return null;
         const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
             type: "address",
@@ -52,16 +48,10 @@ export function getCommentAddressPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Gets the ExternalPointer from an array of tags
- * @throws
- */
+/** Gets the ExternalPointer from an array of tags */
 export function getCommentExternalPointer(tags, root = false) {
     const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
-    const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
     if (iTag) {
-        if (!kind)
-            throw new Error("Missing kind tag");
         return {
             type: "external",
             ...getExternalPointerFromTag(iTag),
@@ -69,13 +59,9 @@ export function getCommentExternalPointer(tags, root = false) {
     }
     return null;
 }
-/**
- * Returns the root pointer for a comment
- * @throws
- */
 export function getCommentRootPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentRootPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, true);
@@ -90,13 +76,10 @@ export function getCommentRootPointer(comment) {
         return null;
     });
 }
-/**
- * Returns the reply pointer for a comment
- * @throws
- */
+/** Returns the reply pointer for a comment */
 export function getCommentReplyPointer(comment) {
     if (comment.kind !== COMMENT_KIND)
-        throw new Error("Event is not a comment");
+        return null;
     return getOrComputeCachedValue(comment, CommentReplyPointerSymbol, () => {
         // check for address pointer first since it can also have E tags
         const A = getCommentAddressPointer(comment.tags, false);
@@ -111,15 +94,21 @@ export function getCommentReplyPointer(comment) {
         return null;
     });
 }
+/** Checks if a pointer is a {@link CommentEventPointer} */
 export function isCommentEventPointer(pointer) {
     return (Reflect.has(pointer, "id") &&
         Reflect.has(pointer, "kind") &&
         !Reflect.has(pointer, "identifier") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a pointer is a {@link CommentAddressPointer} */
 export function isCommentAddressPointer(pointer) {
     return (Reflect.has(pointer, "identifier") &&
         Reflect.has(pointer, "pubkey") &&
         Reflect.has(pointer, "kind") &&
         typeof pointer.kind === "number");
 }
+/** Checks if a comment event is valid */
+export function isValidComment(comment) {
+    return (comment.kind === COMMENT_KIND && getCommentRootPointer(comment) !== null && getCommentReplyPointer(comment) !== null);
+}

package/dist/helpers/contacts.d.ts

@@ -1,14 +1,23 @@
 import { NostrEvent } from "nostr-tools";
 import { ProfilePointer } from "nostr-tools/nip19";
+import { HiddenContentSigner } from "./hidden-content.js";
 export declare const ContactsRelaysSymbol: unique symbol;
 export declare const PublicContactsSymbol: unique symbol;
 export declare const HiddenContactsSymbol: unique symbol;
-export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;
+/** Type for contact events with unlocked hidden tags */
+export type UnlockedContacts = {
+    [HiddenContactsSymbol]: ProfilePointer[];
+};
+export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "inbox" | "outbox" | "all"> | null;
 /** Merges any number of contact lists into a single list */
 export declare function mergeContacts(...pointers: (ProfilePointer | undefined | (ProfilePointer | undefined)[])[]): ProfilePointer[];
 /** Returns all public and hidden contacts from a contacts list event */
 export declare function getContacts(event: NostrEvent): ProfilePointer[];
 /** Returns only the public contacts from a contacts list event */
 export declare function getPublicContacts(event: NostrEvent): ProfilePointer[];
+/** Checks if the hidden contacts are unlocked */
+export declare function isHiddenContactsUnlocked<T extends NostrEvent>(event: T): event is T & UnlockedContacts;
 /** Returns only the hidden contacts from a contacts list event */
 export declare function getHiddenContacts(event: NostrEvent): ProfilePointer[] | undefined;
+/** Unlocks the hidden contacts */
+export declare function unlockHiddenContacts(event: NostrEvent, signer: HiddenContentSigner): Promise<ProfilePointer[]>;

package/dist/helpers/contacts.js

@@ -2,7 +2,8 @@ import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
 import { isPTag, processTags } from "./tags.js";
 import { getProfilePointerFromPTag } from "./pointers.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "./hidden-tags.js";
+import { notifyEventUpdate } from "./index.js";
 export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
 export const PublicContactsSymbol = Symbol.for("public-contacts");
 export const HiddenContactsSymbol = Symbol.for("hidden-contacts");
@@ -51,9 +52,35 @@ export function getContacts(event) {
 export function getPublicContacts(event) {
     return getOrComputeCachedValue(event, PublicContactsSymbol, () => processTags(event.tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
 }
+/** Checks if the hidden contacts are unlocked */
+export function isHiddenContactsUnlocked(event) {
+    return isHiddenTagsUnlocked(event) && Reflect.has(event, HiddenContactsSymbol);
+}
 /** Returns only the hidden contacts from a contacts list event */
 export function getHiddenContacts(event) {
-    if (isHiddenTagsLocked(event))
+    if (isHiddenContactsUnlocked(event))
+        return event[HiddenContactsSymbol];
+    // Get hidden tags
+    const tags = getHiddenTags(event);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(event, HiddenContactsSymbol, () => processTags(getHiddenTags(event), (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag));
+    // Parse tags
+    const contacts = processTags(tags, (t) => (isPTag(t) ? t : undefined), getProfilePointerFromPTag);
+    // Set cache and notify event store
+    Reflect.set(event, HiddenContactsSymbol, contacts);
+    return contacts;
+}
+/** Unlocks the hidden contacts */
+export async function unlockHiddenContacts(event, signer) {
+    if (isHiddenContactsUnlocked(event))
+        return event[HiddenContactsSymbol];
+    // Unlock hidden tags
+    await unlockHiddenTags(event, signer);
+    // Get hidden contacts
+    const contacts = getHiddenContacts(event);
+    if (!contacts)
+        throw new Error("Failed to unlock hidden contacts");
+    // Set cache and notify event store
+    notifyEventUpdate(event);
+    return contacts;
 }

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;