applesauce-core 0.10.0 → 0.12.0

package/dist/helpers/bookmarks.js

@@ -0,0 +1,27 @@
+import { kinds } from "nostr-tools";
+import { getAddressPointerFromATag, getEventPointerFromETag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getHiddenTags } from "./index.js";
+export const BookmarkPublicSymbol = Symbol.for("bookmark-public");
+export const BookmarkHiddenSymbol = Symbol.for("bookmark-hidden");
+export function parseBookmarkTags(tags) {
+    const notes = tags.filter((t) => t[0] === "e" && t[1]).map(getEventPointerFromETag);
+    const articles = tags
+        .filter((t) => t[0] === "a" && t[1])
+        .map(getAddressPointerFromATag)
+        .filter((addr) => addr.kind === kinds.LongFormArticle);
+    const hashtags = tags.filter((t) => t[0] === "t" && t[1]).map((t) => t[1]);
+    const urls = tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
+    return { notes, articles, hashtags, urls };
+}
+/** Returns the public bookmarks of the event */
+export function getBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkPublicSymbol, () => parseBookmarkTags(bookmark.tags));
+}
+/** Returns the bookmarks of the event if its unlocked */
+export function getHiddenBookmarks(bookmark) {
+    return getOrComputeCachedValue(bookmark, BookmarkHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return tags && parseBookmarkTags(tags);
+    });
+}

package/dist/helpers/cache.d.ts

@@ -1,5 +1,4 @@
-import { EventTemplate, NostrEvent } from "nostr-tools";
-export declare function getCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol): T | undefined;
-export declare function setCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, value: T): void;
+export declare function getCachedValue<T extends unknown>(event: any, symbol: symbol): T | undefined;
+export declare function setCachedValue<T extends unknown>(event: any, symbol: symbol, value: T): void;
 /** Internal method used to cache computed values on events */
-export declare function getOrComputeCachedValue<T extends unknown>(event: NostrEvent | EventTemplate, symbol: symbol, compute: (event: NostrEvent | EventTemplate) => T): T;
+export declare function getOrComputeCachedValue<T extends unknown>(event: any, symbol: symbol, compute: () => T): T;

package/dist/helpers/cache.js

@@ -10,7 +10,7 @@ export function getOrComputeCachedValue(event, symbol, compute) {
         return Reflect.get(event, symbol);
     }
     else {
-        const value = compute(event);
+        const value = compute();
         Reflect.set(event, symbol, value);
         return value;
     }

package/dist/helpers/channels.d.ts

@@ -0,0 +1,10 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channels.js

@@ -0,0 +1,27 @@
+import { getOrComputeCachedValue } from "./cache.js";
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    return getOrComputeCachedValue(channel, ChannelMetadataSymbol, () => {
+        return parseChannelMetadataContent(channel);
+    });
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/comment.d.ts

@@ -1,20 +1,20 @@
 import { NostrEvent } from "nostr-tools";
 import { ExternalPointer, ExternalIdentifiers } from "./external-id.js";
 export declare const COMMENT_KIND = 1111;
-type CommentEventPointer = {
+export type CommentEventPointer = {
     id: string;
     kind: number;
     pubkey?: string;
     relay?: string;
 };
-type CommentAddressPointer = {
+export type CommentAddressPointer = {
     id?: string;
     kind: number;
     pubkey: string;
     identifier: string;
     relay?: string;
 };
-type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
+export type CommentExternalPointer = ExternalPointer<keyof ExternalIdentifiers>;
 export type CommentPointer = CommentEventPointer | CommentAddressPointer | CommentExternalPointer;
 export declare const CommentRootPointerSymbol: unique symbol;
 export declare const CommentReplyPointerSymbol: unique symbol;
@@ -45,4 +45,3 @@ export declare function getCommentRootPointer(comment: NostrEvent): CommentPoint
 export declare function getCommentReplyPointer(comment: NostrEvent): CommentPointer | null;
 export declare function isCommentEventPointer(pointer: any): pointer is CommentEventPointer;
 export declare function isCommentAddressPointer(pointer: any): pointer is CommentAddressPointer;
-export {};

package/dist/helpers/comment.js

@@ -1,7 +1,7 @@
 import { getExternalPointerFromTag } from "./external-id.js";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getAddressPointerFromATag } from "./pointers.js";
-import { safeRelayUrl } from "./relays.js";
+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");
@@ -10,16 +10,18 @@ export const CommentReplyPointerSymbol = Symbol.for("comment-reply-pointer");
  * @throws
  */
 export function getCommentEventPointer(tags, root = false) {
-    const tag = tags.find((t) => t[0] === (root ? "E" : "e"));
+    const eTag = tags.find((t) => t[0] === (root ? "E" : "e"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
-    if (tag) {
+    if (eTag) {
         if (!kind)
             throw new Error("Missing kind tag");
+        // 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 = {
-            id: tag[1],
+            id: eTag[1],
             kind: parseInt(kind),
-            pubkey: tag[3] || undefined,
-            relay: tag[2] && (safeRelayUrl(tag[2]) ?? undefined),
+            pubkey: eTag[3] || rootPubkey || undefined,
+            relay: eTag[2] && isSafeRelayURL(eTag[2]) ? eTag[2] : undefined,
         };
         return pointer;
     }
@@ -30,16 +32,19 @@ export function getCommentEventPointer(tags, root = false) {
  * @throws
  */
 export function getCommentAddressPointer(tags, root = false) {
-    const tag = tags.find((t) => t[0] === (root ? "A" : "a"));
-    const id = tags.find((t) => t[0] === (root ? "E" : "e"))?.[1];
+    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 (tag) {
+    if (aTag) {
         if (!kind)
             throw new Error("Missing kind tag");
+        const addressPointer = getAddressPointerFromATag(aTag);
         const pointer = {
-            id,
-            ...getAddressPointerFromATag(tag),
-            kind: parseInt(kind),
+            id: eTag?.[1],
+            pubkey: addressPointer.pubkey,
+            identifier: addressPointer.identifier,
+            kind: addressPointer.kind || parseInt(kind),
+            relay: addressPointer.relays?.[0] || eTag?.[2],
         };
         return pointer;
     }
@@ -50,13 +55,12 @@ export function getCommentAddressPointer(tags, root = false) {
  * @throws
  */
 export function getCommentExternalPointer(tags, root = false) {
-    const tag = tags.find((t) => t[0] === (root ? "I" : "i"));
+    const iTag = tags.find((t) => t[0] === (root ? "I" : "i"));
     const kind = tags.find((t) => t[0] === (root ? "K" : "k"))?.[1];
-    if (tag) {
+    if (iTag) {
         if (!kind)
             throw new Error("Missing kind tag");
-        const pointer = getExternalPointerFromTag(tag);
-        return pointer;
+        return getExternalPointerFromTag(iTag);
     }
     return null;
 }

package/dist/helpers/contacts.d.ts

@@ -0,0 +1,3 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ContactsRelaysSymbol: unique symbol;
+export declare function getRelaysFromContactsEvent(event: NostrEvent): Map<string, "all" | "inbox" | "outbox"> | null;

package/dist/helpers/contacts.js

@@ -0,0 +1,25 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { isSafeRelayURL } from "./relays.js";
+export const ContactsRelaysSymbol = Symbol.for("contacts-relays");
+export function getRelaysFromContactsEvent(event) {
+    return getOrComputeCachedValue(event, ContactsRelaysSymbol, () => {
+        try {
+            const relayJson = JSON.parse(event.content);
+            const relays = new Map();
+            for (const [url, opts] of Object.entries(relayJson)) {
+                if (!isSafeRelayURL(url))
+                    continue;
+                if (opts.write && opts.read)
+                    relays.set(url, "all");
+                else if (opts.read)
+                    relays.set(url, "inbox");
+                else if (opts.write)
+                    relays.set(url, "outbox");
+            }
+            return relays;
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}

package/dist/helpers/direct-messages.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./hidden-content.js";
+/** Returns the decrypted content of a direct message */
+export declare function decryptDirectMessage(message: NostrEvent, signer: HiddenContentSigner): Promise<string>;

package/dist/helpers/direct-messages.js

@@ -0,0 +1,5 @@
+import { getHiddenContent, unlockHiddenContent } from "./hidden-content.js";
+/** Returns the decrypted content of a direct message */
+export async function decryptDirectMessage(message, signer) {
+    return getHiddenContent(message) || (await unlockHiddenContent(message, signer));
+}

package/dist/helpers/dns-identity.d.ts

@@ -0,0 +1,7 @@
+import { isNip05, NIP05_REGEX } from "nostr-tools/nip05";
+/** Returns the name and domain for a NIP-05 address */
+export declare function parseNIP05Address(address: string): {
+    name: string;
+    domain: string;
+} | null;
+export { isNip05, NIP05_REGEX };

package/dist/helpers/dns-identity.js

@@ -0,0 +1,10 @@
+import { isNip05, NIP05_REGEX } from "nostr-tools/nip05";
+/** Returns the name and domain for a NIP-05 address */
+export function parseNIP05Address(address) {
+    const match = address.toLowerCase().match(NIP05_REGEX);
+    if (!match)
+        return null;
+    const [, name = "_", domain] = match;
+    return { name, domain };
+}
+export { isNip05, NIP05_REGEX };

package/dist/helpers/emoji.d.ts

@@ -4,7 +4,9 @@ export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: str
 /** Returns the name of a NIP-30 emoji pack */
 export declare function getPackName(pack: NostrEvent): string | undefined;
 export type Emoji = {
-    name: string;
+    /** The emoji shortcode (without the ::) */
+    shortcode: string;
+    /** The URL to the emoji image */
     url: string;
 };
 /** Returns an array of emojis from a NIP-30 emoji pack */

package/dist/helpers/emoji.js

@@ -2,7 +2,7 @@ import { getTagValue } from "./event.js";
 /** Gets an "emoji" tag that matches an emoji code */
 export function getEmojiTag(event, code) {
     code = code.replace(/^:|:$/g, "").toLocaleLowerCase();
-    return event.tags.filter((t) => t[0] === "emoji" && t[1] && t[2]).find((t) => t[1].toLowerCase() === code);
+    return event.tags.find((t) => t[0] === "emoji" && t.length >= 3 && t[1].toLowerCase() === code);
 }
 /** Returns the name of a NIP-30 emoji pack */
 export function getPackName(pack) {
@@ -12,5 +12,5 @@ export function getPackName(pack) {
 export function getEmojis(pack) {
     return pack.tags
         .filter((t) => t[0] === "emoji" && t[1] && t[2])
-        .map((t) => ({ name: t[1], url: t[2] }));
+        .map((t) => ({ shortcode: t[1], url: t[2] }));
 }

package/dist/helpers/event.d.ts

@@ -1,7 +1,9 @@
 import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { IEventStore } from "../event-store/interface.js";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
 export declare const FromCacheSymbol: unique symbol;
+export declare const ReplaceableIdentifierSymbol: unique symbol;
 declare module "nostr-tools" {
     interface Event {
         [EventUIDSymbol]?: string;
@@ -33,10 +35,22 @@ export declare function getIndexableTags(event: NostrEvent): Set<string>;
  * Returns the second index ( tag[1] ) of the first tag that matches the name
  * If the event has any hidden tags they will be searched first
  */
-export declare function getTagValue(event: NostrEvent, name: string): string | undefined;
+export declare function getTagValue<T extends {
+    kind: number;
+    tags: string[][];
+    content: string;
+    pubkey: string;
+}>(event: T, name: string): string | undefined;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;
 /** Marks an event as being from a cache */
 export declare function markFromCache(event: NostrEvent): void;
 /** Returns if an event was from a cache */
 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;
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export declare function getReplaceableIdentifier(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,9 +1,13 @@
 import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { getHiddenTags } from "./hidden-tags.js";
+import { getOrComputeCachedValue } from "./cache.js";
+import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { EventStoreSymbol } from "../event-store/event-store.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
+export const ReplaceableIdentifierSymbol = Symbol.for("replaceable-identifier");
 /**
  * Checks if an object is a nostr event
  * NOTE: does not validation the signature on the event
@@ -34,20 +38,20 @@ export function isReplaceable(kind) {
  * For parametrized replaceable events this is ( event.kind + ":" + event.pubkey + ":" + event.tags.d.1 )
  */
 export function getEventUID(event) {
-    let id = event[EventUIDSymbol];
-    if (!id) {
+    let uid = event[EventUIDSymbol];
+    if (!uid) {
         if (isReplaceable(event.kind)) {
-            const d = event.tags.find((t) => t[0] === "d")?.[1];
-            id = getReplaceableUID(event.kind, event.pubkey, d);
-        }
-        else {
-            id = event.id;
+            let d = event.tags.find((t) => t[0] === "d")?.[1];
+            uid = getReplaceableUID(event.kind, event.pubkey, d);
         }
+        else
+            uid = event.id;
+        event[EventUIDSymbol] = uid;
     }
-    return id;
+    return uid;
 }
 export function getReplaceableUID(kind, pubkey, d) {
-    return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
+    return d ? kind + ":" + pubkey + ":" + d : kind + ":" + pubkey;
 }
 /** Returns a Set of tag names and values that are indexable */
 export function getIndexableTags(event) {
@@ -55,7 +59,7 @@ export function getIndexableTags(event) {
     if (!indexable) {
         const tags = new Set();
         for (const tag of event.tags) {
-            if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
+            if (tag.length >= 2 && tag[0].length === 1 && INDEXABLE_TAGS.has(tag[0])) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
@@ -76,7 +80,8 @@ export function getTagValue(event, name) {
 }
 /** Sets events verified flag without checking anything */
 export function fakeVerifyEvent(event) {
-    return (event[verifiedSymbol] = true);
+    event[verifiedSymbol] = true;
+    return true;
 }
 /** Marks an event as being from a cache */
 export function markFromCache(event) {
@@ -86,3 +91,21 @@ export function markFromCache(event) {
 export function isFromCache(event) {
     return !!event[FromCacheSymbol];
 }
+/** Returns the EventStore of an event if its been added to one */
+export function getParentEventStore(event) {
+    return Reflect.get(event, EventStoreSymbol);
+}
+/**
+ * Returns the replaceable identifier for a replaceable event
+ * @throws
+ */
+export function getReplaceableIdentifier(event) {
+    if (!isParameterizedReplaceableKind(event.kind))
+        throw new Error("Event is not replaceable");
+    return getOrComputeCachedValue(event, ReplaceableIdentifierSymbol, () => {
+        const d = getTagValue(event, "d");
+        if (d === undefined)
+            throw new Error("Event missing identifier");
+        return d;
+    });
+}

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

@@ -0,0 +1,55 @@
+import { NostrEvent } from "nostr-tools";
+export type FileMetadata = {
+    /** URL of the file */
+    url: string;
+    /** MIME type */
+    type?: string;
+    /** sha256 hash of the file */
+    sha256?: string;
+    /**
+     * The original sha256 hash before the file was transformed
+     * @deprecated
+     */
+    originalSha256?: string;
+    /** size of the file in bytes */
+    size?: number;
+    /** size of file in pixels in the form <width>x<height> */
+    dimensions?: string;
+    /** magnet */
+    magnet?: string;
+    /** torrent infohash */
+    infohash?: string;
+    /** URL to a thumbnail */
+    thumbnail?: string;
+    /** URL to a preview image with the same dimensions */
+    image?: string;
+    /** summary */
+    summary?: string;
+    /** description for accessability */
+    alt?: string;
+    /** blurhash */
+    blurhash?: string;
+    /** fallback URLs */
+    fallback?: string[];
+};
+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
+ */
+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
+ */
+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

@@ -0,0 +1,99 @@
+import { getOrComputeCachedValue } from "./cache.js";
+/**
+ * Parses file metadata tags into {@link FileMetadata}
+ * @throws
+ */
+export function parseFileMetadataTags(tags) {
+    const fields = {};
+    let fallback = undefined;
+    for (const [name, value] of tags) {
+        switch (name) {
+            case "fallback":
+                fallback = fallback ? [...fallback, value] : [value];
+                break;
+            default:
+                fields[name] = value;
+                break;
+        }
+    }
+    if (!fields.url)
+        throw new Error("Missing required url in file metadata");
+    const metadata = { url: fields.url, fallback };
+    // parse size
+    if (fields.size)
+        metadata.size = parseInt(fields.size);
+    // copy optional fields
+    if (fields.m)
+        metadata.type = fields.m;
+    if (fields.x)
+        metadata.sha256 = fields.x;
+    if (fields.ox)
+        metadata.originalSha256 = fields.ox;
+    if (fields.dim)
+        metadata.dimensions = fields.dim;
+    if (fields.magnet)
+        metadata.magnet = fields.magnet;
+    if (fields.i)
+        metadata.infohash = fields.i;
+    if (fields.thumb)
+        metadata.thumbnail = fields.thumb;
+    if (fields.image)
+        metadata.image = fields.image;
+    if (fields.summary)
+        metadata.summary = fields.summary;
+    if (fields.alt)
+        metadata.alt = fields.alt;
+    if (fields.blurhash)
+        metadata.blurhash = fields.blurhash;
+    return metadata;
+}
+/**
+ * Parses a imeta tag into a {@link FileMetadata}
+ * @throws
+ */
+export function getFileMetadataFromImetaTag(tag) {
+    const parts = tag.slice(1);
+    const tags = [];
+    for (const part of parts) {
+        const match = part.match(/^(.+?)\s(.+)$/);
+        if (match) {
+            const [_, name, value] = match;
+            tags.push([name, value]);
+        }
+    }
+    return parseFileMetadataTags(tags);
+}
+export const MediaAttachmentsSymbol = Symbol.for("media-attachments");
+/** Gets all the media attachments on an event */
+export function getMediaAttachments(event) {
+    return getOrComputeCachedValue(event, MediaAttachmentsSymbol, () => {
+        return event.tags
+            .filter((t) => t[0] === "imeta")
+            .map((tag) => {
+            try {
+                return getFileMetadataFromImetaTag(tag);
+            }
+            catch (error) {
+                // ignore invalid attachments
+                return undefined;
+            }
+        })
+            .filter((a) => !!a);
+    });
+}
+/**
+ * Gets {@link FileMetadata} for a NIP-94 kind 1063 event
+ * @throws
+ */
+export function getFileMetadata(file) {
+    return parseFileMetadataTags(file.tags);
+}
+/** Returns the last 64 length hex string in a URL */
+export function getSha256FromURL(url) {
+    if (typeof url === "string")
+        url = new URL(url);
+    const hashes = Array.from(url.pathname.matchAll(/[0-9a-f]{64}/gi));
+    if (hashes.length > 0)
+        return hashes[hashes.length - 1][0];
+    return;
+}

package/dist/helpers/filter.d.ts

@@ -6,5 +6,9 @@ import { Filter, NostrEvent } from "nostr-tools";
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
 /** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
+/**
+ * Copied from nostr-tools and modified to support undefined
+ */
+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

@@ -17,7 +17,7 @@ export function matchFilter(filter, event) {
     for (let f in filter) {
         if (f[0] === "#") {
             let tagName = f.slice(1);
-            let values = filter[`#${tagName}`];
+            let values = filter[f];
             if (values) {
                 const tags = getIndexableTags(event);
                 if (values.some((v) => tags.has(tagName + ":" + v)) === false)
@@ -40,6 +40,39 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
+/**
+ * Copied from nostr-tools and modified to support undefined
+ */
+export function mergeFilters(...filters) {
+    let result = {};
+    for (let i = 0; i < filters.length; i++) {
+        let filter = filters[i];
+        Object.entries(filter).forEach(([property, values]) => {
+            // skip undefined
+            if (values === undefined)
+                return;
+            if (property === "kinds" || property === "ids" || property === "authors" || property[0] === "#") {
+                // @ts-ignore
+                result[property] = result[property] || [];
+                // @ts-ignore
+                for (let v = 0; v < values.length; v++) {
+                    // @ts-ignore
+                    let value = values[v];
+                    // @ts-ignore
+                    if (!result[property].includes(value))
+                        result[property].push(value);
+                }
+            }
+        });
+        if (filter.limit && (!result.limit || filter.limit > result.limit))
+            result.limit = filter.limit;
+        if (filter.until && (!result.until || filter.until > result.until))
+            result.until = filter.until;
+        if (filter.since && (!result.since || filter.since < result.since))
+            result.since = filter.since;
+    }
+    return result;
+}
 /** Check if two filters are equal */
 export function isFilterEqual(a, b) {
     return equal(a, b);

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

@@ -0,0 +1,12 @@
+import { NostrEvent, UnsignedEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./hidden-content.js";
+export declare const GiftWrapSealSymbol: unique symbol;
+export declare const GiftWrapEventSymbol: unique symbol;
+/** Returns the unsigned seal event in a gift-wrap event */
+export declare function getGiftWrapSeal(gift: NostrEvent): NostrEvent | undefined;
+/** Returns the unsigned event in the gift-wrap seal */
+export declare function getGiftWrapEvent(gift: NostrEvent): UnsignedEvent | undefined;
+/** Returns if a gift-wrap event or gift-wrap seal is locked */
+export declare function isGiftWrapLocked(gift: NostrEvent): boolean;
+/** Unlocks and returns the unsigned seal event in a gift-wrap */
+export declare function unlockGiftWrap(gift: NostrEvent, signer: HiddenContentSigner): Promise<UnsignedEvent>;