applesauce-core 0.0.0-next-20241115160057 → 0.0.0-next-20241119160247

package/dist/helpers/bolt11.d.ts

@@ -5,4 +5,5 @@ export type ParsedInvoice = {
     timestamp: number;
     expiry: number;
 };
+/** Parses a lightning invoice */
 export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -1,4 +1,5 @@
 import { decode } from "light-bolt11-decoder";
+/** Parses a lightning invoice */
 export function parseBolt11(paymentRequest) {
     const decoded = decode(paymentRequest);
     const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;

package/dist/helpers/emoji.d.ts

@@ -1,2 +1,9 @@
 import { EventTemplate, NostrEvent } from "nostr-tools";
 export declare function getEmojiTag(event: NostrEvent | EventTemplate, code: string): ["emoji", string, string];
+/** Returns the name of a NIP-30 emoji pack */
+export declare function getPackName(pack: NostrEvent): string | undefined;
+/** Returns an array of emojis from a NIP-30 emoji pack */
+export declare function getEmojis(pack: NostrEvent): {
+    name: string;
+    url: string;
+}[];

package/dist/helpers/emoji.js

@@ -1,4 +1,15 @@
+import { getTagValue } from "./event.js";
 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);
 }
+/** Returns the name of a NIP-30 emoji pack */
+export function getPackName(pack) {
+    return getTagValue(pack, "title") || getTagValue(pack, "d");
+}
+/** Returns an array of emojis from a NIP-30 emoji 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] }));
+}

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/dist/helpers/json.d.ts

@@ -1 +1,2 @@
+/** Returns the parsed JSON or undefined if invalid */
 export declare function safeParse<T extends unknown = any>(str: string): T | undefined;

package/dist/helpers/json.js

@@ -1,3 +1,4 @@
+/** Returns the parsed JSON or undefined if invalid */
 export function safeParse(str) {
     try {
         return JSON.parse(str);

package/dist/helpers/mailboxes.d.ts

@@ -1,12 +1,6 @@
 import { NostrEvent } from "nostr-tools";
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [MailboxesInboxesSymbol]?: string[];
-        [MailboxesOutboxesSymbol]?: string[];
-    }
-}
 /**
  * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */

package/dist/helpers/mailboxes.js

@@ -1,11 +1,12 @@
 import { safeRelayUrl } from "./relays.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
 export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
 /**
  * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
 export function getInboxes(event) {
-    if (!event[MailboxesInboxesSymbol]) {
+    return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
@@ -14,15 +15,14 @@ export function getInboxes(event) {
                     inboxes.push(url);
             }
         }
-        event[MailboxesInboxesSymbol] = inboxes;
-    }
-    return event[MailboxesInboxesSymbol];
+        return inboxes;
+    });
 }
 /**
  * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export function getOutboxes(event) {
-    if (!event[MailboxesOutboxesSymbol]) {
+    return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
@@ -31,7 +31,6 @@ export function getOutboxes(event) {
                     outboxes.push(url);
             }
         }
-        event[MailboxesOutboxesSymbol] = outboxes;
-    }
-    return event[MailboxesOutboxesSymbol];
+        return outboxes;
+    });
 }

package/dist/helpers/profile.d.ts

@@ -16,3 +16,5 @@ export type ProfileContent = {
 };
 /** Returns the parsed profile content for a kind 0 event */
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
+/** Checks if the content of the kind 0 event is valid JSON */
+export declare function isValidProfile(profile?: NostrEvent): boolean;

package/dist/helpers/profile.js

@@ -1,3 +1,4 @@
+import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
 /** Returns the parsed profile content for a kind 0 event */
@@ -14,3 +15,17 @@ export function getProfileContent(event) {
         return profile;
     });
 }
+/** Checks if the content of the kind 0 event is valid JSON */
+export function isValidProfile(profile) {
+    if (!profile)
+        return false;
+    if (profile.kind !== kinds.Metadata)
+        return false;
+    try {
+        getProfileContent(profile);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/helpers/string.d.ts

@@ -1,4 +1,10 @@
+/** Tests if a string is hex */
 export declare function isHex(str?: string): boolean;
+/** Tests if a string is a 64 length hex string */
 export declare function isHexKey(key?: string): boolean;
+/**
+ * Remove invisible characters from a string
+ * @see read more https://www.regular-expressions.info/unicode.html#category
+ */
 export declare function stripInvisibleChar(str: string): string;
 export declare function stripInvisibleChar(str?: string | undefined): string | undefined;

package/dist/helpers/string.js

@@ -1,8 +1,10 @@
+/** Tests if a string is hex */
 export function isHex(str) {
     if (str?.match(/^[0-9a-f]+$/i))
         return true;
     return false;
 }
+/** Tests if a string is a 64 length hex string */
 export function isHexKey(key) {
     if (key?.toLowerCase()?.match(/^[0-9a-f]{64}$/))
         return true;

package/dist/helpers/zap.d.ts

@@ -11,3 +11,4 @@ export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-too
 export declare function getZapEventPointer(zap: NostrEvent): import("nostr-tools/nip19").EventPointer | null;
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
 export declare function getZapRequest(zap: NostrEvent): import("nostr-tools").Event;
+export declare function isValidZap(zap?: NostrEvent): boolean;

package/dist/helpers/zap.js

@@ -1,4 +1,4 @@
-import { nip57 } from "nostr-tools";
+import { kinds, nip57 } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
 import { getTagValue } from "./event.js";
 import { isATag, isETag } from "./tags.js";
@@ -50,3 +50,17 @@ export function getZapRequest(zap) {
         return JSON.parse(description);
     });
 }
+export function isValidZap(zap) {
+    if (!zap)
+        return false;
+    if (zap.kind !== kinds.Zap)
+        return false;
+    try {
+        getZapRequest(zap);
+        getZapRecipient(zap);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/queries/profile.js

@@ -1,11 +1,11 @@
 import { kinds } from "nostr-tools";
-import { map } from "rxjs/operators";
-import { getProfileContent } from "../helpers/profile.js";
+import { filter, map } from "rxjs/operators";
+import { getProfileContent, isValidProfile } from "../helpers/profile.js";
 export function ProfileQuery(pubkey) {
     return {
         key: pubkey,
         run: (events) => {
-            return events.replaceable(kinds.Metadata, pubkey).pipe(map((event) => event && getProfileContent(event)));
+            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
         },
     };
 }

package/dist/queries/zaps.js

@@ -1,15 +1,19 @@
+import { map } from "rxjs";
 import { kinds } from "nostr-tools";
 import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
+import { isValidZap } from "../helpers/zap.js";
 export function EventZapsQuery(id) {
     return {
         key: JSON.stringify(id),
         run: (events) => {
             if (isAddressPointer(id)) {
-                return events.timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }]);
+                return events
+                    .timeline([{ kinds: [kinds.Zap], "#a": [getCoordinateFromAddressPointer(id)] }])
+                    .pipe(map((events) => events.filter(isValidZap)));
             }
             else {
                 id = typeof id === "string" ? id : id.id;
-                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]);
+                return events.timeline([{ kinds: [kinds.Zap], "#e": [id] }]).pipe(map((events) => events.filter(isValidZap)));
             }
         },
     };

package/package.json

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