applesauce-core 0.0.0-next-20250123205825 → 0.0.0-next-20250123215242

package/dist/helpers/hidden-tags.js

@@ -0,0 +1,108 @@
+import { unixNow } from "applesauce-core/helpers";
+import { kinds } from "nostr-tools";
+export const HiddenTagsSymbol = Symbol.for("hidden-tags");
+/** Various event kinds that can have encrypted tags in their content and which encryption method they use */
+export const EventEncryptionMethod = {
+    // NIP-60 wallet
+    37375: "nip44",
+    // NIP-51 lists
+    [kinds.BookmarkList]: "nip04",
+    [kinds.InterestsList]: "nip04",
+    [kinds.Mutelist]: "nip04",
+    [kinds.CommunitiesList]: "nip04",
+    [kinds.PublicChatsList]: "nip04",
+    [kinds.SearchRelaysList]: "nip04",
+    // NIP-51 sets
+    [kinds.Bookmarksets]: "nip04",
+    [kinds.Relaysets]: "nip04",
+    [kinds.Followsets]: "nip04",
+    [kinds.Curationsets]: "nip04",
+    [kinds.Interestsets]: "nip04",
+};
+/** Checks if an event can have hidden tags */
+export function canHaveHiddenTags(kind) {
+    return EventEncryptionMethod[kind] !== undefined;
+}
+/** Checks if an event has hidden tags */
+export function hasHiddenTags(event) {
+    return canHaveHiddenTags(event.kind) && event.content.length > 0;
+}
+/** Returns the hidden tags for an event if they are unlocked */
+export function getHiddenTags(event) {
+    return Reflect.get(event, HiddenTagsSymbol);
+}
+/** Checks if the hidden tags are locked */
+export function isHiddenTagsLocked(event) {
+    return hasHiddenTags(event) && getHiddenTags(event) === undefined;
+}
+function getEventEncryption(kind, signer) {
+    const method = EventEncryptionMethod[kind];
+    const encryption = signer[method];
+    if (!encryption)
+        throw new Error(`Signer does not support ${method} encryption`);
+    return encryption;
+}
+/**
+ * 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
+ * @throws
+ */
+export async function unlockHiddenTags(event, signer, store) {
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getEventEncryption(event.kind, signer);
+    const plaintext = await encryption.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
+ * @throws
+ */
+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.kind))
+            throw new Error("Event kind does not support hidden tags");
+        const hidden = hasHiddenTags(event) ? getHiddenTags(event) : [];
+        if (!hidden)
+            throw new Error("Hidden tags are locked");
+        const newHidden = operations.hidden(hidden);
+        const encryption = getEventEncryption(event.kind, signer);
+        draft.content = await encryption.encrypt(event.pubkey, JSON.stringify(newHidden));
+    }
+    return draft;
+}
+/**
+ * Override the hidden tags in an event
+ * @throws
+ */
+export async function overrideHiddenTags(event, hidden, signer) {
+    if (!canHaveHiddenTags(event.kind))
+        throw new Error("Event kind does not support hidden tags");
+    const encryption = getEventEncryption(event.kind, signer);
+    const ciphertext = await encryption.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,28 @@
+import { describe, beforeEach, it, expect } from "vitest";
+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

@@ -0,0 +1,28 @@
+export * from "./bolt11.js";
+export * from "./cache.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./emoji.js";
+export * from "./event.js";
+export * from "./external-id.js";
+export * from "./file-metadata.js";
+export * from "./filter.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
+export * from "./mailboxes.js";
+export * from "./picture-post.js";
+export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./share.js";
+export * from "./string.js";
+export * from "./tags.js";
+export * from "./threading.js";
+export * from "./time.js";
+export * from "./url.js";
+export * from "./zap.js";

package/dist/helpers/index.js

@@ -0,0 +1,28 @@
+export * from "./bolt11.js";
+export * from "./cache.js";
+export * from "./comment.js";
+export * from "./content.js";
+export * from "./delete.js";
+export * from "./emoji.js";
+export * from "./event.js";
+export * from "./external-id.js";
+export * from "./file-metadata.js";
+export * from "./filter.js";
+export * from "./groups.js";
+export * from "./hashtag.js";
+export * from "./hidden-tags.js";
+export * from "./json.js";
+export * from "./lnurl.js";
+export * from "./lru.js";
+export * from "./mailboxes.js";
+export * from "./picture-post.js";
+export * from "./pointers.js";
+export * from "./profile.js";
+export * from "./relays.js";
+export * from "./share.js";
+export * from "./string.js";
+export * from "./tags.js";
+export * from "./threading.js";
+export * from "./time.js";
+export * from "./url.js";
+export * from "./zap.js";

package/dist/helpers/json.d.ts

@@ -0,0 +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

@@ -0,0 +1,9 @@
+/** Returns the parsed JSON or undefined if invalid */
+export function safeParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}

package/dist/helpers/lnurl.d.ts

@@ -0,0 +1,4 @@
+export declare function parseLightningAddress(address: string): URL | undefined;
+export declare function decodeLNURL(lnurl: string): URL | undefined;
+export declare function parseLNURLOrAddress(addressOrLNURL: string): URL | undefined;
+export declare function getInvoice(callback: URL): Promise<string>;

package/dist/helpers/lnurl.js

@@ -0,0 +1,40 @@
+import { bech32 } from "@scure/base";
+import { parseBolt11 } from "./bolt11.js";
+const decoder = new TextDecoder();
+export function parseLightningAddress(address) {
+    let [name, domain] = address.split("@");
+    if (!name || !domain)
+        return;
+    return new URL(`https://${domain}/.well-known/lnurlp/${name}`);
+}
+export function decodeLNURL(lnurl) {
+    try {
+        const { words, prefix } = bech32.decode(lnurl);
+        if (prefix !== "lnurl")
+            return;
+        const str = decoder.decode(bech32.fromWords(words));
+        return new URL(str);
+    }
+    catch (error) { }
+    return undefined;
+}
+export function parseLNURLOrAddress(addressOrLNURL) {
+    if (addressOrLNURL.includes("@")) {
+        return parseLightningAddress(addressOrLNURL);
+    }
+    return decodeLNURL(addressOrLNURL);
+}
+export async function getInvoice(callback) {
+    const { pr: payRequest } = await fetch(callback).then((res) => res.json());
+    const amount = callback.searchParams.get("amount");
+    if (!amount)
+        throw new Error("Missing amount");
+    if (payRequest) {
+        const parsed = parseBolt11(payRequest);
+        if (parsed.amount !== parseInt(amount))
+            throw new Error("Incorrect amount");
+        return payRequest;
+    }
+    else
+        throw new Error("Failed to get invoice");
+}

package/dist/helpers/lru.d.ts

@@ -0,0 +1,32 @@
+type Item<T> = {
+    key: string;
+    prev: Item<T> | null;
+    value: T;
+    next: Item<T> | null;
+    expiry: number;
+};
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export declare class LRU<T extends unknown> {
+    first: Item<T> | null;
+    items: Record<string, Item<T>>;
+    last: Item<T> | null;
+    max: number;
+    resetTtl: boolean;
+    size: number;
+    ttl: number;
+    constructor(max?: number, ttl?: number, resetTtl?: boolean);
+    clear(): this;
+    delete(key: string): this;
+    entries(keys?: string[]): (string | T | undefined)[][];
+    evict(bypass?: boolean): this;
+    expiresAt(key: string): number | undefined;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    set(key: string, value: T, bypass?: boolean, resetTtl?: boolean): this;
+    values(keys?: string[]): NonNullable<T>[];
+}
+export {};

package/dist/helpers/lru.js

@@ -0,0 +1,148 @@
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export class LRU {
+    first = null;
+    items = Object.create(null);
+    last = null;
+    max;
+    resetTtl;
+    size;
+    ttl;
+    constructor(max = 0, ttl = 0, resetTtl = false) {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.max = max;
+        this.resetTtl = resetTtl;
+        this.size = 0;
+        this.ttl = ttl;
+    }
+    clear() {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.size = 0;
+        return this;
+    }
+    delete(key) {
+        if (this.has(key)) {
+            const item = this.items[key];
+            delete this.items[key];
+            this.size--;
+            if (item.prev !== null) {
+                item.prev.next = item.next;
+            }
+            if (item.next !== null) {
+                item.next.prev = item.prev;
+            }
+            if (this.first === item) {
+                this.first = item.next;
+            }
+            if (this.last === item) {
+                this.last = item.prev;
+            }
+        }
+        return this;
+    }
+    entries(keys = this.keys()) {
+        return keys.map((key) => [key, this.get(key)]);
+    }
+    evict(bypass = false) {
+        if (bypass || this.size > 0) {
+            const item = this.first;
+            delete this.items[item.key];
+            if (--this.size === 0) {
+                this.first = null;
+                this.last = null;
+            }
+            else {
+                this.first = item.next;
+                this.first.prev = null;
+            }
+        }
+        return this;
+    }
+    expiresAt(key) {
+        let result;
+        if (this.has(key)) {
+            result = this.items[key].expiry;
+        }
+        return result;
+    }
+    get(key) {
+        let result;
+        if (this.has(key)) {
+            const item = this.items[key];
+            if (this.ttl > 0 && item.expiry <= Date.now()) {
+                this.delete(key);
+            }
+            else {
+                result = item.value;
+                this.set(key, result, true);
+            }
+        }
+        return result;
+    }
+    has(key) {
+        return key in this.items;
+    }
+    keys() {
+        const result = [];
+        let x = this.first;
+        while (x !== null) {
+            result.push(x.key);
+            x = x.next;
+        }
+        return result;
+    }
+    set(key, value, bypass = false, resetTtl = this.resetTtl) {
+        let item;
+        if (bypass || this.has(key)) {
+            item = this.items[key];
+            item.value = value;
+            if (bypass === false && resetTtl) {
+                item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+            }
+            if (this.last !== item) {
+                const last = this.last, next = item.next, prev = item.prev;
+                if (this.first === item) {
+                    this.first = item.next;
+                }
+                item.next = null;
+                item.prev = this.last;
+                last.next = item;
+                if (prev !== null) {
+                    prev.next = next;
+                }
+                if (next !== null) {
+                    next.prev = prev;
+                }
+            }
+        }
+        else {
+            if (this.max > 0 && this.size === this.max) {
+                this.evict(true);
+            }
+            item = this.items[key] = {
+                expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+                key: key,
+                prev: this.last,
+                next: null,
+                value,
+            };
+            if (++this.size === 1) {
+                this.first = item;
+            }
+            else {
+                this.last.next = item;
+            }
+        }
+        this.last = item;
+        return this;
+    }
+    values(keys = this.keys()) {
+        return keys.map((key) => this.get(key));
+    }
+}

package/dist/helpers/mailboxes.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
+ */
+export declare function getInboxes(event: NostrEvent): string[];
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
+export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -0,0 +1,36 @@
+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) {
+    return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
+        const inboxes = [];
+        for (const tag of event.tags) {
+            if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
+                const url = safeRelayUrl(tag[1]);
+                if (url && !inboxes.includes(url))
+                    inboxes.push(url);
+            }
+        }
+        return inboxes;
+    });
+}
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
+ */
+export function getOutboxes(event) {
+    return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
+        const outboxes = [];
+        for (const tag of event.tags) {
+            if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
+                const url = safeRelayUrl(tag[1]);
+                if (url && !outboxes.includes(url))
+                    outboxes.push(url);
+            }
+        }
+        return outboxes;
+    });
+}

package/dist/helpers/mailboxes.test.d.ts

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

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "vitest";
+import { getInboxes, getOutboxes } from "./mailboxes.js";
+const emptyEvent = {
+    kind: 10002,
+    content: "",
+    tags: [],
+    created_at: 0,
+    sig: "",
+    id: "",
+    pubkey: "",
+};
+describe("Mailboxes", () => {
+    describe("getInboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toHaveLength(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toEqual(expect.arrayContaining(["wss://inbox.com/"]));
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toHaveLength(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toHaveLength(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toEqual(expect.arrayContaining(["wss://outbox.com/"]));
+        });
+    });
+});

package/dist/helpers/picture-post.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+export declare const PICTURE_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export declare function getPicturePostAttachments(post: NostrEvent): import("./file-metadata.js").FileMetadata[];

package/dist/helpers/picture-post.js

@@ -0,0 +1,6 @@
+import { getMediaAttachments } from "./file-metadata.js";
+export const PICTURE_POST_KIND = 20;
+/** Return the media attachments from a kind 20 media post */
+export function getPicturePostAttachments(post) {
+    return getMediaAttachments(post);
+}

package/dist/helpers/pointers.d.ts

@@ -0,0 +1,55 @@
+import { AddressPointer, DecodeResult, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
+    identifier?: string;
+};
+/** Parse the value of an "a" tag into an AddressPointer */
+export declare function parseCoordinate(a: string): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: false): AddressPointerWithoutD | null;
+export declare function parseCoordinate(a: string, requireD: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: false): AddressPointerWithoutD;
+export declare function parseCoordinate(a: string, requireD: true, silent: false): AddressPointer;
+export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
+export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
+/** Extra a pubkey from the result of nip19.decode */
+export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
+/** Encodes the result of nip19.decode */
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+/**
+ * Gets an EventPointer form a common "e" tag
+ * @throws
+ */
+export declare function getEventPointerFromETag(tag: string[]): EventPointer;
+/**
+ * Gets an EventPointer form a "q" tag
+ * @throws
+ */
+export declare function getEventPointerFromQTag(tag: string[]): EventPointer;
+/**
+ * Get an AddressPointer from an "a" tag
+ * @throws
+ */
+export declare function getAddressPointerFromATag(tag: string[]): AddressPointer;
+/**
+ * Gets a ProfilePointer from a "p" tag
+ * @throws
+ */
+export declare function getProfilePointerFromPTag(tag: string[]): ProfilePointer;
+/** Parses "e", "a", "p", and "q" tags into a pointer */
+export declare function getPointerFromTag(tag: string[]): DecodeResult | null;
+export declare function isAddressPointer(pointer: DecodeResult["data"]): pointer is AddressPointer;
+export declare function isEventPointer(pointer: DecodeResult["data"]): pointer is EventPointer;
+/** Returns the coordinate string for an AddressPointer */
+export declare function getCoordinateFromAddressPointer(pointer: AddressPointer): string;
+/**
+ * Returns an AddressPointer for a replaceable event
+ * @throws
+ */
+export declare function getAddressPointerForEvent(event: NostrEvent, relays?: string[]): AddressPointer;
+/**
+ * Returns an EventPointer for an event
+ * @throws
+ */
+export declare function getEventPointerForEvent(event: NostrEvent, relays?: string[]): EventPointer;
+/** Returns a pointer for a given event */
+export declare function getPointerForEvent(event: NostrEvent, relays?: string[]): DecodeResult;