applesauce-core 0.0.0-next-20250806165639 → 0.0.0-next-20250815164532

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

@@ -0,0 +1,67 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Subject } from "rxjs";
+import { LRU } from "../helpers/lru.js";
+/**
+ * An in-memory database for nostr events
+ * NOTE: does not handle replaceable events
+ */
+export declare class Database {
+    protected log: import("debug").Debugger;
+    /** Indexes */
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    /** A sorted array of replaceable events by uid */
+    protected replaceable: Map<string, import("nostr-tools").Event[]>;
+    /** A stream of events inserted into the database */
+    inserted: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been updated */
+    updated: Subject<import("nostr-tools").Event>;
+    /** A stream of events removed from the database */
+    removed: Subject<import("nostr-tools").Event>;
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert?: (event: NostrEvent) => void;
+    get size(): number;
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** Index helper methods */
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Moves an event to the top of the LRU cache */
+    touch(event: NostrEvent): void;
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id: string): boolean;
+    /** Gets a single event based on id */
+    getEvent(id: string): NostrEvent | undefined;
+    /** Checks if the database contains a replaceable event without touching it */
+    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    /** Gets an array of replaceable events */
+    getReplaceable(kind: number, pubkey: string, d?: string): NostrEvent[] | undefined;
+    /** Inserts an event into the database and notifies all subscriptions */
+    addEvent(event: NostrEvent): NostrEvent;
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event: NostrEvent): NostrEvent;
+    /** Removes an event from the database and notifies all subscriptions */
+    removeEvent(eventOrId: string | NostrEvent): boolean;
+    /** Sets the claim on the event and touches it */
+    claimEvent(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
+    iterateAuthors(authors: Iterable<string>): Generator<NostrEvent>;
+    iterateTag(tag: string, values: Iterable<string>): Generator<NostrEvent>;
+    iterateKinds(kinds: Iterable<number>): Generator<NostrEvent>;
+    iterateTime(since: number | undefined, until: number | undefined): Generator<NostrEvent>;
+    iterateIds(ids: Iterable<string>): Generator<NostrEvent>;
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    getEventsForFilters(filters: Filter[]): Set<NostrEvent>;
+    /** Remove the oldest events that are not claimed */
+    prune(limit?: number): number;
+}

package/dist/event-store/database.js

@@ -0,0 +1,316 @@
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { Subject } from "rxjs";
+import { getEventUID, getIndexableTags, getReplaceableUID, isReplaceable } from "../helpers/event.js";
+import { INDEXABLE_TAGS } from "./common.js";
+import { logger } from "../logger.js";
+import { LRU } from "../helpers/lru.js";
+/**
+ * An in-memory database for nostr events
+ * NOTE: does not handle replaceable events
+ */
+export class Database {
+    log = logger.extend("Database");
+    /** Indexes */
+    kinds = new Map();
+    authors = new Map();
+    tags = new LRU();
+    created_at = [];
+    /** LRU cache of last events touched */
+    events = new LRU();
+    /** A sorted array of replaceable events by uid */
+    replaceable = new Map();
+    /** A stream of events inserted into the database */
+    inserted = new Subject();
+    /** A stream of events that have been updated */
+    updated = new Subject();
+    /** A stream of events removed from the database */
+    removed = new Subject();
+    /** A method thats called before a new event is inserted */
+    onBeforeInsert;
+    get size() {
+        return this.events.size;
+    }
+    claims = new WeakMap();
+    /** Index helper methods */
+    getKindIndex(kind) {
+        if (!this.kinds.has(kind))
+            this.kinds.set(kind, new Set());
+        return this.kinds.get(kind);
+    }
+    getAuthorsIndex(author) {
+        if (!this.authors.has(author))
+            this.authors.set(author, new Set());
+        return this.authors.get(author);
+    }
+    getTagIndex(tagAndValue) {
+        if (!this.tags.has(tagAndValue)) {
+            // build new tag index from existing events
+            const events = new Set();
+            const ts = Date.now();
+            for (const event of this.events.values()) {
+                if (getIndexableTags(event).has(tagAndValue)) {
+                    events.add(event);
+                }
+            }
+            const took = Date.now() - ts;
+            if (took > 100)
+                this.log(`Built index ${tagAndValue} took ${took}ms`);
+            this.tags.set(tagAndValue, events);
+        }
+        return this.tags.get(tagAndValue);
+    }
+    /** Moves an event to the top of the LRU cache */
+    touch(event) {
+        this.events.set(event.id, event);
+    }
+    /** Checks if the database contains an event without touching it */
+    hasEvent(id) {
+        return this.events.has(id);
+    }
+    /** Gets a single event based on id */
+    getEvent(id) {
+        return this.events.get(id);
+    }
+    /** Checks if the database contains a replaceable event without touching it */
+    hasReplaceable(kind, pubkey, d) {
+        const events = this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+        return !!events && events.length > 0;
+    }
+    /** Gets an array of replaceable events */
+    getReplaceable(kind, pubkey, d) {
+        return this.replaceable.get(getReplaceableUID(kind, pubkey, d));
+    }
+    /** Inserts an event into the database and notifies all subscriptions */
+    addEvent(event) {
+        const id = event.id;
+        const current = this.events.get(id);
+        if (current)
+            return current;
+        this.onBeforeInsert?.(event);
+        this.events.set(id, event);
+        this.getKindIndex(event.kind).add(event);
+        this.getAuthorsIndex(event.pubkey).add(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).add(event);
+            }
+        }
+        // insert into time index
+        insertEventIntoDescendingList(this.created_at, event);
+        // insert into replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            let array = this.replaceable.get(uid);
+            if (!this.replaceable.has(uid)) {
+                // add an empty array if there is no array
+                array = [];
+                this.replaceable.set(uid, array);
+            }
+            // insert the event into the sorted array
+            insertEventIntoDescendingList(array, event);
+        }
+        this.inserted.next(event);
+        return event;
+    }
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event) {
+        const inserted = this.addEvent(event);
+        this.updated.next(inserted);
+        return inserted;
+    }
+    /** Removes an event from the database and notifies all subscriptions */
+    removeEvent(eventOrId) {
+        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+        if (!event)
+            throw new Error("Missing event");
+        const id = event.id;
+        // only remove events that are known
+        if (!this.events.has(id))
+            return false;
+        this.getAuthorsIndex(event.pubkey).delete(event);
+        this.getKindIndex(event.kind).delete(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).delete(event);
+            }
+        }
+        // remove from created_at index
+        const i = this.created_at.indexOf(event);
+        this.created_at.splice(i, 1);
+        this.events.delete(id);
+        // remove from replaceable index
+        if (isReplaceable(event.kind)) {
+            const uid = getEventUID(event);
+            const array = this.replaceable.get(uid);
+            if (array && array.includes(event)) {
+                const idx = array.indexOf(event);
+                array.splice(idx, 1);
+            }
+        }
+        // remove any claims this event has
+        this.claims.delete(event);
+        // notify subscribers this event was removed
+        this.removed.next(event);
+        return true;
+    }
+    /** Sets the claim on the event and touches it */
+    claimEvent(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
+    *iterateAuthors(authors) {
+        for (const author of authors) {
+            const events = this.authors.get(author);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTag(tag, values) {
+        for (const value of values) {
+            const events = this.getTagIndex(tag + ":" + value);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateKinds(kinds) {
+        for (const kind of kinds) {
+            const events = this.kinds.get(kind);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTime(since, until) {
+        let untilIndex = 0;
+        let sinceIndex = this.created_at.length - 1;
+        let start = until
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - until;
+            })
+            : undefined;
+        if (start)
+            untilIndex = start[0];
+        const end = since
+            ? binarySearch(this.created_at, (mid) => {
+                return mid.created_at - since;
+            })
+            : undefined;
+        if (end)
+            sinceIndex = end[0];
+        for (let i = untilIndex; i < sinceIndex; i++) {
+            yield this.created_at[i];
+        }
+    }
+    *iterateIds(ids) {
+        for (const id of ids) {
+            if (this.events.has(id))
+                yield this.events.get(id);
+        }
+    }
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter) {
+        // search is not supported, return an empty set
+        if (filter.search)
+            return new Set();
+        let first = true;
+        let events = new Set();
+        const and = (iterable) => {
+            const set = iterable instanceof Set ? iterable : new Set(iterable);
+            if (first) {
+                events = set;
+                first = false;
+            }
+            else {
+                for (const event of events) {
+                    if (!set.has(event))
+                        events.delete(event);
+                }
+            }
+            return events;
+        };
+        if (filter.ids)
+            and(this.iterateIds(filter.ids));
+        let time = null;
+        // query for time first if since is set
+        if (filter.since !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        for (const t of INDEXABLE_TAGS) {
+            const key = `#${t}`;
+            const values = filter[key];
+            if (values?.length)
+                and(this.iterateTag(t, values));
+        }
+        if (filter.authors)
+            and(this.iterateAuthors(filter.authors));
+        if (filter.kinds)
+            and(this.iterateKinds(filter.kinds));
+        // query for time last if only until is set
+        if (filter.since === undefined && filter.until !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        // if the filter queried on time and has a limit. truncate the events now
+        if (filter.limit && time) {
+            const limited = new Set();
+            for (const event of time) {
+                if (limited.size >= filter.limit)
+                    break;
+                if (events.has(event))
+                    limited.add(event);
+            }
+            return limited;
+        }
+        return events;
+    }
+    getEventsForFilters(filters) {
+        if (filters.length === 0)
+            throw new Error("No Filters");
+        let events = new Set();
+        for (const filter of filters) {
+            const filtered = this.getEventsForFilter(filter);
+            for (const event of filtered)
+                events.add(event);
+        }
+        return events;
+    }
+    /** Remove the oldest events that are not claimed */
+    prune(limit = 1000) {
+        let removed = 0;
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event)) {
+                this.removeEvent(event);
+                removed++;
+                if (removed >= limit)
+                    break;
+            }
+            cursor = cursor.next;
+        }
+        return removed;
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { kinds } from "nostr-tools";
+import { EventStore } from "./event-store.js";
+import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+const event = {
+    content: '{"name":"hzrd149","picture":"https://cdn.hzrd149.com/5ed3fe5df09a74e8c126831eac999364f9eb7624e2b86d521521b8021de20bdc.png","about":"JavaScript developer working on some nostr stuff\\n- noStrudel https://nostrudel.ninja/ \\n- Blossom https://github.com/hzrd149/blossom \\n- Applesauce https://hzrd149.github.io/applesauce/","website":"https://hzrd149.com","nip05":"_@hzrd149.com","lud16":"hzrd1499@minibits.cash","pubkey":"266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5","display_name":"hzrd149","displayName":"hzrd149","banner":""}',
+    created_at: 1738362529,
+    id: "e9df8d5898c4ccfbd21fcd59f3f48abb3ff0ab7259b19570e2f1756de1e9306b",
+    kind: 0,
+    pubkey: "266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5",
+    sig: "465a47b93626a587bf81dadc2b306b8f713a62db31d6ce1533198e9ae1e665a6eaf376a03250bf9ffbb02eb9059c8eafbd37ae1092d05d215757575bd8357586",
+    tags: [],
+};
+describe("add", () => {
+    it("should return original event in case of duplicates", () => {
+        const a = { ...event };
+        expect(eventStore.add(a)).toBe(a);
+        const b = { ...event };
+        expect(eventStore.add(b)).toBe(a);
+        const c = { ...event };
+        expect(eventStore.add(c)).toBe(a);
+    });
+    it("should merge seen relays on duplicate events", () => {
+        const a = { ...event };
+        addSeenRelay(a, "wss://relay.a.com");
+        eventStore.add(a);
+        const b = { ...event };
+        addSeenRelay(b, "wss://relay.b.com");
+        eventStore.add(b);
+        expect(eventStore.getEvent(event.id)).toBeDefined();
+        expect([...getSeenRelays(eventStore.getEvent(event.id))]).toEqual(expect.arrayContaining(["wss://relay.a.com", "wss://relay.b.com"]));
+    });
+    it("should ignore deleted events", () => {
+        const deleteEvent = {
+            id: "delete event id",
+            kind: kinds.EventDeletion,
+            created_at: event.created_at + 100,
+            pubkey: event.pubkey,
+            tags: [["e", event.id]],
+            sig: "this should be ignored for the test",
+            content: "test",
+        };
+        // add delete event first
+        eventStore.add(deleteEvent);
+        // now event should be ignored
+        eventStore.add(event);
+        expect(eventStore.getEvent(event.id)).toBeUndefined();
+    });
+});
+describe("verifyEvent", () => {
+    it("should be called for all events added", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        eventStore.add(event);
+        expect(verifyEvent).toHaveBeenCalledWith(event);
+    });
+    it("should not be called for duplicate events", () => {
+        const verifyEvent = vi.fn().mockReturnValue(true);
+        eventStore.verifyEvent = verifyEvent;
+        const a = { ...event };
+        eventStore.add(a);
+        expect(verifyEvent).toHaveBeenCalledWith(a);
+        const b = { ...event };
+        eventStore.add(b);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+        const c = { ...event };
+        eventStore.add(c);
+        expect(verifyEvent).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/helpers/__tests__/exports.test.js

@@ -23,7 +23,7 @@ describe("exports", () => {
         "FromCacheSymbol",
         "GROUPS_LIST_KIND",
         "GROUP_MESSAGE_KIND",
-        "GiftWrapRumorSymbol",
+        "GiftWrapEventSymbol",
         "GiftWrapSealSymbol",
         "GroupsHiddenSymbol",
         "GroupsPublicSymbol",
@@ -124,7 +124,7 @@ describe("exports", () => {
         "getExternalPointerFromTag",
         "getFileMetadata",
         "getFileMetadataFromImetaTag",
-        "getGiftWrapRumor",
+        "getGiftWrapEvent",
         "getGiftWrapSeal",
         "getGroupPointerFromGroupTag",
         "getGroupPointerFromHTag",
@@ -175,7 +175,6 @@ describe("exports", () => {
         "getReplaceableIdentifier",
         "getReplaceableUID",
         "getReported",
-        "getSealRumor",
         "getSeenRelays",
         "getSha256FromURL",
         "getSharedAddressPointer",
@@ -231,7 +230,6 @@ describe("exports", () => {
         "isReplaceable",
         "isSafeRelayURL",
         "isSameURL",
-        "isSealLocked",
         "isSha256",
         "isStreamURL",
         "isTTag",

package/dist/helpers/__tests__/nip-19.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/nip-19.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { bytesToHex } from "@noble/hashes/utils";
+import { normalizeToPubkey, normalizeToSecretKey } from "../nip-19.js";
+describe("normalizeToPubkey", () => {
+    it("should get pubkey from npub", () => {
+        expect(normalizeToPubkey("npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should get pubkey from nprofile", () => {
+        expect(normalizeToPubkey("nprofile1qyw8wumn8ghj7umpw3jkcmrfw3jju6r6wfjrzdpe9e3k7mf0qyf8wumn8ghj7mn0wd68yat99e3k7mf0qqszv6q4uryjzr06xfxxew34wwc5hmjfmfpqn229d72gfegsdn2q3fg5g7lja")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should return hex pubkey", () => {
+        expect(normalizeToPubkey("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5")).toEqual("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+    });
+    it("should throw on invalid hex pubkey", () => {
+        expect(() => {
+            normalizeToPubkey("5028372");
+        }).toThrow();
+    });
+    it("should throw on invalid string", () => {
+        expect(() => {
+            normalizeToPubkey("testing");
+        }).toThrow();
+    });
+});
+describe("normalizeToSecretKey", () => {
+    it("should get secret key from nsec", () => {
+        expect(bytesToHex(normalizeToSecretKey("nsec1xe7znq745x5n68566l32ru72aajz3pk2cys9lnf3tuexvkw0dldsj8v2lm"))).toEqual("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb");
+    });
+    it("should get secret key from raw hex", () => {
+        expect(bytesToHex(normalizeToSecretKey("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb"))).toEqual("367c2983d5a1a93d1e9ad7e2a1f3caef642886cac1205fcd315f326659cf6fdb");
+    });
+    it("should throw on invalid hex key", () => {
+        expect(() => {
+            normalizeToSecretKey("209573290");
+        }).toThrow();
+    });
+    it("should throw on npub", () => {
+        expect(() => {
+            normalizeToSecretKey("npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr");
+        }).toThrow();
+    });
+});

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/encrypted-content.d.ts

@@ -10,18 +10,26 @@ export interface EncryptedContentSigner {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 }
-/** Various event kinds that can have encrypted content and which encryption method they use */
-export declare const EventContentEncryptionMethod: Record<number, "nip04" | "nip44">;
-/** Sets the encryption method that is used for the contents of a specific event kind */
-export declare function setEncryptedContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner): {
+export type EncryptionMethod = "nip04" | "nip44";
+/** A pair of encryption methods for encrypting and decrypting event content */
+export interface EncryptionMethods {
     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;
-};
+}
+/** Various event kinds that can have encrypted content and which encryption method they use */
+export declare const EventContentEncryptionMethod: Record<number, EncryptionMethod>;
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export declare function setEncryptedContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner, override?: EncryptionMethod): EncryptionMethods;
 /** Checks if an event can have encrypted content */
 export declare function canHaveEncryptedContent(kind: number): boolean;
 /** Checks if an event has encrypted content */

package/dist/helpers/encrypted-content.js

@@ -13,9 +13,17 @@ export function setEncryptedContentEncryptionMethod(kind, method) {
     EventContentEncryptionMethod[kind] = method;
     return kind;
 }
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export function getEncryptedContentEncryptionMethods(kind, signer) {
-    const method = EventContentEncryptionMethod[kind];
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @throws If the event kind does not support encrypted content
+ * @throws If the signer does not support the encryption method
+ * @returns The encryption methods for the event kind
+ */
+export function getEncryptedContentEncryptionMethods(kind, signer, override) {
+    const method = override ?? EventContentEncryptionMethod[kind];
     if (!method)
         throw new Error(`Event kind ${kind} does not support encrypted content`);
     const encryption = signer[method];

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

@@ -0,0 +1 @@
+export {};