applesauce-core 0.8.0 → 0.9.0

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

@@ -1,4 +1,3 @@
-/// <reference types="debug" />
 import { Filter, NostrEvent } from "nostr-tools";
 import { Subject } from "rxjs";
 import { LRU } from "../helpers/lru.js";

package/dist/helpers/bolt11.d.ts

@@ -0,0 +1,8 @@
+export type ParsedInvoice = {
+    paymentRequest: string;
+    description: string;
+    amount?: number;
+    timestamp: number;
+    expiry: number;
+};
+export declare function parseBolt11(paymentRequest: string): ParsedInvoice;

package/dist/helpers/bolt11.js

@@ -0,0 +1,14 @@
+import { decode } from "light-bolt11-decoder";
+export function parseBolt11(paymentRequest) {
+    const decoded = decode(paymentRequest);
+    const timestamp = decoded.sections.find((s) => s.name === "timestamp")?.value ?? 0;
+    const description = decoded.sections.find((s) => s.name === "description")?.value ?? "";
+    const amount = parseInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+    return {
+        paymentRequest: decoded.paymentRequest,
+        description: description,
+        amount: amount,
+        timestamp: timestamp,
+        expiry: timestamp + decoded.expiry,
+    };
+}

package/dist/helpers/cache.js

@@ -1,17 +1,17 @@
 export function getCachedValue(event, symbol) {
-    // @ts-expect-error
-    return event[symbol];
+    return Reflect.get(event, symbol);
 }
 export function setCachedValue(event, symbol, value) {
-    // @ts-expect-error
-    event[symbol] = value;
+    Reflect.set(event, symbol, value);
 }
 /** Internal method used to cache computed values on events */
 export function getOrComputeCachedValue(event, symbol, compute) {
-    let cached = getCachedValue(event, symbol);
-    if (!cached) {
-        // @ts-expect-error
-        cached = event[symbol] = compute(event);
+    if (Reflect.has(event, symbol)) {
+        return Reflect.get(event, symbol);
+    }
+    else {
+        const value = compute(event);
+        Reflect.set(event, symbol, value);
+        return value;
     }
-    return cached;
 }

package/dist/helpers/index.d.ts

@@ -12,3 +12,5 @@ export * from "./emoji.js";
 export * from "./lru.js";
 export * from "./hashtag.js";
 export * from "./url.js";
+export * from "./zap.js";
+export * from "./bolt11.js";

package/dist/helpers/index.js

@@ -12,3 +12,5 @@ export * from "./emoji.js";
 export * from "./lru.js";
 export * from "./hashtag.js";
 export * from "./url.js";
+export * from "./zap.js";
+export * from "./bolt11.js";

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

@@ -10,7 +10,7 @@ export declare function parseCoordinate(a: string, requireD: true, silent: false
 export declare function parseCoordinate(a: string, requireD: true, silent: true): AddressPointer | null;
 export declare function parseCoordinate(a: string, requireD: false, silent: true): AddressPointerWithoutD | null;
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
-export declare function encodeDecodeResult(result: DecodeResult): "" | `nsec1${string}` | `npub1${string}` | `note1${string}` | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nrelay1${string}`;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
 export declare function getEventPointerFromTag(tag: string[]): EventPointer;
 export declare function getAddressPointerFromTag(tag: string[]): AddressPointer;
 export declare function getProfilePointerFromTag(tag: string[]): ProfilePointer;

package/dist/helpers/pointers.js

@@ -1,4 +1,4 @@
-import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nrelayEncode, nsecEncode, } from "nostr-tools/nip19";
+import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey } from "nostr-tools";
 import { safeRelayUrls } from "./relays.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
@@ -53,8 +53,6 @@ export function encodeDecodeResult(result) {
             return nprofileEncode(result.data);
         case "nevent":
             return neventEncode(result.data);
-        case "nrelay":
-            return nrelayEncode(result.data);
         case "nsec":
             return nsecEncode(result.data);
         case "npub":

package/dist/helpers/profile.d.ts

@@ -1,10 +1,5 @@
 import { NostrEvent } from "nostr-tools";
 export declare const ProfileContentSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [ProfileContentSymbol]?: ProfileContent | Error;
-    }
-}
 export type ProfileContent = {
     name?: string;
     display_name?: string;
@@ -21,5 +16,5 @@ export type ProfileContent = {
 };
 /** Returns the parsed profile content for a kind 0 event */
 export declare function getProfileContent(event: NostrEvent): ProfileContent;
-export declare function getProfileContent(event: NostrEvent, quite: false): ProfileContent;
-export declare function getProfileContent(event: NostrEvent, quite: true): ProfileContent | Error;
+/** 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,28 +1,31 @@
+import { kinds } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
-export function getProfileContent(event, quite = false) {
-    let cached = event[ProfileContentSymbol];
-    if (!cached) {
-        try {
-            const profile = JSON.parse(event.content);
-            // ensure nip05 is a string
-            if (profile.nip05 && typeof profile.nip05 !== "string")
-                profile.nip05 = String(profile.nip05);
-            cached = event[ProfileContentSymbol] = profile;
+/** Returns the parsed profile content for a kind 0 event */
+export function getProfileContent(event) {
+    return getOrComputeCachedValue(event, ProfileContentSymbol, () => {
+        const profile = JSON.parse(event.content);
+        // ensure nip05 is a string
+        if (profile.nip05 && typeof profile.nip05 !== "string")
+            profile.nip05 = String(profile.nip05);
+        // add missing protocol to website
+        if (profile.website?.startsWith("http") === false) {
+            profile.website = "https://" + profile.website;
         }
-        catch (e) {
-            if (e instanceof Error)
-                cached = event[ProfileContentSymbol] = e;
-        }
-    }
-    if (cached === undefined) {
-        throw new Error("Failed to parse profile");
+        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;
     }
-    else if (cached instanceof Error) {
-        if (!quite)
-            throw cached;
-        else
-            return cached;
+    catch (error) {
+        return false;
     }
-    else
-        return cached;
 }

package/dist/helpers/threading.d.ts

@@ -1,4 +1,4 @@
-import { NostrEvent } from "nostr-tools";
+import { EventTemplate, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 export type ThreadReferences = {
     root?: {
@@ -29,7 +29,7 @@ declare module "nostr-tools" {
     }
 }
 /** Parses NIP-10 tags and handles legacy behavior */
-export declare function interpretThreadTags(event: NostrEvent): {
+export declare function interpretThreadTags(event: NostrEvent | EventTemplate): {
     root?: {
         e: string[];
         a: undefined;
@@ -39,7 +39,7 @@ export declare function interpretThreadTags(event: NostrEvent): {
     } | {
         e: string[];
         a: string[];
-    } | undefined;
+    };
     reply?: {
         e: string[];
         a: undefined;
@@ -49,7 +49,7 @@ export declare function interpretThreadTags(event: NostrEvent): {
     } | {
         e: string[];
         a: string[];
-    } | undefined;
+    };
 };
 /** Returns the parsed NIP-10 tags for an event */
-export declare function getNip10References(event: NostrEvent): ThreadReferences;
+export declare function getNip10References(event: NostrEvent | EventTemplate): ThreadReferences;

package/dist/helpers/threading.js

@@ -1,4 +1,5 @@
 import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { getOrComputeCachedValue } from "./cache.js";
 export const Nip10ThreadRefsSymbol = Symbol.for("nip10-thread-refs");
 /** Parses NIP-10 tags and handles legacy behavior */
 export function interpretThreadTags(event) {
@@ -42,20 +43,31 @@ export function interpretThreadTags(event) {
 }
 /** Returns the parsed NIP-10 tags for an event */
 export function getNip10References(event) {
-    let refs = event[Nip10ThreadRefsSymbol];
-    if (!refs) {
-        const e = event;
-        const tags = interpretThreadTags(e);
-        refs = event[Nip10ThreadRefsSymbol] = {
-            root: tags.root && {
-                e: tags.root.e && getEventPointerFromTag(tags.root.e),
-                a: tags.root.a && getAddressPointerFromTag(tags.root.a),
-            },
-            reply: tags.reply && {
-                e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
-                a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
-            },
+    return getOrComputeCachedValue(event, Nip10ThreadRefsSymbol, () => {
+        const tags = interpretThreadTags(event);
+        let root;
+        if (tags.root) {
+            try {
+                root = {
+                    e: tags.root.e && getEventPointerFromTag(tags.root.e),
+                    a: tags.root.a && getAddressPointerFromTag(tags.root.a),
+                };
+            }
+            catch (error) { }
+        }
+        let reply;
+        if (tags.reply) {
+            try {
+                reply = {
+                    e: tags.reply.e && getEventPointerFromTag(tags.reply.e),
+                    a: tags.reply.a && getAddressPointerFromTag(tags.reply.a),
+                };
+            }
+            catch (error) { }
+        }
+        return {
+            root,
+            reply,
         };
-    }
-    return refs;
+    });
 }

package/dist/helpers/zap.d.ts

@@ -0,0 +1,14 @@
+import { NostrEvent } from "nostr-tools";
+export declare const ZapRequestSymbol: unique symbol;
+export declare const ZapFromSymbol: unique symbol;
+export declare const ZapInvoiceSymbol: unique symbol;
+export declare const ZapEventPointerSymbol: unique symbol;
+export declare const ZapAddressPointerSymbol: unique symbol;
+export declare function getZapSender(zap: NostrEvent): string;
+export declare function getZapRecipient(zap: NostrEvent): string;
+export declare function getZapPayment(zap: NostrEvent): import("./bolt11.js").ParsedInvoice | undefined;
+export declare function getZapAddressPointer(zap: NostrEvent): import("nostr-tools/nip19").AddressPointer | null;
+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

@@ -0,0 +1,66 @@
+import { kinds, nip57 } from "nostr-tools";
+import { getOrComputeCachedValue } from "./cache.js";
+import { getTagValue } from "./event.js";
+import { isATag, isETag } from "./tags.js";
+import { getAddressPointerFromTag, getEventPointerFromTag } from "./pointers.js";
+import { parseBolt11 } from "./bolt11.js";
+export const ZapRequestSymbol = Symbol.for("zap-request");
+export const ZapFromSymbol = Symbol.for("zap-from");
+export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
+export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
+export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
+export function getZapSender(zap) {
+    return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+}
+export function getZapRecipient(zap) {
+    const recipient = getTagValue(zap, "p");
+    if (!recipient)
+        throw new Error("Missing recipient");
+    return recipient;
+}
+export function getZapPayment(zap) {
+    return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
+        const bolt11 = getTagValue(zap, "bolt11");
+        return bolt11 ? parseBolt11(bolt11) : undefined;
+    });
+}
+export function getZapAddressPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
+        const a = zap.tags.find(isATag);
+        return a ? getAddressPointerFromTag(a) : null;
+    });
+}
+export function getZapEventPointer(zap) {
+    return getOrComputeCachedValue(zap, ZapEventPointerSymbol, () => {
+        const e = zap.tags.find(isETag);
+        return e ? getEventPointerFromTag(e) : null;
+    });
+}
+export function getZapPreimage(zap) {
+    return getTagValue(zap, "preimage");
+}
+export function getZapRequest(zap) {
+    return getOrComputeCachedValue(zap, ZapRequestSymbol, () => {
+        const description = getTagValue(zap, "description");
+        if (!description)
+            throw new Error("Missing description tag");
+        const error = nip57.validateZapRequest(description);
+        if (error)
+            throw new Error(error);
+        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/observable/getValue.js

@@ -2,6 +2,8 @@ import { BehaviorSubject } from "rxjs";
 export function getValue(observable) {
     if (observable instanceof BehaviorSubject)
         return observable.value;
+    if (Reflect.has(observable, "value"))
+        return Reflect.get(observable, "value");
     return new Promise((res) => {
         const sub = observable.subscribe((v) => {
             res(v);

package/dist/queries/index.d.ts

@@ -3,3 +3,4 @@ export * from "./profile.js";
 export * from "./mailboxes.js";
 export * from "./reactions.js";
 export * from "./thread.js";
+export * from "./zaps.js";

package/dist/queries/index.js

@@ -3,3 +3,4 @@ export * from "./profile.js";
 export * from "./mailboxes.js";
 export * from "./reactions.js";
 export * from "./thread.js";
+export * from "./zaps.js";

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.d.ts

@@ -0,0 +1,4 @@
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../query-store/index.js";
+export declare function EventZapsQuery(id: string | EventPointer | AddressPointer): Query<NostrEvent[]>;

package/dist/queries/zaps.js

@@ -0,0 +1,20 @@
+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)] }])
+                    .pipe(map((events) => events.filter(isValidZap)));
+            }
+            else {
+                id = typeof id === "string" ? id : id.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.8.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -54,8 +54,9 @@
   "dependencies": {
     "debug": "^4.3.7",
     "json-stringify-deterministic": "^1.0.12",
+    "light-bolt11-decoder": "^3.2.0",
     "nanoid": "^5.0.7",
-    "nostr-tools": "^2.7.2",
+    "nostr-tools": "^2.10.1",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
@@ -63,7 +64,8 @@
     "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.13",
     "jest": "^29.7.0",
-    "jest-extended": "^4.0.2"
+    "jest-extended": "^4.0.2",
+    "typescript": "^5.6.3"
   },
   "jest": {
     "roots": [
@@ -73,6 +75,10 @@
       "jest-extended/all"
     ]
   },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
   "scripts": {
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",