applesauce-common 0.0.0-next-20251209200210 → 0.0.0-next-20251220152312

package/dist/casts/profile.js

@@ -0,0 +1,40 @@
+import { getDisplayName, getProfileContent, getProfilePicture, isValidProfile } from "applesauce-core/helpers/profile";
+import { EventCast } from "./cast.js";
+/** Cast a kind 0 event to a Profile */
+export class Profile extends EventCast {
+    constructor(event, store) {
+        if (!isValidProfile(event))
+            throw new Error("Invalid profile");
+        super(event, store);
+    }
+    get metadata() {
+        return getProfileContent(this.event);
+    }
+    get name() {
+        return this.metadata.name;
+    }
+    get displayName() {
+        return getDisplayName(this.metadata);
+    }
+    get about() {
+        return this.metadata.about;
+    }
+    get picture() {
+        return getProfilePicture(this.metadata);
+    }
+    get dnsIdentity() {
+        return this.metadata.nip05;
+    }
+    get website() {
+        return this.metadata.website;
+    }
+    get lud16() {
+        return this.metadata.lud16;
+    }
+    get lud06() {
+        return this.metadata.lud06;
+    }
+    get lightningAddress() {
+        return this.metadata.lud16 || this.metadata.lud06;
+    }
+}

package/dist/casts/relay-lists.d.ts

@@ -0,0 +1,33 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { BlockedRelaysListEvent, FAVORITE_RELAYS_KIND, FavoriteRelaysListEvent, SearchRelaysListEvent } from "../helpers/relay-list.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Base class for relay lists */
+declare class RelayListBase<T extends KnownEvent<typeof FAVORITE_RELAYS_KIND | typeof kinds.SearchRelaysList | kinds.BlockedRelaysList>> extends EventCast<T> {
+    constructor(event: T, store: CastRefEventStore);
+    /** The public relays in the relay list */
+    get relays(): string[];
+    /** The hidden relays in the relay list */
+    get hidden(): string[];
+    /** An observable that updates when the hidden relays are unlocked */
+    get hidden$(): import("../observable/chainable.js").ChainableObservable<string[]>;
+    /** Whether the relay list has hidden relays */
+    get hasHidden(): boolean;
+    /** Whether the relay list is unlocked */
+    get unlocked(): boolean;
+    /** Unlocks the hidden relays on the relay list */
+    unlock(signer: HiddenContentSigner): Promise<string[]>;
+}
+/** Class for favorite relays lists (kind 10012) */
+export declare class FavoriteRelays extends RelayListBase<FavoriteRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+/** Class for search relays lists (kind 10007) */
+export declare class SearchRelays extends RelayListBase<SearchRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+/** Class for blocked relays lists (kind 10006) */
+export declare class BlockedRelays extends RelayListBase<BlockedRelaysListEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+}
+export {};

package/dist/casts/relay-lists.js

@@ -0,0 +1,72 @@
+import { defined, watchEventUpdates } from "applesauce-core";
+import { hasHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "applesauce-core/helpers";
+import { kinds } from "applesauce-core/helpers/event";
+import { map, of } from "rxjs";
+import { getRelaysFromList } from "../helpers/lists.js";
+import { FAVORITE_RELAYS_KIND, isValidBlockedRelaysList, isValidFavoriteRelaysList, isValidSearchRelaysList, } from "../helpers/relay-list.js";
+import { EventCast } from "./cast.js";
+/** Base class for relay lists */
+class RelayListBase extends EventCast {
+    constructor(event, store) {
+        if (event.kind !== FAVORITE_RELAYS_KIND &&
+            event.kind !== kinds.SearchRelaysList &&
+            event.kind !== kinds.BlockedRelaysList)
+            throw new Error(`Invalid relay list (kind ${event.kind})`);
+        super(event, store);
+    }
+    /** The public relays in the relay list */
+    get relays() {
+        return getRelaysFromList(this.event);
+    }
+    /** The hidden relays in the relay list */
+    get hidden() {
+        return getRelaysFromList(this.event, "hidden");
+    }
+    /** An observable that updates when the hidden relays are unlocked */
+    get hidden$() {
+        return this.$$ref("hidden$", (store) => of(this.event).pipe(
+        // Watch for event updates
+        watchEventUpdates(store), 
+        // Get the hidden relays
+        map((event) => event && getRelaysFromList(event, "hidden")), 
+        // Only emit when the hidden relays are unlocked
+        defined()));
+    }
+    /** Whether the relay list has hidden relays */
+    get hasHidden() {
+        return hasHiddenTags(this.event);
+    }
+    /** Whether the relay list is unlocked */
+    get unlocked() {
+        return isHiddenTagsUnlocked(this.event);
+    }
+    /** Unlocks the hidden relays on the relay list */
+    async unlock(signer) {
+        await unlockHiddenTags(this.event, signer);
+        return this.hidden;
+    }
+}
+/** Class for favorite relays lists (kind 10012) */
+export class FavoriteRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidFavoriteRelaysList(event))
+            throw new Error("Invalid favorite relays list");
+        super(event, store);
+    }
+}
+/** Class for search relays lists (kind 10007) */
+export class SearchRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidSearchRelaysList(event))
+            throw new Error("Invalid search relays list");
+        super(event, store);
+    }
+}
+/** Class for blocked relays lists (kind 10006) */
+export class BlockedRelays extends RelayListBase {
+    constructor(event, store) {
+        if (!isValidBlockedRelaysList(event))
+            throw new Error("Invalid blocked relays list");
+        super(event, store);
+    }
+}

package/dist/casts/share.d.ts

@@ -0,0 +1,13 @@
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { ShareEvent } from "../helpers/share.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Cast class for kind 6 and 16 share events */
+export declare class Share extends EventCast<ShareEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get sharedKind(): number | undefined;
+    get embedded(): import("nostr-tools").Event | undefined;
+    get sharedAddressPointer(): import("nostr-tools/nip19").AddressPointer | undefined;
+    get sharedEventPointer(): import("nostr-tools/nip19").EventPointer;
+    get sharedPointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer;
+    get shared$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}

package/dist/casts/share.js

@@ -0,0 +1,28 @@
+import { getEmbededSharedEvent, getSharedAddressPointer, getSharedEventPointer, isValidShare, } from "../helpers/share.js";
+import { EventCast } from "./cast.js";
+/** Cast class for kind 6 and 16 share events */
+export class Share extends EventCast {
+    constructor(event, store) {
+        if (!isValidShare(event))
+            throw new Error("Invalid share");
+        super(event, store);
+    }
+    get sharedKind() {
+        return getSharedEventPointer(this.event)?.kind;
+    }
+    get embedded() {
+        return getEmbededSharedEvent(this.event);
+    }
+    get sharedAddressPointer() {
+        return getSharedAddressPointer(this.event);
+    }
+    get sharedEventPointer() {
+        return getSharedEventPointer(this.event);
+    }
+    get sharedPointer() {
+        return this.sharedAddressPointer || this.sharedEventPointer;
+    }
+    get shared$() {
+        return this.$$ref("shared$", (store) => store.event(this.sharedPointer));
+    }
+}

package/dist/casts/stream.d.ts

@@ -0,0 +1,43 @@
+import { kinds, KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
+import { EventPointer } from "applesauce-core/helpers/pointers";
+import { StreamChatMessageEvent } from "../helpers/stream-chat.js";
+import { StreamStatus } from "../helpers/stream.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+import { Share } from "./share.js";
+import { Zap } from "./zap.js";
+/** Cast a kind 30311 event to a Stream (NIP-53) */
+export declare class Stream extends EventCast<KnownEvent<kinds.LiveEvent>> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get title(): string | undefined;
+    get summary(): string | undefined;
+    get image(): string | undefined;
+    get status(): StreamStatus;
+    get host(): import("./user.js").User;
+    get participants(): import("./user.js").User[];
+    get goalPointer(): EventPointer | undefined;
+    get streamingURLs(): string[];
+    get streamingVideos(): string[];
+    get streamingAudio(): string[];
+    get recording(): string | undefined;
+    get relays(): string[] | undefined;
+    get startTime(): number | undefined;
+    get endTime(): number | undefined;
+    get viewers(): number | undefined;
+    get maxViewers(): number | undefined;
+    get hashtags(): string[];
+    /** An observable of all zaps on this stream */
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get shares$(): import("../observable/chainable.js").ChainableObservable<Share[]>;
+    /** An observable of all chat messages for this stream */
+    get chat$(): import("../observable/chainable.js").ChainableObservable<StreamChatMessage[]>;
+    /** An observable of the goal event if this stream has a goal */
+    get goal$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}
+/** A cast for a stream chat message */
+export declare class StreamChatMessage extends EventCast<StreamChatMessageEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get stream(): import("nostr-tools/nip19").AddressPointer;
+    get stream$(): import("../observable/chainable.js").ChainableObservable<Stream | undefined>;
+    get zaps$(): import("../observable/chainable.js").ChainableObservable<Zap[]>;
+    get reactions$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event[]>;
+}

package/dist/casts/stream.js

@@ -0,0 +1,116 @@
+import { isAudioURL, isStreamURL, isVideoURL } from "applesauce-core/helpers";
+import { kinds } from "applesauce-core/helpers/event";
+import { of } from "rxjs";
+import { getStreamChatMessageStream, isValidStreamChatMessage, } from "../helpers/stream-chat.js";
+import { getStreamEndTime, getStreamGoalPointer, getStreamHashtags, getStreamHost, getStreamImage, getStreamMaxViewers, getStreamParticipants, getStreamRecording, getStreamRelays, getStreamStartTime, getStreamStatus, getStreamStreamingURLs, getStreamSummary, getStreamTitle, getStreamViewers, } from "../helpers/stream.js";
+import { ReactionsModel } from "../models/reactions.js";
+import { SharesModel } from "../models/shares.js";
+import { StreamChatMessagesModel } from "../models/stream.js";
+import { EventZapsModel } from "../models/zaps.js";
+import { castEventStream, castTimelineStream } from "../observable/cast-stream.js";
+import { EventCast } from "./cast.js";
+import { Share } from "./share.js";
+import { Zap } from "./zap.js";
+import { castUser } from "./user.js";
+function isValidStream(event) {
+    return event.kind === kinds.LiveEvent;
+}
+/** Cast a kind 30311 event to a Stream (NIP-53) */
+export class Stream extends EventCast {
+    constructor(event, store) {
+        if (!isValidStream(event))
+            throw new Error("Invalid stream");
+        super(event, store);
+    }
+    get title() {
+        return getStreamTitle(this.event);
+    }
+    get summary() {
+        return getStreamSummary(this.event);
+    }
+    get image() {
+        return getStreamImage(this.event);
+    }
+    get status() {
+        return getStreamStatus(this.event);
+    }
+    get host() {
+        return castUser(getStreamHost(this.event), this.store);
+    }
+    get participants() {
+        return getStreamParticipants(this.event).map((p) => castUser(p, this.store));
+    }
+    get goalPointer() {
+        return getStreamGoalPointer(this.event);
+    }
+    get streamingURLs() {
+        return getStreamStreamingURLs(this.event);
+    }
+    get streamingVideos() {
+        return this.streamingURLs.filter((url) => isVideoURL(url) || isStreamURL(url));
+    }
+    get streamingAudio() {
+        return this.streamingURLs.filter((url) => isAudioURL(url) || isStreamURL(url));
+    }
+    get recording() {
+        return getStreamRecording(this.event);
+    }
+    get relays() {
+        return getStreamRelays(this.event);
+    }
+    get startTime() {
+        return getStreamStartTime(this.event);
+    }
+    get endTime() {
+        return getStreamEndTime(this.event);
+    }
+    get viewers() {
+        return getStreamViewers(this.event);
+    }
+    get maxViewers() {
+        return getStreamMaxViewers(this.event);
+    }
+    get hashtags() {
+        return getStreamHashtags(this.event);
+    }
+    /** An observable of all zaps on this stream */
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get shares$() {
+        return this.$$ref("shares$", (store) => store.model(SharesModel, this.event).pipe(castTimelineStream(Share, store)));
+    }
+    /** An observable of all chat messages for this stream */
+    get chat$() {
+        return this.$$ref("chat$", (store) => store.model(StreamChatMessagesModel, this.event).pipe(castTimelineStream(StreamChatMessage, store)));
+    }
+    /** An observable of the goal event if this stream has a goal */
+    get goal$() {
+        return this.$$ref("goal$", (store) => {
+            const goalPointer = this.goalPointer;
+            if (!goalPointer)
+                return of(undefined);
+            return store.event(goalPointer.id);
+        });
+    }
+}
+/** A cast for a stream chat message */
+export class StreamChatMessage extends EventCast {
+    constructor(event, store) {
+        if (!isValidStreamChatMessage(event))
+            throw new Error("Invalid stream chat message");
+        super(event, store);
+    }
+    get stream() {
+        return getStreamChatMessageStream(this.event);
+    }
+    get stream$() {
+        return this.$$ref("stream$", (store) => store.replaceable(this.stream).pipe(castEventStream(Stream, store)));
+    }
+    get zaps$() {
+        return this.$$ref("zaps$", (store) => store.model(EventZapsModel, this.event).pipe(castTimelineStream(Zap, store)));
+    }
+    get reactions$() {
+        return this.$$ref("reactions$", (store) => store.model(ReactionsModel, this.event));
+    }
+}

package/dist/casts/user.d.ts

@@ -0,0 +1,38 @@
+import { NostrEvent, ProfilePointer } from "applesauce-core/helpers";
+import { Observable } from "rxjs";
+import { ChainableObservable } from "../observable/chainable.js";
+import { type CastRefEventStore } from "./cast.js";
+/** Cast a nostr event or pointer into a {@link User} */
+export declare function castUser(event: NostrEvent, store: CastRefEventStore): User;
+export declare function castUser(user: string | ProfilePointer, store: CastRefEventStore): User;
+/** A class for a user */
+export declare class User {
+    #private;
+    pubkey: string;
+    /** A global cache of pubkey -> {@link User} */
+    static cache: Map<string, User>;
+    constructor(user: string | ProfilePointer, store: CastRefEventStore);
+    /** Internal method for creating a reference */
+    protected $$ref<Return extends unknown>(key: string, builder: (store: CastRefEventStore) => Observable<Return>): ChainableObservable<Return>;
+    get npub(): `npub1${string}`;
+    get pointer(): ProfilePointer;
+    get nprofile(): `nprofile1${string}`;
+    replaceable(kind: number, identifier?: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    addressable(kind: number, identifier: string, relays?: string[]): ChainableObservable<NostrEvent | undefined>;
+    get profile$(): ChainableObservable<import("./profile.js").Profile | undefined>;
+    get contacts$(): ChainableObservable<User[]>;
+    get mutes$(): ChainableObservable<import("./mutes.js").Mutes | undefined>;
+    get mailboxes$(): ChainableObservable<{
+        inboxes: string[];
+        outboxes: string[];
+    } | undefined>;
+    get outboxes$(): ChainableObservable<string[] | undefined>;
+    get inboxes$(): ChainableObservable<string[] | undefined>;
+    get bookmarks$(): ChainableObservable<import("./bookmarks.js").BookmarksList | undefined>;
+    get favoriteRelays$(): ChainableObservable<import("./relay-lists.js").FavoriteRelays | undefined>;
+    get searchRelays$(): ChainableObservable<import("./relay-lists.js").SearchRelays | undefined>;
+    get blockedRelays$(): ChainableObservable<import("./relay-lists.js").BlockedRelays | undefined>;
+    get directMessageRelays$(): ChainableObservable<string[] | undefined>;
+    /** Get the latest live stream for the user */
+    get live$(): ChainableObservable<import("./stream.js").Stream | undefined>;
+}

package/dist/casts/user.js

@@ -0,0 +1,169 @@
+import { isEvent, isHexKey, kinds, nprofileEncode, npubEncode, } from "applesauce-core/helpers";
+import { combineLatest, defer, from, map, switchMap, tap } from "rxjs";
+import { FAVORITE_RELAYS_KIND } from "../helpers/relay-list.js";
+import { castEventStream } from "../observable/cast-stream.js";
+import { chainable } from "../observable/chainable.js";
+import { getRelaysFromList } from "../helpers/lists.js";
+export function castUser(user, store) {
+    if (isEvent(user)) {
+        return castUser(user.pubkey, store);
+    }
+    else {
+        const pubkey = typeof user === "string" ? user : user.pubkey;
+        // Skip creating a new instance if this pubkey has already been cast
+        const existing = User.cache.get(pubkey);
+        if (existing)
+            return existing;
+        // Create a new instance and cache it
+        const newUser = new User(pubkey, store);
+        User.cache.set(pubkey, newUser);
+        return newUser;
+    }
+}
+// IMPORTANT: this class MUST use async import() to import the other classes so that we do not get circular dependency errors
+/** A class for a user */
+export class User {
+    pubkey;
+    #store;
+    /** A cache of the users outboxes for creating a profile pointer relay hints */
+    #outboxes;
+    /** A global cache of pubkey -> {@link User} */
+    static cache = new Map();
+    constructor(user, store) {
+        if (typeof user === "string" && !isHexKey(user))
+            throw new Error("Invalid pubkey for user");
+        const pubkey = typeof user === "string" ? user : user.pubkey;
+        this.#store = store;
+        this.pubkey = pubkey;
+    }
+    /** A cache of observable references */
+    #refs = {};
+    /** Internal method for creating a reference */
+    $$ref(key, builder) {
+        // Return cached observable
+        if (this.#refs[key])
+            return this.#refs[key];
+        // Build a new observable and cache it
+        const observable = chainable(builder(this.#store));
+        this.#refs[key] = observable;
+        return observable;
+    }
+    // Public getters
+    get npub() {
+        return npubEncode(this.pubkey);
+    }
+    get pointer() {
+        return {
+            pubkey: this.pubkey,
+            relays: this.#outboxes?.slice(0, 3) ?? [],
+        };
+    }
+    get nprofile() {
+        return nprofileEncode(this.pointer);
+    }
+    // Request methods
+    replaceable(kind, identifier, relays) {
+        return chainable(this.#store.replaceable({ kind, pubkey: this.pubkey, identifier, relays }));
+    }
+    addressable(kind, identifier, relays) {
+        return chainable(this.#store.addressable({ kind, pubkey: this.pubkey, identifier, relays }));
+    }
+    // Observable interfaces
+    get profile$() {
+        return this.$$ref("profile$", (store) => defer(() => from(import("./profile.js").then((m) => m.Profile))).pipe(switchMap((Profile) => store.replaceable({ kind: kinds.Metadata, pubkey: this.pubkey }).pipe(castEventStream(Profile, store)))));
+    }
+    get contacts$() {
+        return this.$$ref("contacts$", (store) => this.outboxes$.pipe(
+        // Fetch the contacts from the outboxes
+        switchMap((outboxes) => store.contacts({ pubkey: this.pubkey, relays: outboxes })), 
+        // Cast to users
+        map((arr) => arr.map((p) => castUser(p, this.#store)))));
+    }
+    get mutes$() {
+        return this.$$ref("mutes$", (store) => combineLatest([
+            // Import the Mutes class
+            defer(() => import("./mutes.js").then((m) => m.Mutes)),
+            // Always start without the outboxes
+            this.outboxes$,
+        ]).pipe(
+        // Create the mute list event with the outboxes
+        switchMap(([Mutes, outboxes]) => store
+            .event({ kind: kinds.Mutelist, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(Mutes, store)))));
+    }
+    get mailboxes$() {
+        return this.$$ref("mailboxes$", (store) => store.mailboxes({ pubkey: this.pubkey }).pipe(
+        // Cache the outboxes for creating a profile pointer relay hints
+        tap((mailboxes) => (this.#outboxes = mailboxes?.outboxes))));
+    }
+    get outboxes$() {
+        return this.mailboxes$.outboxes;
+    }
+    get inboxes$() {
+        return this.mailboxes$.inboxes;
+    }
+    get bookmarks$() {
+        return this.$$ref("bookmarks$", (store) => combineLatest([
+            // Import the BookmarksList class
+            defer(() => from(import("./bookmarks.js").then((m) => m.BookmarksList))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(switchMap(([BookmarksList, outboxes]) => 
+        // Fetch the bookmarks list event from the outboxes
+        store
+            .replaceable({ kind: kinds.BookmarkList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(BookmarksList, store)))));
+    }
+    get favoriteRelays$() {
+        return this.$$ref("favoriteRelays$", (store) => combineLatest([
+            // Import the FavoriteRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.FavoriteRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the favorite relays list event from the outboxes
+        switchMap(([FavoriteRelaysList, outboxes]) => store
+            .replaceable({ kind: FAVORITE_RELAYS_KIND, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(FavoriteRelaysList, store)))));
+    }
+    get searchRelays$() {
+        return this.$$ref("searchRelays$", (store) => combineLatest([
+            // Import the SearchRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.SearchRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the search relays list event from the outboxes
+        switchMap(([SearchRelaysList, outboxes]) => store
+            .replaceable({ kind: kinds.SearchRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(SearchRelaysList, store)))));
+    }
+    get blockedRelays$() {
+        return this.$$ref("blockedRelays$", (store) => combineLatest([
+            // Import the BlockedRelays class
+            defer(() => from(import("./relay-lists.js").then((m) => m.BlockedRelays))),
+            // Get outboxes and start without them
+            this.outboxes$,
+        ]).pipe(
+        // Fetch the blocked relays list event from the outboxes
+        switchMap(([BlockedRelaysList, outboxes]) => store
+            .replaceable({ kind: kinds.BlockedRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(BlockedRelaysList, store)))));
+    }
+    get directMessageRelays$() {
+        return this.$$ref("dmRelays$", (store) => this.outboxes$.pipe(
+        // Fetch the DM relays list event from the outboxes
+        switchMap((outboxes) => store
+            .replaceable({ kind: kinds.DirectMessageRelaysList, pubkey: this.pubkey, relays: outboxes })
+            .pipe(map((event) => event && getRelaysFromList(event))))));
+    }
+    /** Get the latest live stream for the user */
+    get live$() {
+        return this.$$ref("live$", (store) => defer(() => import("./stream.js").then((m) => m.Stream)).pipe(switchMap((Stream) => store
+            .timeline([
+            { kinds: [kinds.LiveEvent], "#p": [this.pubkey] },
+            { kinds: [kinds.LiveEvent], authors: [this.pubkey] },
+        ])
+            .pipe(map((events) => events[0]), castEventStream(Stream, store)))));
+    }
+}

package/dist/casts/zap.d.ts

@@ -0,0 +1,17 @@
+import { NostrEvent } from "applesauce-core/helpers";
+import { ZapEvent } from "../helpers/zap.js";
+import { CastRefEventStore, EventCast } from "./cast.js";
+/** Cast a kind 9735 event to a Zap */
+export declare class Zap extends EventCast<ZapEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get sender(): import("./user.js").User;
+    get recipient(): import("./user.js").User;
+    get payment(): import("../helpers/bolt11.js").ParsedInvoice;
+    get amount(): number;
+    get preimage(): string | undefined;
+    get request(): import("nostr-tools").Event;
+    get addressPointer(): import("nostr-tools/nip19").AddressPointer | null;
+    get eventPointer(): import("nostr-tools/nip19").EventPointer | null;
+    /** An observable of the zapped event */
+    get event$(): import("../observable/chainable.js").ChainableObservable<import("nostr-tools").Event | undefined>;
+}

package/dist/casts/zap.js

@@ -0,0 +1,47 @@
+import { of } from "rxjs";
+import { getZapAddressPointer, getZapAmount, getZapEventPointer, getZapPayment, getZapPreimage, getZapRecipient, getZapRequest, getZapSender, isValidZap, } from "../helpers/zap.js";
+import { EventCast } from "./cast.js";
+import { castUser } from "./user.js";
+// NOTE: extending BaseCast since there is no need for author$ or comments$
+/** Cast a kind 9735 event to a Zap */
+export class Zap extends EventCast {
+    constructor(event, store) {
+        if (!isValidZap(event))
+            throw new Error("Invalid zap");
+        super(event, store);
+    }
+    get sender() {
+        return castUser(getZapSender(this.event), this.store);
+    }
+    get recipient() {
+        return castUser(getZapRecipient(this.event), this.store);
+    }
+    get payment() {
+        return getZapPayment(this.event);
+    }
+    get amount() {
+        return getZapAmount(this.event);
+    }
+    get preimage() {
+        return getZapPreimage(this.event);
+    }
+    get request() {
+        return getZapRequest(this.event);
+    }
+    get addressPointer() {
+        return getZapAddressPointer(this.event);
+    }
+    get eventPointer() {
+        return getZapEventPointer(this.event);
+    }
+    /** An observable of the zapped event */
+    get event$() {
+        return this.$$ref("event$", (store) => {
+            if (this.addressPointer)
+                return store.replaceable(this.addressPointer);
+            if (this.eventPointer)
+                return store.event(this.eventPointer.id);
+            return of(undefined);
+        });
+    }
+}