applesauce-core 0.10.0 → 0.11.0

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/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,8 @@
-import { NostrEvent, VerifiedEvent } from "nostr-tools";
+import { EventTemplate, NostrEvent, VerifiedEvent } from "nostr-tools";
 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 +34,15 @@ 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(event: NostrEvent | EventTemplate, 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 replaceable identifier for a replaceable event
+ * @throws
+ */
+export declare function getReplaceableIdentifier(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,9 +1,12 @@
 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";
 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 +37,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 +58,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 +79,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 +90,17 @@ export function markFromCache(event) {
 export function isFromCache(event) {
     return !!event[FromCacheSymbol];
 }
+/**
+ * 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/groups.d.ts

@@ -0,0 +1,24 @@
+import { NostrEvent } from "nostr-tools";
+export declare const GROUPS_LIST_KIND = 10009;
+export declare const GROUP_MESSAGE_KIND = 9;
+/** NIP-29 group pointer */
+export type GroupPointer = {
+    id: string;
+    relay: string;
+    name?: string;
+};
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export declare function decodeGroupPointer(str: string): GroupPointer;
+/** Converts a group pointer into a group identifier */
+export declare function encodeGroupPointer(pointer: GroupPointer): string;
+export declare const GroupsPublicSymbol: unique symbol;
+export declare const GroupsHiddenSymbol: unique symbol;
+/** gets a {@link GroupPointer} from a "group" tag */
+export declare function getGroupPointerFromGroupTag(tag: string[]): GroupPointer;
+/** Returns all the public groups from a k:10009 list */
+export declare function getPublicGroups(bookmark: NostrEvent): GroupPointer[];
+/** Returns all the hidden groups from a k:10009 list */
+export declare function getHiddenGroups(bookmark: NostrEvent): GroupPointer[] | undefined;

package/dist/helpers/groups.js

@@ -0,0 +1,39 @@
+import { getOrComputeCachedValue } from "./cache.js";
+import { processTags } from "./tags.js";
+import { getHiddenTags } from "./hidden-tags.js";
+export const GROUPS_LIST_KIND = 10009;
+export const GROUP_MESSAGE_KIND = 9;
+/**
+ * decodes a group identifier into a group pointer object
+ * @throws
+ */
+export function decodeGroupPointer(str) {
+    const [relay, id] = str.split("'");
+    if (!relay)
+        throw new Error("Group pointer missing relay");
+    return { relay, id: id || "_" };
+}
+/** Converts a group pointer into a group identifier */
+export function encodeGroupPointer(pointer) {
+    const hostname = URL.canParse(pointer.relay) ? new URL(pointer.relay).hostname : pointer.relay;
+    return `${hostname}'${pointer.id}`;
+}
+export const GroupsPublicSymbol = Symbol.for("groups-public");
+export const GroupsHiddenSymbol = Symbol.for("groups-hidden");
+/** gets a {@link GroupPointer} from a "group" tag */
+export function getGroupPointerFromGroupTag(tag) {
+    const [_, id, relay, name] = tag;
+    return { id, relay, name };
+}
+/** Returns all the public groups from a k:10009 list */
+export function getPublicGroups(bookmark) {
+    return getOrComputeCachedValue(bookmark, GroupsPublicSymbol, () => processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+}
+/** Returns all the hidden groups from a k:10009 list */
+export function getHiddenGroups(bookmark) {
+    return getOrComputeCachedValue(bookmark, GroupsHiddenSymbol, () => {
+        const tags = getHiddenTags(bookmark);
+        return (tags &&
+            processTags(bookmark.tags.filter((t) => t[0] === "group"), getGroupPointerFromGroupTag));
+    });
+}

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

@@ -1,5 +1,5 @@
-import { EventTemplate, NostrEvent, UnsignedEvent } from "nostr-tools";
-import { EventStore } from "applesauce-core";
+import { EventTemplate, NostrEvent } from "nostr-tools";
+import { EventStore } from "../event-store/event-store.js";
 export type HiddenTagsSigner = {
     nip04?: {
         encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
@@ -10,7 +10,6 @@ export type HiddenTagsSigner = {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 };
-export type TagOperation = (tags: string[][]) => string[][];
 export declare const HiddenTagsSymbol: unique symbol;
 /** Various event kinds that can have encrypted tags in their content and which encryption method they use */
 export declare const EventEncryptionMethod: Record<number, "nip04" | "nip44">;
@@ -22,6 +21,14 @@ export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolea
 export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
 /** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+/** Returns either nip04 or nip44 encryption method depending on list kind */
+export declare function getListEncryptionMethods(kind: number, signer: HiddenTagsSigner): {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+} | {
+    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+};
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
@@ -29,18 +36,11 @@ export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
  * @param store An optional EventStore to notify about the update
  * @throws
  */
-export declare function unlockHiddenTags(event: NostrEvent, signer: HiddenTagsSigner, store?: EventStore): Promise<NostrEvent>;
-/**
- * Modifies tags and returns an EventTemplate
- * @param event Event to modify
- * @param operations Operations for hidden and public tags
- * @param signer A signer to use to decrypt the tags
- * @throws
- */
-export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, operations: {
-    public?: TagOperation;
-    hidden?: TagOperation;
-}, signer?: HiddenTagsSigner): Promise<EventTemplate>;
+export declare function unlockHiddenTags<T extends {
+    kind: number;
+    pubkey: string;
+    content: string;
+}>(event: T, signer: HiddenTagsSigner, store?: EventStore): Promise<T>;
 /**
  * Override the hidden tags in an event
  * @throws