applesauce-core 3.1.0 → 4.1.0

package/dist/helpers/mailboxes.d.ts

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

package/dist/helpers/mailboxes.js

@@ -1,41 +1,47 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { isSafeRelayURL } from "./relays.js";
+import { isRTag } from "./tags.js";
 import { normalizeURL } from "./url.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
- */
+/** Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol */
 export function getInboxes(event) {
     return getOrComputeCachedValue(event, MailboxesInboxesSymbol, () => {
         const inboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !inboxes.includes(url) &&
-                (mode === "read" || mode === undefined)) {
-                inboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [, url, mode] = tag;
+                if (url && isSafeRelayURL(url) && !inboxes.includes(url) && (mode === "read" || mode === undefined)) {
+                    inboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return inboxes;
     });
 }
-/**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
- */
+/** Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol */
 export function getOutboxes(event) {
     return getOrComputeCachedValue(event, MailboxesOutboxesSymbol, () => {
         const outboxes = [];
         for (const tag of event.tags) {
-            const [name, url, mode] = tag;
-            if (name === "r" &&
-                url &&
-                isSafeRelayURL(url) &&
-                !outboxes.includes(url) &&
-                (mode === "write" || mode === undefined)) {
-                outboxes.push(normalizeURL(url));
+            if (!isRTag(tag))
+                continue;
+            try {
+                const [name, url, mode] = tag;
+                if (name === "r" &&
+                    isSafeRelayURL(url) &&
+                    !outboxes.includes(url) &&
+                    (mode === "write" || mode === undefined)) {
+                    outboxes.push(normalizeURL(url));
+                }
+            }
+            catch {
+                // Ignore invalid url tags
             }
         }
         return outboxes;

package/dist/helpers/mutes.d.ts

@@ -1,6 +1,11 @@
 import { NostrEvent } from "nostr-tools";
+import { HiddenContentSigner } from "./index.js";
 export declare const MutePublicSymbol: unique symbol;
 export declare const MuteHiddenSymbol: unique symbol;
+/** Type for unlocked mute events */
+export type UnlockedMutes = {
+    [MuteHiddenSymbol]: Mutes;
+};
 export type Mutes = {
     pubkeys: Set<string>;
     threads: Set<string>;
@@ -15,8 +20,13 @@ export declare function parseMutedTags(tags: string[][]): Mutes;
 export declare function getMutedThings(mute: NostrEvent): Mutes;
 /** Returns only the public muted things from a mute event */
 export declare function getPublicMutedThings(mute: NostrEvent): Mutes;
+/** Checks if the hidden mutes are unlocked */
+export declare function isHiddenMutesUnlocked<T extends NostrEvent>(mute: T): mute is T & UnlockedMutes;
 /** Returns the hidden muted content if the event is unlocked */
-export declare function getHiddenMutedThings(mute: NostrEvent): Mutes | undefined;
+export declare function getHiddenMutedThings<T extends NostrEvent & UnlockedMutes>(mute: T): Mutes;
+export declare function getHiddenMutedThings<T extends NostrEvent>(mute: T): Mutes | undefined;
+/** Unlocks the hidden mutes */
+export declare function unlockHiddenMutes(mute: NostrEvent, signer: HiddenContentSigner): Promise<Mutes>;
 /** Creates a RegExp for matching muted words */
 export declare function createMutedWordsRegExp(mutedWords: string[]): RegExp;
 /** Returns true if the event matches the mutes */

package/dist/helpers/mutes.js

@@ -1,7 +1,7 @@
 import { kinds } from "nostr-tools";
 import { getOrComputeCachedValue } from "./cache.js";
-import { getHiddenTags, isHiddenTagsLocked } from "./hidden-tags.js";
-import { getIndexableTags, getNip10References } from "./index.js";
+import { getHiddenTags, isHiddenTagsUnlocked, unlockHiddenTags } from "./hidden-tags.js";
+import { getIndexableTags, getNip10References, notifyEventUpdate } from "./index.js";
 import { isETag, isPTag, isTTag } from "./tags.js";
 export const MutePublicSymbol = Symbol.for("mute-public");
 export const MuteHiddenSymbol = Symbol.for("mute-hidden");
@@ -40,11 +40,36 @@ export function getMutedThings(mute) {
 export function getPublicMutedThings(mute) {
     return getOrComputeCachedValue(mute, MutePublicSymbol, () => parseMutedTags(mute.tags));
 }
-/** Returns the hidden muted content if the event is unlocked */
+/** Checks if the hidden mutes are unlocked */
+export function isHiddenMutesUnlocked(mute) {
+    return isHiddenTagsUnlocked(mute) && Reflect.has(mute, MuteHiddenSymbol);
+}
 export function getHiddenMutedThings(mute) {
-    if (isHiddenTagsLocked(mute))
+    if (isHiddenMutesUnlocked(mute))
+        return mute[MuteHiddenSymbol];
+    // get hidden tags
+    const tags = getHiddenTags(mute);
+    if (!tags)
         return undefined;
-    return getOrComputeCachedValue(mute, MuteHiddenSymbol, () => parseMutedTags(getHiddenTags(mute)));
+    // parse muted tags
+    const mutes = parseMutedTags(tags);
+    // set cached value
+    Reflect.set(mute, MuteHiddenSymbol, mutes);
+    return mutes;
+}
+/** Unlocks the hidden mutes */
+export async function unlockHiddenMutes(mute, signer) {
+    if (isHiddenMutesUnlocked(mute))
+        return mute[MuteHiddenSymbol];
+    // Unlock hidden tags
+    await unlockHiddenTags(mute, signer);
+    // get hidden mutes
+    const mutes = getHiddenMutedThings(mute);
+    if (!mutes)
+        throw new Error("Failed to unlock hidden mutes");
+    // Notify event store
+    notifyEventUpdate(mute);
+    return mutes;
 }
 /** Creates a RegExp for matching muted words */
 export function createMutedWordsRegExp(mutedWords) {

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

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

package/dist/helpers/pointers.d.ts

@@ -1,5 +1,7 @@
 import { AddressPointer, EventPointer, ProfilePointer, decode } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+export type { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, decode as decodePointer, } from "nostr-tools/nip19";
 export type DecodeResult = ReturnType<typeof decode>;
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;
@@ -15,7 +17,7 @@ export declare function parseCoordinate(a: string, requireD: false, silent: true
 /** Extra a pubkey from the result of nip19.decode */
 export declare function getPubkeyFromDecodeResult(result?: DecodeResult): string | undefined;
 /** Encodes the result of nip19.decode */
-export declare function encodeDecodeResult(result: DecodeResult): "" | `nprofile1${string}` | `nevent1${string}` | `naddr1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
+export declare function encodeDecodeResult(result: DecodeResult): "" | `nevent1${string}` | `naddr1${string}` | `nprofile1${string}` | `nsec1${string}` | `npub1${string}` | `note1${string}`;
 /**
  * Gets an EventPointer form a common "e" tag
  * @throws

package/dist/helpers/pointers.js

@@ -1,10 +1,13 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds, nip19 } from "nostr-tools";
+// export nip-19 helpers
+export { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, decode as decodePointer, } from "nostr-tools/nip19";
 import { getReplaceableIdentifier } from "./event.js";
 import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL, mergeRelaySets } from "./relays.js";
 import { isHexKey } from "./string.js";
 import { hexToBytes } from "@noble/hashes/utils";
+import { normalizeURL } from "./url.js";
 export function parseCoordinate(a, requireD = false, silent = true) {
     const parts = a.split(":");
     const kind = parts[0] ? parseInt(parts[0]) : undefined;
@@ -117,7 +120,7 @@ export function getProfilePointerFromPTag(tag) {
         throw new Error("Invalid pubkey");
     const pointer = { pubkey: tag[1] };
     if (tag[2] && isSafeRelayURL(tag[2]))
-        pointer.relays = [tag[2]];
+        pointer.relays = [normalizeURL(tag[2])];
     return pointer;
 }
 /** Checks if a pointer is an AddressPointer */

package/dist/helpers/profile.d.ts

@@ -1,4 +1,5 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
+import { KnownEvent } from "./index.js";
 export declare const ProfileContentSymbol: unique symbol;
 export type ProfileContent = {
     name?: string;
@@ -17,10 +18,13 @@ export type ProfileContent = {
     lud06?: string;
     nip05?: string;
 };
+/** Type for validated profile events */
+export type ProfileEvent = KnownEvent<kinds.Metadata>;
 /** Returns the parsed profile content for a kind 0 event */
-export declare function getProfileContent(event: NostrEvent): ProfileContent;
+export declare function getProfileContent(event: ProfileEvent): ProfileContent;
+export declare function getProfileContent(event: NostrEvent): ProfileContent | undefined;
 /** Checks if the content of the kind 0 event is valid JSON */
-export declare function isValidProfile(profile?: NostrEvent): boolean;
+export declare function isValidProfile(profile?: NostrEvent): profile is ProfileEvent;
 /** Gets the profile picture from a nostr event or profile content with fallback */
 export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined): string | undefined;
 export declare function getProfilePicture(metadata: ProfileContent | NostrEvent | undefined, fallback: string): string;

package/dist/helpers/profile.js

@@ -1,11 +1,13 @@
 import { kinds } from "nostr-tools";
 import { npubEncode } from "nostr-tools/nip19";
 import { getOrComputeCachedValue } from "./cache.js";
+import { safeParse } from "./index.js";
 export const ProfileContentSymbol = Symbol.for("profile-content");
-/** Returns the parsed profile content for a kind 0 event */
 export function getProfileContent(event) {
     return getOrComputeCachedValue(event, ProfileContentSymbol, () => {
-        const profile = JSON.parse(event.content);
+        const profile = safeParse(event.content);
+        if (!profile)
+            return undefined;
         // ensure nip05 is a string
         if (profile.nip05 && typeof profile.nip05 !== "string")
             profile.nip05 = String(profile.nip05);
@@ -22,13 +24,10 @@ export function isValidProfile(profile) {
         return false;
     if (profile.kind !== kinds.Metadata && profile.kind !== kinds.Handlerinformation)
         return false;
-    try {
-        getProfileContent(profile);
-        return true;
-    }
-    catch (error) {
+    // Check if the profile content is valid
+    if (!getProfileContent(profile))
         return false;
-    }
+    return true;
 }
 export function getProfilePicture(metadata, fallback) {
     if (!metadata)

package/dist/helpers/relay-selection.d.ts

@@ -0,0 +1,17 @@
+import { ProfilePointer } from "nostr-tools/nip19";
+export type SelectOptimalRelaysOptions = {
+    /** Maximum number of connections (relays) to select */
+    maxConnections: number;
+    /** Cap the number of relays a user can have */
+    maxRelaysPerUser?: number;
+};
+/** Selects the optimal relays for a list of ProfilePointers */
+export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
+/** Sets relays for any user that has 0 relays */
+export declare function setFallbackRelays(users: ProfilePointer[], fallbacks: string[]): ProfilePointer[];
+/** Removes blacklisted relays from the user's relays */
+export declare function removeBlacklistedRelays(users: ProfilePointer[], blacklist: string[]): ProfilePointer[];
+/** A map of pubkeys by relay */
+export type OutboxMap = Record<string, ProfilePointer[]>;
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export declare function groupPubkeysByRelay(pointers: ProfilePointer[]): OutboxMap;

package/dist/helpers/relay-selection.js

@@ -0,0 +1,102 @@
+/** Selects the optimal relays for a list of ProfilePointers */
+export function selectOptimalRelays(users, { maxConnections, maxRelaysPerUser }) {
+    const usersWithRelays = users.filter((user) => user.relays && user.relays.length > 0);
+    // create map of popular relays
+    const popular = new Map();
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        for (const relay of user.relays)
+            popular.set(relay, (popular.get(relay) || 0) + 1);
+    }
+    // sort users relays by popularity
+    for (const user of usersWithRelays) {
+        if (!user.relays)
+            continue;
+        user.relays = Array.from(user.relays).sort((a, b) => popular.get(b) - popular.get(a));
+    }
+    // Create a pool of users to calculate relay coverage from
+    let selectionPool = Array.from(usersWithRelays);
+    // Create map of times a users relay has been selected
+    const selectionCount = new Map();
+    let selection = new Set();
+    while (selectionPool.length > 0 && selection.size < maxConnections) {
+        // Create map of number of pool users per relay
+        const relayUserCount = new Map();
+        for (const user of selectionPool) {
+            if (!user.relays)
+                continue;
+            for (const relay of user.relays) {
+                // Skip relays that are already selected
+                if (selection.has(relay))
+                    continue;
+                // Increment relay user count
+                relayUserCount.set(relay, (relayUserCount.get(relay) || 0) + 1);
+            }
+        }
+        // Sort relays by coverage
+        const byCoverage = Array.from(relayUserCount.entries()).sort((a, b) => b[1] - a[1]);
+        // No more relays to select, exit loop
+        if (byCoverage.length === 0)
+            break;
+        // Pick the most popular relay
+        const relay = byCoverage[0][0];
+        // Add relay to selection
+        selection.add(relay);
+        // Increment user relay count and remove users over the limit
+        selectionPool = selectionPool.filter((user) => {
+            // Ignore users that don't have the relay
+            if (!user.relays || !user.relays.includes(relay))
+                return true;
+            // Increment user relay count
+            let count = selectionCount.get(relay) || 0;
+            selectionCount.set(relay, count++);
+            // Remove user if they their relay has been selected more than minRelaysPerUser times
+            if (count >= 1)
+                return false;
+            return true;
+        });
+    }
+    // Take the original users and only include relays that where selected
+    return users.map((user) => ({
+        ...user,
+        relays: maxRelaysPerUser
+            ? user.relays
+                ?.filter((relay) => selection.has(relay))
+                .sort((a, b) => (popular.get(a) ?? 0) - (popular.get(b) ?? 0))
+                .slice(0, maxRelaysPerUser)
+            : user.relays?.filter((relay) => selection.has(relay)),
+    }));
+}
+/** Sets relays for any user that has 0 relays */
+export function setFallbackRelays(users, fallbacks) {
+    return users.map((user) => {
+        if (!user.relays || user.relays.length === 0)
+            return { ...user, relays: fallbacks };
+        else
+            return user;
+    });
+}
+/** Removes blacklisted relays from the user's relays */
+export function removeBlacklistedRelays(users, blacklist) {
+    return users.map((user) => {
+        if (!user.relays || user.relays.length === 0)
+            return user;
+        else
+            return { ...user, relays: user.relays.filter((relay) => !blacklist.includes(relay)) };
+    });
+}
+/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+export function groupPubkeysByRelay(pointers) {
+    const outbox = {};
+    for (const pointer of pointers) {
+        if (!pointer.relays)
+            continue;
+        for (const relay of pointer.relays) {
+            if (!outbox[relay])
+                outbox[relay] = [];
+            outbox[relay].push(pointer);
+        }
+    }
+    return outbox;
+}

package/dist/helpers/relays.d.ts

@@ -12,4 +12,6 @@ export declare function getSeenRelays(event: NostrEvent): Set<string> | undefine
 /** A fast check to make sure relay hints are safe to connect to */
 export declare function isSafeRelayURL(relay: string): boolean;
 /** Merge multiple sets of relays and remove duplicates (ignores invalid URLs) */
-export declare function mergeRelaySets(...sources: (Iterable<string> | undefined)[]): string[];
+export declare function mergeRelaySets(...sources: (Iterable<string> | string | undefined)[]): string[];
+/** Alias for {@link mergeRelaySets} */
+export declare const relaySet: typeof mergeRelaySets;

package/dist/helpers/relays.js

@@ -23,9 +23,10 @@ export function mergeRelaySets(...sources) {
     for (const src of sources) {
         if (!src)
             continue;
-        for (const url of src) {
+        if (typeof src === "string") {
+            // Source is a string
             try {
-                const safe = normalizeURL(url).toString();
+                const safe = normalizeURL(src).toString();
                 if (safe)
                     set.add(safe);
             }
@@ -33,6 +34,21 @@ export function mergeRelaySets(...sources) {
                 // failed to parse URL, ignore
             }
         }
+        else {
+            // Source is iterable
+            for (const url of src) {
+                try {
+                    const safe = normalizeURL(url).toString();
+                    if (safe)
+                        set.add(safe);
+                }
+                catch (error) {
+                    // failed to parse URL, ignore
+                }
+            }
+        }
     }
     return Array.from(set);
 }
+/** Alias for {@link mergeRelaySets} */
+export const relaySet = mergeRelaySets;

package/dist/helpers/url.js

@@ -78,13 +78,13 @@ export function ensureHttpURL(url) {
  */
 export function normalizeURL(url) {
     let p = new URL(url);
-    // remove any double slashes
+    // Remove any double slashes
     p.pathname = p.pathname.replace(/\/+/g, "/");
-    // drop the port if its not needed
+    // Remove the port if its not needed
     if ((p.port === "80" && (p.protocol === "ws:" || p.protocol === "http:")) ||
         (p.port === "443" && (p.protocol === "wss:" || p.protocol === "https:")))
         p.port = "";
-    // return a string if a string was passed in
+    // Return a string if a string was passed in
     // @ts-expect-error
     return typeof url === "string" ? p.toString() : p;
 }

package/dist/helpers/wrapped-messages.d.ts

@@ -1,12 +1,14 @@
 import { Rumor } from "./gift-wraps.js";
-/** Returns the subject of a warpped direct message */
+/** Returns the subject of a wrapped direct message */
 export declare function getWrappedMessageSubject(message: Rumor): string | undefined;
 /** Returns the parent id of a wrapped direct message */
 export declare function getWrappedMessageParent(message: Rumor): string | undefined;
 /** Returns the sender of a wrapped direct message */
-export declare function getWrappedMesssageSender(message: Rumor): string;
+export declare function getWrappedMessageSender(message: Rumor): string;
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export declare const getWrappedMesssageSender: typeof getWrappedMessageSender;
 /**
- * Returns the frist participant in a conversation that is not the sender
+ * Returns the first participant in a conversation that is not the sender
  * @see getConversationParticipants
  */
 export declare function getWrappedMessageReceiver(message: Rumor): string;

package/dist/helpers/wrapped-messages.js

@@ -1,5 +1,5 @@
 import { getConversationParticipants, getTagValue } from "./index.js";
-/** Returns the subject of a warpped direct message */
+/** Returns the subject of a wrapped direct message */
 export function getWrappedMessageSubject(message) {
     return getTagValue(message, "subject");
 }
@@ -8,11 +8,13 @@ export function getWrappedMessageParent(message) {
     return getTagValue(message, "e");
 }
 /** Returns the sender of a wrapped direct message */
-export function getWrappedMesssageSender(message) {
+export function getWrappedMessageSender(message) {
     return message.pubkey;
 }
+/** @deprecated use {@link getWrappedMessageSender} instead */
+export const getWrappedMesssageSender = getWrappedMessageSender;
 /**
- * Returns the frist participant in a conversation that is not the sender
+ * Returns the first participant in a conversation that is not the sender
  * @see getConversationParticipants
  */
 export function getWrappedMessageReceiver(message) {

package/dist/helpers/zap.d.ts

@@ -1,6 +1,9 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { ParsedInvoice } from "./bolt11.js";
+import { KnownEvent } from "./index.js";
+/** Type for validated zap event */
+export type ZapEvent = KnownEvent<kinds.Zap>;
 export declare const ZapRequestSymbol: unique symbol;
 export declare const ZapSenderSymbol: unique symbol;
 export declare const ZapReceiverSymbol: unique symbol;
@@ -8,30 +11,31 @@ export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
 /** Returns the senders pubkey */
-export declare function getZapSender(zap: NostrEvent): string;
-/**
- * Gets the receivers pubkey
- * @throws
- */
-export declare function getZapRecipient(zap: NostrEvent): string;
+export declare function getZapSender(zap: ZapEvent): string;
+export declare function getZapSender(zap: NostrEvent): string | undefined;
+/** Gets the receivers pubkey */
+export declare function getZapRecipient(zap: ZapEvent): string;
+export declare function getZapRecipient(zap: NostrEvent): string | undefined;
 /** Returns the parsed bolt11 invoice */
+export declare function getZapPayment(zap: ZapEvent): ParsedInvoice;
 export declare function getZapPayment(zap: NostrEvent): ParsedInvoice | undefined;
+/** Returns the zap event amount in msats */
+export declare function getZapAmount(zap: ZapEvent): number;
+export declare function getZapAmount(zap: NostrEvent): number | undefined;
 /** Gets the AddressPointer that was zapped */
 export declare function getZapAddressPointer(zap: NostrEvent): AddressPointer | null;
 /** Gets the EventPointer that was zapped */
 export declare function getZapEventPointer(zap: NostrEvent): EventPointer | null;
 /** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
+/** Returns the zap request event inside the zap receipt */
+export declare function getZapRequest(zap: ZapEvent): NostrEvent;
+export declare function getZapRequest(zap: NostrEvent): NostrEvent | undefined;
 /**
- * Returns the zap request event inside the zap receipt
- * @throws
- */
-export declare function getZapRequest(zap: NostrEvent): NostrEvent;
-/**
- * Checks if the zap is valid
+ * Checks if a zap event is valid (not missing fields)
  * DOES NOT validate LNURL address
  */
-export declare function isValidZap(zap?: NostrEvent): boolean;
+export declare function isValidZap(zap?: NostrEvent): zap is ZapEvent;
 export type ZapSplit = {
     pubkey: string;
     percent: number;

package/dist/helpers/zap.js

@@ -10,31 +10,25 @@ export const ZapReceiverSymbol = Symbol.for("zap-receiver");
 export const ZapInvoiceSymbol = Symbol.for("zap-bolt11");
 export const ZapEventPointerSymbol = Symbol.for("zap-event-pointer");
 export const ZapAddressPointerSymbol = Symbol.for("zap-address-pointer");
-/** Returns the senders pubkey */
 export function getZapSender(zap) {
     return getOrComputeCachedValue(zap, ZapSenderSymbol, () => {
-        return getTagValue(zap, "P") || getZapRequest(zap).pubkey;
+        return getTagValue(zap, "P") || getZapRequest(zap)?.pubkey;
     });
 }
-/**
- * Gets the receivers pubkey
- * @throws
- */
 export function getZapRecipient(zap) {
     return getOrComputeCachedValue(zap, ZapReceiverSymbol, () => {
-        const recipient = getTagValue(zap, "p");
-        if (!recipient)
-            throw new Error("Missing recipient");
-        return recipient;
+        return getTagValue(zap, "p");
     });
 }
-/** Returns the parsed bolt11 invoice */
 export function getZapPayment(zap) {
     return getOrComputeCachedValue(zap, ZapInvoiceSymbol, () => {
         const bolt11 = getTagValue(zap, "bolt11");
         return bolt11 ? parseBolt11(bolt11) : undefined;
     });
 }
+export function getZapAmount(zap) {
+    return getZapPayment(zap)?.amount;
+}
 /** Gets the AddressPointer that was zapped */
 export function getZapAddressPointer(zap) {
     return getOrComputeCachedValue(zap, ZapAddressPointerSymbol, () => {
@@ -53,23 +47,25 @@ export function getZapEventPointer(zap) {
 export function getZapPreimage(zap) {
     return getTagValue(zap, "preimage");
 }
-/**
- * Returns the zap request event inside the zap receipt
- * @throws
- */
 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);
+            return;
+        // Attempt to parse the zap request
+        try {
+            const error = nip57.validateZapRequest(description);
+            if (error)
+                return;
+            return JSON.parse(description);
+        }
+        catch (error) {
+            return undefined;
+        }
     });
 }
 /**
- * Checks if the zap is valid
+ * Checks if a zap event is valid (not missing fields)
  * DOES NOT validate LNURL address
  */
 export function isValidZap(zap) {
@@ -77,14 +73,16 @@ export function isValidZap(zap) {
         return false;
     if (zap.kind !== kinds.Zap)
         return false;
-    try {
-        getZapRequest(zap);
-        getZapRecipient(zap);
-        return true;
-    }
-    catch (error) {
+    // Is not a valid zap kind if any of these is undefined
+    if (getZapPayment(zap) === undefined)
         return false;
-    }
+    if (getZapRequest(zap) === undefined)
+        return false;
+    if (getZapRecipient(zap) === undefined)
+        return false;
+    if (getZapSender(zap) === undefined)
+        return false;
+    return true;
 }
 /** Returns the zap splits for an event */
 export function getZapSplits(event) {