applesauce-core 0.7.0 → 0.9.0

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

@@ -1,6 +1,5 @@
-/// <reference types="debug" />
-/// <reference types="zen-observable" />
 import { Filter, NostrEvent } from "nostr-tools";
+import { Subject } from "rxjs";
 import { LRU } from "../helpers/lru.js";
 /**
  * An in-memory database for nostr events
@@ -14,48 +13,12 @@ export declare class Database {
     protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
-    private insertedSignal;
-    private updatedSignal;
-    private deletedSignal;
     /** A stream of events inserted into the database */
-    inserted: {
-        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
-        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
-        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
-        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
-        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
-        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
-        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
-        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
-        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
-        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
-    };
+    inserted: Subject<import("nostr-tools").Event>;
     /** A stream of events that have been updated */
-    updated: {
-        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
-        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
-        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
-        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
-        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
-        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
-        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
-        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
-        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
-        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
-    };
+    updated: Subject<import("nostr-tools").Event>;
     /** A stream of events removed of the database */
-    deleted: {
-        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
-        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
-        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
-        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
-        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
-        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
-        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
-        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
-        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
-        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
-    };
+    deleted: Subject<import("nostr-tools").Event>;
     get size(): number;
     protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */

package/dist/event-store/database.js

@@ -1,6 +1,6 @@
 import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
-import PushStream from "zen-push";
-import { getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
+import { Subject } from "rxjs";
+import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
 import { LRU } from "../helpers/lru.js";
@@ -16,15 +16,12 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
-    insertedSignal = new PushStream();
-    updatedSignal = new PushStream();
-    deletedSignal = new PushStream();
     /** A stream of events inserted into the database */
-    inserted = this.insertedSignal.observable;
+    inserted = new Subject();
     /** A stream of events that have been updated */
-    updated = this.updatedSignal.observable;
+    updated = new Subject();
     /** A stream of events removed of the database */
-    deleted = this.deletedSignal.observable;
+    deleted = new Subject();
     get size() {
         return this.events.size;
     }
@@ -79,8 +76,14 @@ export class Database {
     addEvent(event) {
         const uid = getEventUID(event);
         const current = this.events.get(uid);
-        if (current && event.created_at <= current.created_at)
+        if (current && event.created_at <= current.created_at) {
+            // if this is a duplicate event, transfer some import symbols
+            if (current.id === event.id) {
+                if (event[FromCacheSymbol])
+                    current[FromCacheSymbol] = event[FromCacheSymbol];
+            }
             return current;
+        }
         this.events.set(uid, event);
         this.getKindIndex(event.kind).add(event);
         this.getAuthorsIndex(event.pubkey).add(event);
@@ -90,13 +93,13 @@ export class Database {
             }
         }
         insertEventIntoDescendingList(this.created_at, event);
-        this.insertedSignal.next(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.updatedSignal.next(inserted);
+        this.updated.next(inserted);
         return inserted;
     }
     /** Deletes an event from the database and notifies all subscriptions */
@@ -119,7 +122,7 @@ export class Database {
         const i = this.created_at.indexOf(event);
         this.created_at.splice(i, 1);
         this.events.delete(uid);
-        this.deletedSignal.next(event);
+        this.deleted.next(event);
         return true;
     }
     /** Sets the claim on the event and touches it */

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

@@ -1,11 +1,8 @@
 import { Filter, NostrEvent } from "nostr-tools";
-import Observable from "zen-observable";
+import { Observable } from "rxjs";
 import { Database } from "./database.js";
 export declare class EventStore {
     database: Database;
-    private singles;
-    private streams;
-    private timelines;
     constructor();
     /** Adds an event to the database */
     add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;

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

@@ -1,14 +1,11 @@
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
-import Observable from "zen-observable";
+import { Observable } from "rxjs";
 import { Database } from "./database.js";
 import { getEventUID, getReplaceableUID } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 export class EventStore {
     database;
-    singles = new Map();
-    streams = new Map();
-    timelines = new Map();
     constructor() {
         this.database = new Database();
     }
@@ -71,12 +68,10 @@ export class EventStore {
                     observer.next(undefined);
                 }
             });
-            this.singles.set(observer, uid);
             return () => {
                 inserted.unsubscribe();
                 deleted.unsubscribe();
                 updated.unsubscribe();
-                this.singles.delete(observer);
                 if (current)
                     this.database.removeClaim(current, observer);
             };
@@ -160,10 +155,8 @@ export class EventStore {
                     claimed.add(event);
                 }
             });
-            this.streams.set(observer, filters);
             return () => {
                 sub.unsubscribe();
-                this.streams.delete(observer);
                 // remove all claims
                 for (const event of claimed)
                     this.database.removeClaim(event, observer);
@@ -228,9 +221,7 @@ export class EventStore {
                     this.database.removeClaim(current, observer);
                 }
             });
-            this.timelines.set(observer, filters);
             return () => {
-                this.timelines.delete(observer);
                 inserted.unsubscribe();
                 deleted.unsubscribe();
                 updated.unsubscribe();

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

@@ -1,10 +1,12 @@
-import { NostrEvent } from "nostr-tools";
+import { NostrEvent, VerifiedEvent } from "nostr-tools";
 export declare const EventUIDSymbol: unique symbol;
 export declare const EventIndexableTagsSymbol: unique symbol;
+export declare const FromCacheSymbol: unique symbol;
 declare module "nostr-tools" {
     interface Event {
         [EventUIDSymbol]?: string;
         [EventIndexableTagsSymbol]?: Set<string>;
+        [FromCacheSymbol]?: boolean;
     }
 }
 /**
@@ -24,3 +26,9 @@ export declare function getReplaceableUID(kind: number, pubkey: string, d?: stri
 export declare function getIndexableTags(event: NostrEvent): Set<string>;
 /** Returns the second index ( tag[1] ) of the first tag that matches the name */
 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;
+/** Marks an event as being from a cache */
+export declare function markFromCache(event: NostrEvent): void;
+/** Returns if an event was from a cache */
+export declare function isFromCache(event: NostrEvent): boolean;

package/dist/helpers/event.js

@@ -1,7 +1,8 @@
-import { kinds } from "nostr-tools";
+import { kinds, verifiedSymbol } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 export const EventUIDSymbol = Symbol.for("event-uid");
 export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
+export const FromCacheSymbol = Symbol.for("from-cache");
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
@@ -49,3 +50,15 @@ export function getIndexableTags(event) {
 export function getTagValue(event, name) {
     return event.tags.find((t) => t[0] === name)?.[1];
 }
+/** Sets events verified flag without checking anything */
+export function fakeVerifyEvent(event) {
+    return (event[verifiedSymbol] = true);
+}
+/** Marks an event as being from a cache */
+export function markFromCache(event) {
+    event[FromCacheSymbol] = true;
+}
+/** Returns if an event was from a cache */
+export function isFromCache(event) {
+    return !!event[FromCacheSymbol];
+}

package/dist/helpers/filter.d.ts

@@ -6,3 +6,7 @@ import { Filter, NostrEvent } from "nostr-tools";
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
 /** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;
+/** Stringify filters in a predictable way */
+export declare function stringifyFilter(filter: Filter | Filter[]): string;
+/** Check if two filters are equal */
+export declare function isFilterEqual(a: Filter | Filter[], b: Filter | Filter[]): boolean;

package/dist/helpers/filter.js

@@ -1,4 +1,5 @@
 import { getIndexableTags } from "./event.js";
+import stringify from "json-stringify-deterministic";
 /**
  * Copied from nostr-tools and modified to use getIndexableTags
  * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
@@ -39,3 +40,11 @@ export function matchFilters(filters, event) {
     }
     return false;
 }
+/** Stringify filters in a predictable way */
+export function stringifyFilter(filter) {
+    return stringify(filter);
+}
+/** Check if two filters are equal */
+export function isFilterEqual(a, b) {
+    return stringifyFilter(a) === stringifyFilter(b);
+}

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,17 +1,11 @@
 import { NostrEvent } from "nostr-tools";
 export declare const MailboxesInboxesSymbol: unique symbol;
 export declare const MailboxesOutboxesSymbol: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [MailboxesInboxesSymbol]?: Set<string>;
-        [MailboxesOutboxesSymbol]?: Set<string>;
-    }
-}
 /**
  * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
-export declare function getInboxes(event: NostrEvent): Set<string>;
+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): Set<string>;
+export declare function getOutboxes(event: NostrEvent): string[];

package/dist/helpers/mailboxes.js

@@ -1,37 +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) {
-    if (!event[MailboxesInboxesSymbol]) {
-        const inboxes = new Set();
+    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.add(url);
+                if (url && !inboxes.includes(url))
+                    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]) {
-        const outboxes = new Set();
+    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.add(url);
+                if (url && !outboxes.includes(url))
+                    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/index.d.ts

@@ -2,3 +2,4 @@ export * from "./event-store/index.js";
 export * from "./query-store/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Queries from "./queries/index.js";
+export * from "./logger.js";

package/dist/index.js

@@ -2,3 +2,4 @@ export * from "./event-store/index.js";
 export * from "./query-store/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Queries from "./queries/index.js";
+export * from "./logger.js";

package/dist/observable/getValue.d.ts

@@ -1,2 +1,2 @@
-import Observable from "zen-observable";
+import { Observable } from "rxjs";
 export declare function getValue<T>(observable: Observable<T>): T | Promise<T>;

package/dist/observable/getValue.js

@@ -1,7 +1,9 @@
-import { isStateful } from "./stateful.js";
+import { BehaviorSubject } from "rxjs";
 export function getValue(observable) {
-    if (isStateful(observable) && observable.value !== undefined)
+    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/observable/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./stateful.js";
-export * from "./throttle.js";
 export * from "./getValue.js";
+export * from "./share-latest-value.js";

package/dist/observable/index.js

@@ -1,3 +1,2 @@
-export * from "./stateful.js";
-export * from "./throttle.js";
 export * from "./getValue.js";
+export * from "./share-latest-value.js";

package/dist/observable/share-latest-value.d.ts

@@ -0,0 +1,8 @@
+import { Observable, ShareConfig } from "rxjs";
+/**
+ * Creates an operator that adds a 'value' property and multiplexes the source
+ * @param config Optional ShareConfig for customizing sharing behavior
+ */
+export declare function shareLatestValue<T>(config?: ShareConfig<T>): (source: Observable<T>) => Observable<T> & {
+    value: T | undefined;
+};

package/dist/observable/share-latest-value.js

@@ -0,0 +1,21 @@
+import { share } from "rxjs";
+import { tap } from "rxjs/operators";
+/**
+ * Creates an operator that adds a 'value' property and multiplexes the source
+ * @param config Optional ShareConfig for customizing sharing behavior
+ */
+export function shareLatestValue(config = {}) {
+    return (source) => {
+        // Create storage for latest value
+        let latestValue = undefined;
+        // Create shared source with value tracking
+        const shared$ = source.pipe(tap((value) => {
+            latestValue = value;
+        }), share(config));
+        // Add value property
+        Object.defineProperty(shared$, "value", {
+            get: () => latestValue,
+        });
+        return shared$;
+    };
+}

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

@@ -1,5 +1,5 @@
 import { Query } from "../query-store/index.js";
 export declare function MailboxesQuery(pubkey: string): Query<{
-    inboxes: Set<string>;
-    outboxes: Set<string>;
+    inboxes: string[];
+    outboxes: string[];
 } | undefined>;

package/dist/queries/mailboxes.js

@@ -1,11 +1,12 @@
 import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 export function MailboxesQuery(pubkey) {
     return {
         key: pubkey,
-        run: (events) => events.replaceable(kinds.RelayList, pubkey).map((event) => event && {
+        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
             inboxes: getInboxes(event),
             outboxes: getOutboxes(event),
-        }),
+        })),
     };
 }

package/dist/queries/profile.js

@@ -1,10 +1,11 @@
 import { kinds } from "nostr-tools";
-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).map((event) => event && getProfileContent(event));
+            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
         },
     };
 }

package/dist/queries/thread.js

@@ -1,4 +1,5 @@
 import { kinds } from "nostr-tools";
+import { map } from "rxjs/operators";
 import { getNip10References } from "../helpers/threading.js";
 import { getCoordinateFromAddressPointer, isAddressPointer } from "../helpers/pointers.js";
 import { getEventUID } from "../helpers/event.js";
@@ -31,7 +32,7 @@ export function ThreadQuery(root, opts) {
     }
     return {
         key: `${rootUID}-${kinds.join(",")}`,
-        run: (events) => events.stream([rootFilter, replyFilter]).map((event) => {
+        run: (events) => events.stream([rootFilter, replyFilter]).pipe(map((event) => {
             if (!items.has(getEventUID(event))) {
                 const refs = getNip10References(event);
                 const replies = parentReferences.get(getEventUID(event)) || new Set();
@@ -60,6 +61,6 @@ export function ThreadQuery(root, opts) {
                 items.set(getEventUID(event), item);
             }
             return { root: items.get(rootUID), all: items };
-        }),
+        })),
     };
 }

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/dist/query-store/index.d.ts

@@ -1,7 +1,6 @@
-import Observable from "zen-observable";
+import { BehaviorSubject, Observable } from "rxjs";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
-import { StatefulObservable } from "../observable/stateful.js";
 import { LRU } from "../helpers/lru.js";
 import * as Queries from "../queries/index.js";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
@@ -14,7 +13,7 @@ export declare class QueryStore {
     static Queries: typeof Queries;
     store: EventStore;
     constructor(store: EventStore);
-    queries: LRU<StatefulObservable<any>>;
+    queries: LRU<Observable<any> | BehaviorSubject<any>>;
     /** Creates a cached query */
     runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
         key: string;
@@ -40,8 +39,8 @@ export declare class QueryStore {
     reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
     /** Returns the parsed relay list (10002) for the pubkey */
     mailboxes(pubkey: string): Observable<{
-        inboxes: Set<string>;
-        outboxes: Set<string>;
+        inboxes: string[];
+        outboxes: string[];
     } | undefined>;
     thread(root: string | EventPointer | AddressPointer): Observable<Queries.Thread>;
 }

package/dist/query-store/index.js

@@ -1,6 +1,6 @@
-import { stateful } from "../observable/stateful.js";
 import { LRU } from "../helpers/lru.js";
 import * as Queries from "../queries/index.js";
+import { shareLatestValue } from "../observable/share-latest-value.js";
 export class QueryStore {
     static Queries = Queries;
     store;
@@ -14,7 +14,7 @@ export class QueryStore {
             const query = queryConstructor(...args);
             const key = `${queryConstructor.name}|${query.key}`;
             if (!this.queries.has(key)) {
-                const observable = stateful(query.run(this.store, this));
+                const observable = query.run(this.store, this).pipe(shareLatestValue());
                 this.queries.set(key, observable);
                 return observable;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -54,19 +54,18 @@
   "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",
-    "zen-push": "^0.3.1",
-    "zen-observable": "^0.10.0"
+    "nostr-tools": "^2.10.1",
+    "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@types/zen-push": "^0.1.4",
     "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.13",
-    "@types/zen-observable": "^0.8.7",
     "jest": "^29.7.0",
-    "jest-extended": "^4.0.2"
+    "jest-extended": "^4.0.2",
+    "typescript": "^5.6.3"
   },
   "jest": {
     "roots": [
@@ -76,6 +75,10 @@
       "jest-extended/all"
     ]
   },
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:nostrudel@geyser.fund"
+  },
   "scripts": {
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",

package/dist/observable/stateful.d.ts

@@ -1,10 +0,0 @@
-import Observable from "zen-observable";
-export type StatefulObservable<T> = Observable<T> & {
-    _stateful?: true;
-    value?: T;
-    error?: Error;
-    complete?: boolean;
-};
-/** Wraps an {@link Observable} and makes it stateful */
-export declare function stateful<T extends unknown>(observable: Observable<T>, cleanup?: boolean): StatefulObservable<T>;
-export declare function isStateful<T extends unknown>(observable: Observable<T> | StatefulObservable<T>): observable is StatefulObservable<T>;

package/dist/observable/stateful.js

@@ -1,60 +0,0 @@
-import Observable from "zen-observable";
-/** Wraps an {@link Observable} and makes it stateful */
-export function stateful(observable, cleanup = false) {
-    let subscription = undefined;
-    let observers = [];
-    const self = new Observable((observer) => {
-        // add observer to list
-        observers.push(observer);
-        // pass any cached values
-        if (self.value)
-            observer.next(self.value);
-        if (self.error)
-            observer.error(self.error);
-        if (self.complete)
-            observer.complete();
-        // subscribe if not already
-        if (!subscription) {
-            subscription = observable.subscribe({
-                next: (v) => {
-                    self.value = v;
-                    for (const observer of observers)
-                        observer.next(v);
-                },
-                error: (err) => {
-                    self.error = err;
-                    for (const observer of observers)
-                        observer.error(err);
-                },
-                complete: () => {
-                    self.complete = true;
-                    for (const observer of observers)
-                        observer.complete();
-                },
-            });
-        }
-        return () => {
-            let i = observers.indexOf(observer);
-            if (i !== -1) {
-                // remove observer from list
-                observers.splice(i, 1);
-                if (subscription && observers.length === 0) {
-                    subscription.unsubscribe();
-                    subscription = undefined;
-                    // reset cached values
-                    if (cleanup) {
-                        delete self.value;
-                        delete self.error;
-                        delete self.complete;
-                    }
-                }
-            }
-        };
-    });
-    self._stateful = true;
-    return self;
-}
-export function isStateful(observable) {
-    // @ts-expect-error
-    return observable._stateful;
-}

package/dist/observable/throttle.d.ts

@@ -1,3 +0,0 @@
-import Observable from "zen-observable";
-/** Throttles an {@link Observable} */
-export declare function throttle<T>(source: Observable<T>, interval: number): Observable<T>;

package/dist/observable/throttle.js

@@ -1,23 +0,0 @@
-import Observable from "zen-observable";
-/** Throttles an {@link Observable} */
-export function throttle(source, interval) {
-    return new Observable((observer) => {
-        let lastEmissionTime = 0;
-        let subscription = source.subscribe({
-            next(value) {
-                const currentTime = Date.now();
-                if (currentTime - lastEmissionTime >= interval) {
-                    lastEmissionTime = currentTime;
-                    observer.next(value);
-                }
-            },
-            error(err) {
-                observer.error(err);
-            },
-            complete() {
-                observer.complete();
-            },
-        });
-        return () => subscription.unsubscribe();
-    });
-}