applesauce-core 0.0.0-next-20241119142128 → 0.0.0-next-20241119173145

package/dist/helpers/event.d.ts

@@ -24,7 +24,10 @@ export declare function getEventUID(event: NostrEvent): string;
 export declare function getReplaceableUID(kind: number, pubkey: string, d?: string): string;
 /** Returns a Set of tag names and values that are indexable */
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
-/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+/**
+ * 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;
 /** Sets events verified flag without checking anything */
 export declare function fakeVerifyEvent(event: NostrEvent): event is VerifiedEvent;

package/dist/helpers/event.js

@@ -1,5 +1,6 @@
 import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
+import { getHiddenTags } from "./hidden-tags.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 export const FromCacheSymbol = Symbol.for("from-cache");
@@ -46,8 +47,15 @@ export function getIndexableTags(event) {
     }
     return indexable;
 }
-/** Returns the second index ( tag[1] ) of the first tag that matches the name */
+/**
+ * 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 function getTagValue(event, name) {
+    const hidden = getHiddenTags(event);
+    const hiddenValue = hidden?.find((t) => t[0] === name)?.[1];
+    if (hiddenValue)
+        return hiddenValue;
     return event.tags.find((t) => t[0] === name)?.[1];
 }
 /** Sets events verified flag without checking anything */

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

@@ -0,0 +1,39 @@
+import { EventTemplate, NostrEvent, UnsignedEvent } from "nostr-tools";
+import { EventStore } from "applesauce-core";
+export type HiddenTagsSigner = {
+    nip04: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+};
+export type TagOperation = (tags: string[][]) => string[][];
+export declare const HiddenTagsSymbol: unique symbol;
+export declare const EventsWithHiddenTags: number[];
+/** Checks if an event can have hidden tags */
+export declare function canHaveHiddenTags(event: NostrEvent | EventTemplate): boolean;
+/** Checks if an event has hidden tags */
+export declare function hasHiddenTags(event: NostrEvent | EventTemplate): boolean;
+/** Returns the hidden tags from an event if they are unlocked */
+export declare function getHiddenTags(event: NostrEvent | EventTemplate): string[][] | undefined;
+export declare function isHiddenTagsLocked(event: NostrEvent): boolean;
+/**
+ * Decrypts the private list
+ * @param event The list event to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @param store An optional EventStore to notify about the update
+ */
+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
+ */
+export declare function modifyEventTags(event: NostrEvent | UnsignedEvent, operations: {
+    public?: TagOperation;
+    hidden?: TagOperation;
+}, signer?: HiddenTagsSigner): Promise<EventTemplate>;
+/**
+ * Override the hidden tags in an event
+ */
+export declare function overrideHiddenTags(event: NostrEvent, hidden: string[][], signer: HiddenTagsSigner): Promise<EventTemplate>;

package/dist/helpers/hidden-tags.js

@@ -0,0 +1,90 @@
+import { unixNow } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+export const HiddenTagsSymbol = Symbol.for("hidden-tags");
+export const EventsWithHiddenTags = [
+    37375, // NIP-60 wallet
+    // NIP-51 lists
+    kinds.BookmarkList,
+    kinds.InterestsList,
+    kinds.Mutelist,
+    kinds.CommunitiesList,
+    kinds.PublicChatsList,
+    kinds.SearchRelaysList,
+    kinds.SearchRelaysList,
+    10009, // NIP-29 groups
+    // NIP-51 sets
+    kinds.Bookmarksets,
+    kinds.Relaysets,
+    kinds.Followsets,
+    kinds.Curationsets,
+    kinds.Interestsets,
+];
+/** Checks if an event can have hidden tags */
+export function canHaveHiddenTags(event) {
+    return EventsWithHiddenTags.includes(event.kind);
+}
+/** Checks if an event has hidden tags */
+export function hasHiddenTags(event) {
+    return canHaveHiddenTags(event) && event.content.length > 0;
+}
+/** Returns the hidden tags from an event if they are unlocked */
+export function getHiddenTags(event) {
+    return Reflect.get(event, HiddenTagsSymbol);
+}
+export function isHiddenTagsLocked(event) {
+    return hasHiddenTags(event) && getHiddenTags(event) === undefined;
+}
+/**
+ * Decrypts the private list
+ * @param event The list event to decrypt
+ * @param signer A signer to use to decrypt the tags
+ * @param store An optional EventStore to notify about the update
+ */
+export async function unlockHiddenTags(event, signer, store) {
+    const plaintext = await signer.nip04.decrypt(event.pubkey, event.content);
+    const parsed = JSON.parse(plaintext);
+    if (!Array.isArray(parsed))
+        throw new Error("Content is not an array of tags");
+    // Convert array to tags array string[][]
+    const tags = parsed.filter((t) => Array.isArray(t)).map((t) => t.map((v) => String(v)));
+    Reflect.set(event, HiddenTagsSymbol, tags);
+    if (store)
+        store.update(event);
+    return event;
+}
+/**
+ * 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
+ */
+export async function modifyEventTags(event, operations, signer) {
+    const draft = { content: event.content, tags: event.tags, kind: event.kind, created_at: unixNow() };
+    if (operations.public) {
+        draft.tags = operations.public(event.tags);
+    }
+    if (operations.hidden) {
+        if (!signer)
+            throw new Error("Missing signer for hidden tags");
+        if (!canHaveHiddenTags(event))
+            throw new Error("Event can not have hidden tags");
+        const hidden = hasHiddenTags(event) ? getHiddenTags(event) : [];
+        if (!hidden)
+            throw new Error("Hidden tags are locked");
+        const newHidden = operations.hidden(hidden);
+        draft.content = await signer.nip04.encrypt(event.pubkey, JSON.stringify(newHidden));
+    }
+    return draft;
+}
+/**
+ * Override the hidden tags in an event
+ */
+export async function overrideHiddenTags(event, hidden, signer) {
+    const ciphertext = await signer.nip04.encrypt(event.pubkey, JSON.stringify(hidden));
+    return {
+        kind: event.kind,
+        content: ciphertext,
+        created_at: unixNow(),
+        tags: event.tags,
+    };
+}

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

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

package/dist/helpers/hidden-tags.test.js

@@ -0,0 +1,27 @@
+import { getHiddenTags, unixNow, unlockHiddenTags } from "applesauce-core/helpers";
+import { finalizeEvent, generateSecretKey, getPublicKey, kinds, nip04 } from "nostr-tools";
+const key = generateSecretKey();
+const pubkey = getPublicKey(key);
+const signer = {
+    nip04: {
+        encrypt: (pubkey, plaintext) => nip04.encrypt(key, pubkey, plaintext),
+        decrypt: (pubkey, ciphertext) => nip04.decrypt(key, pubkey, ciphertext),
+    },
+};
+describe("Private Lists", () => {
+    describe("unlockHiddenTags", () => {
+        let list;
+        beforeEach(async () => {
+            list = finalizeEvent({
+                kind: kinds.Mutelist,
+                created_at: unixNow(),
+                content: await nip04.encrypt(key, pubkey, JSON.stringify([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]])),
+                tags: [],
+            }, key);
+        });
+        it("should unlock hidden tags", async () => {
+            await unlockHiddenTags(list, signer);
+            expect(getHiddenTags(list)).toEqual(expect.arrayContaining([["p", "npub1ye5ptcxfyyxl5vjvdjar2ua3f0hynkjzpx552mu5snj3qmx5pzjscpknpr"]]));
+        });
+    });
+});

package/dist/helpers/index.d.ts

@@ -14,3 +14,4 @@ export * from "./hashtag.js";
 export * from "./url.js";
 export * from "./zap.js";
 export * from "./bolt11.js";
+export * from "./hidden-tags.js";

package/dist/helpers/index.js

@@ -14,3 +14,4 @@ export * from "./hashtag.js";
 export * from "./url.js";
 export * from "./zap.js";
 export * from "./bolt11.js";
+export * from "./hidden-tags.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20241119142128",
+  "version": "0.0.0-next-20241119173145",
   "description": "",
   "type": "module",
   "main": "dist/index.js",