applesauce-wallet-connect 0.0.0-next-20250808173123

package/dist/helpers/tokens.js

@@ -0,0 +1,162 @@
+import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
+import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+export const WALLET_TOKEN_KIND = 7375;
+// Enable hidden content for wallet token kind
+setHiddenContentEncryptionMethod(WALLET_TOKEN_KIND, "nip44");
+/** Internal method for creating a unique id for each proof */
+export function getProofUID(proof) {
+    return proof.id + proof.amount + proof.C + proof.secret;
+}
+/** Internal method to filter out duplicate proofs */
+export function ignoreDuplicateProofs(seen = new Set()) {
+    return (proof) => {
+        const id = getProofUID(proof);
+        if (seen.has(id))
+            return false;
+        else {
+            seen.add(id);
+            return true;
+        }
+    };
+}
+export const TokenContentSymbol = Symbol.for("token-content");
+/**
+ * Returns the decrypted and parsed details of a 7375 token event
+ * @throws
+ */
+export function getTokenContent(token) {
+    if (isHiddenTagsLocked(token))
+        return undefined;
+    return getOrComputeCachedValue(token, TokenContentSymbol, () => {
+        const plaintext = getHiddenContent(token);
+        if (!plaintext)
+            throw new Error("Token is locked");
+        const details = JSON.parse(plaintext);
+        if (!details.mint)
+            throw new Error("Token missing mint");
+        if (!details.proofs)
+            throw new Error("Token missing proofs");
+        if (!details.del)
+            details.del = [];
+        return details;
+    });
+}
+/** Returns if token details are locked */
+export function isTokenContentLocked(token) {
+    return isHiddenContentLocked(token);
+}
+/** Decrypts a k:7375 token event */
+export async function unlockTokenContent(token, signer) {
+    if (isHiddenContentLocked(token))
+        await unlockHiddenContent(token, signer);
+    return getTokenContent(token);
+}
+/** Removes the unencrypted hidden content */
+export function lockTokenContent(token) {
+    Reflect.deleteProperty(token, TokenContentSymbol);
+    lockHiddenContent(token);
+}
+/**
+ * Gets the totaled amount of proofs in a token event
+ * @param token The token event to calculate the total
+ */
+export function getTokenProofsTotal(token) {
+    if (isTokenContentLocked(token))
+        return undefined;
+    const content = getTokenContent(token);
+    return content.proofs.reduce((t, p) => t + p.amount, 0);
+}
+/**
+ * Selects oldest tokens and proofs that total up to more than the min amount
+ * @throws
+ */
+export function dumbTokenSelection(tokens, minAmount, mint) {
+    // sort newest to oldest
+    const sorted = tokens
+        .filter((token) => !isTokenContentLocked(token) && (mint ? getTokenContent(token).mint === mint : true))
+        .sort((a, b) => b.created_at - a.created_at);
+    let amount = 0;
+    const seen = new Set();
+    const selectedTokens = [];
+    const selectedProofs = [];
+    while (amount < minAmount) {
+        const token = sorted.pop();
+        if (!token)
+            throw new Error("Insufficient funds");
+        const proofs = getTokenContent(token).proofs.filter(ignoreDuplicateProofs(seen));
+        const total = proofs.reduce((t, p) => t + p.amount, 0);
+        selectedTokens.push(token);
+        selectedProofs.push(...proofs);
+        amount += total;
+    }
+    return { events: selectedTokens, proofs: selectedProofs };
+}
+/**
+ * Returns a decoded cashu token inside an unicode emoji
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
+ */
+export function decodeTokenFromEmojiString(str) {
+    try {
+        let decoded = [];
+        const chars = Array.from(str);
+        if (!chars.length)
+            return undefined;
+        const fromVariationSelector = function (char) {
+            const codePoint = char.codePointAt(0);
+            if (codePoint === undefined)
+                return null;
+            // Handle Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) {
+                // Maps FE00->0, FE01->1, ..., FE0F->15
+                const byteValue = codePoint - 0xfe00;
+                return String.fromCharCode(byteValue);
+            }
+            // Handle Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (codePoint >= 0xe0100 && codePoint <= 0xe01ef) {
+                // Maps E0100->16, E0101->17, ..., E01EF->255
+                const byteValue = codePoint - 0xe0100 + 16;
+                return String.fromCharCode(byteValue);
+            }
+            // No Variation Selector
+            return null;
+        };
+        // Check all input chars for peanut data
+        for (const char of chars) {
+            let byte = fromVariationSelector(char);
+            if (byte === null && decoded.length > 0) {
+                break;
+            }
+            else if (byte === null) {
+                continue;
+            }
+            decoded.push(byte); // got some
+        }
+        // Switch out token if we found peanut data
+        let decodedString = decoded.join("");
+        return getDecodedToken(decodedString);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+/**
+ * Encodes a token into an emoji char
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
+ */
+export function encodeTokenToEmoji(token, emoji = "🥜") {
+    return (emoji +
+        Array.from(typeof token === "string" ? token : getEncodedToken(token))
+            .map((char) => {
+            const byteValue = char.charCodeAt(0);
+            // For byte values 0-15, use Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (byteValue >= 0 && byteValue <= 15) {
+                return String.fromCodePoint(0xfe00 + byteValue);
+            }
+            // For byte values 16-255, use Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (byteValue >= 16 && byteValue <= 255) {
+                return String.fromCodePoint(0xe0100 + (byteValue - 16));
+            }
+            return "";
+        })
+            .join(""));
+}

package/dist/helpers/wallet.d.ts

@@ -0,0 +1,15 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+export declare const WALLET_KIND = 17375;
+export declare const WALLET_BACKUP_KIND = 375;
+export declare const WalletPrivateKeySymbol: unique symbol;
+export declare const WalletMintsSymbol: unique symbol;
+/** Returns if a wallet is locked */
+export declare function isWalletLocked(wallet: NostrEvent): boolean;
+/** Unlocks a wallet and returns the hidden tags */
+export declare function unlockWallet(wallet: NostrEvent, signer: HiddenContentSigner): Promise<string[][]>;
+export declare function lockWallet(wallet: NostrEvent): void;
+/** Returns the wallets mints */
+export declare function getWalletMints(wallet: NostrEvent): string[];
+/** Returns the wallets private key as a string */
+export declare function getWalletPrivateKey(wallet: NostrEvent): Uint8Array | undefined;

package/dist/helpers/wallet.js

@@ -0,0 +1,41 @@
+import { hexToBytes } from "@noble/hashes/utils";
+import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+export const WALLET_KIND = 17375;
+export const WALLET_BACKUP_KIND = 375;
+// Enable hidden content for wallet kinds
+setHiddenTagsEncryptionMethod(WALLET_KIND, "nip44");
+setHiddenTagsEncryptionMethod(WALLET_BACKUP_KIND, "nip44");
+export const WalletPrivateKeySymbol = Symbol.for("wallet-private-key");
+export const WalletMintsSymbol = Symbol.for("wallet-mints");
+/** Returns if a wallet is locked */
+export function isWalletLocked(wallet) {
+    return isHiddenTagsLocked(wallet);
+}
+/** Unlocks a wallet and returns the hidden tags */
+export async function unlockWallet(wallet, signer) {
+    return await unlockHiddenTags(wallet, signer);
+}
+export function lockWallet(wallet) {
+    Reflect.deleteProperty(wallet, WalletPrivateKeySymbol);
+    Reflect.deleteProperty(wallet, WalletMintsSymbol);
+    lockHiddenTags(wallet);
+}
+/** Returns the wallets mints */
+export function getWalletMints(wallet) {
+    return getOrComputeCachedValue(wallet, WalletMintsSymbol, () => {
+        const tags = getHiddenTags(wallet);
+        if (!tags)
+            throw new Error("Wallet is locked");
+        return tags.filter((t) => t[0] === "mint").map((t) => t[1]);
+    });
+}
+/** Returns the wallets private key as a string */
+export function getWalletPrivateKey(wallet) {
+    return getOrComputeCachedValue(wallet, WalletPrivateKeySymbol, () => {
+        const tags = getHiddenTags(wallet);
+        if (!tags)
+            throw new Error("Wallet is locked");
+        const key = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
+        return key ? hexToBytes(key) : undefined;
+    });
+}

package/dist/helpers/zap-info.d.ts

@@ -0,0 +1,19 @@
+import { Proof } from "@cashu/cashu-ts";
+import { NostrEvent } from "nostr-tools";
+export declare const NUTZAP_INFO_KIND = 10019;
+export declare const NutzapMintsSymbol: unique symbol;
+export declare const NutzapRelaysSymbol: unique symbol;
+/** Returns the relay URLs from a kind:10019 nutzap info event */
+export declare function getNutzapInfoRelays(event: NostrEvent): string[];
+/** Returns the mint URLs from a kind:10019 nutzap info event */
+export declare function getNutzapInfoMints(event: NostrEvent): {
+    mint: string;
+    units?: string[];
+}[];
+/** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
+export declare function getNutzapInfoPubkey(event: NostrEvent): string | undefined;
+/**
+ * verfies if proofs are locked to nutzap info
+ * @throws {Error} if proofs are not locked to nutzap info
+ */
+export declare function verifyProofsLocked(proofs: Proof[], info: NostrEvent): void;

package/dist/helpers/zap-info.js

@@ -0,0 +1,42 @@
+import { getOrComputeCachedValue, mergeRelaySets, safeParse } from "applesauce-core/helpers";
+export const NUTZAP_INFO_KIND = 10019;
+// Symbols for caching computed values
+export const NutzapMintsSymbol = Symbol.for("nutzap-mints");
+export const NutzapRelaysSymbol = Symbol.for("nutzap-relays");
+/** Returns the relay URLs from a kind:10019 nutzap info event */
+export function getNutzapInfoRelays(event) {
+    return getOrComputeCachedValue(event, NutzapRelaysSymbol, () => {
+        return mergeRelaySets(event.tags.filter((t) => t[0] === "relay").map((t) => t[1]));
+    });
+}
+/** Returns the mint URLs from a kind:10019 nutzap info event */
+export function getNutzapInfoMints(event) {
+    return getOrComputeCachedValue(event, NutzapMintsSymbol, () => {
+        return event.tags.filter((t) => t[0] === "mint").map((t) => ({ mint: t[1], units: t.slice(2).filter(Boolean) }));
+    });
+}
+/** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
+export function getNutzapInfoPubkey(event) {
+    return event.tags.find((t) => t[0] === "pubkey")?.[1];
+}
+/**
+ * verfies if proofs are locked to nutzap info
+ * @throws {Error} if proofs are not locked to nutzap info
+ */
+export function verifyProofsLocked(proofs, info) {
+    const pubkey = getNutzapInfoPubkey(info);
+    if (!pubkey)
+        throw new Error("Nutzap info must have a pubkey");
+    const fullPubkey = pubkey.length === 64 ? `02${pubkey}` : pubkey;
+    for (const proof of proofs) {
+        const secret = safeParse(proof.secret);
+        if (!secret)
+            throw new Error(`Cashu token must have a spending condition`);
+        if (!Array.isArray(secret))
+            throw new Error("Invalid spending condition");
+        if (secret[0] !== "P2PK")
+            throw new Error("Token proofs must be P2PK locked");
+        if (secret[1].data !== fullPubkey)
+            throw new Error("Token proofs must be P2PK locked to the recipient's nutzap pubkey");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as Blueprints from "./blueprints/index.js";
+export * as Helpers from "./helpers/index.js";
+export * from "./wallet-connect.js";
+export * from "./wallet-service.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * as Blueprints from "./blueprints/index.js";
+export * as Helpers from "./helpers/index.js";
+export * from "./wallet-connect.js";
+export * from "./wallet-service.js";
+export * from "./types.js";

package/dist/interface.d.ts

@@ -0,0 +1,6 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Observable<NostrEvent | string>;
+/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
+export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | Observable<any>;

package/dist/interface.js

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

package/dist/models/history.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+/** A model that returns an array of redeemed event ids for a wallet */
+export declare function WalletRedeemedModel(pubkey: string): Model<string[]>;
+/** A model that returns a timeline of wallet history events */
+export declare function WalletHistoryModel(pubkey: string, locked?: boolean | undefined): Model<NostrEvent[]>;

package/dist/models/history.js

@@ -0,0 +1,21 @@
+import { combineLatest, filter, map, scan, startWith } from "rxjs";
+import { getHistoryRedeemed, isHistoryContentLocked, WALLET_HISTORY_KIND } from "../helpers/history.js";
+/** A model that returns an array of redeemed event ids for a wallet */
+export function WalletRedeemedModel(pubkey) {
+    return (events) => events
+        .filters({ kinds: [WALLET_HISTORY_KIND], authors: [pubkey] })
+        .pipe(scan((ids, history) => [...ids, ...getHistoryRedeemed(history)], []));
+}
+/** A model that returns a timeline of wallet history events */
+export function WalletHistoryModel(pubkey, locked) {
+    return (events) => {
+        const updates = events.update$.pipe(filter((e) => e.kind === WALLET_HISTORY_KIND && e.pubkey === pubkey), startWith(undefined));
+        const timeline = events.timeline({ kinds: [WALLET_HISTORY_KIND], authors: [pubkey] });
+        return combineLatest([updates, timeline]).pipe(map(([_, history]) => {
+            if (locked === undefined)
+                return history;
+            else
+                return history.filter((entry) => isHistoryContentLocked(entry) === locked);
+        }));
+    };
+}

package/dist/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./history.js";
+export * from "./tokens.js";
+export * from "./wallet.js";
+export * from "./nutzap.js";

package/dist/models/index.js

@@ -0,0 +1,4 @@
+export * from "./history.js";
+export * from "./tokens.js";
+export * from "./wallet.js";
+export * from "./nutzap.js";

package/dist/models/nutzap.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+/** A model that returns all nutzap events for an event */
+export declare function EventNutZapzModel(event: NostrEvent): Model<NostrEvent[]>;
+/** A model that returns all nutzaps for a users profile */
+export declare function ProfileNutZapzModel(pubkey: string): Model<NostrEvent[]>;

package/dist/models/nutzap.js

@@ -0,0 +1,16 @@
+import { getReplaceableAddress, isReplaceable } from "applesauce-core/helpers";
+import { map } from "rxjs";
+import { getNutzapPointer, NUTZAP_KIND } from "../helpers/nutzap.js";
+/** A model that returns all nutzap events for an event */
+export function EventNutZapzModel(event) {
+    return (events) => isReplaceable(event.kind)
+        ? events.timeline({ kinds: [NUTZAP_KIND], "#e": [event.id] })
+        : events.timeline({ kinds: [NUTZAP_KIND], "#a": [getReplaceableAddress(event)] });
+}
+/** A model that returns all nutzaps for a users profile */
+export function ProfileNutZapzModel(pubkey) {
+    return (events) => events
+        .timeline({ kinds: [NUTZAP_KIND], "#p": [pubkey] })
+        // filter out nutzaps that are for events
+        .pipe(map((zaps) => zaps.filter((zap) => getNutzapPointer(zap) === undefined)));
+}

package/dist/models/tokens.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+/** A model that subscribes to all token events for a wallet, passing locked will filter by token locked status */
+export declare function WalletTokensModel(pubkey: string, locked?: boolean | undefined): Model<NostrEvent[]>;
+/** A model that returns the visible balance of a wallet for each mint */
+export declare function WalletBalanceModel(pubkey: string): Model<Record<string, number>>;

package/dist/models/tokens.js

@@ -0,0 +1,58 @@
+import { combineLatest, filter, map, startWith } from "rxjs";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+/** removes deleted events from sorted array */
+function filterDeleted(tokens) {
+    const deleted = new Set();
+    return Array.from(tokens)
+        .reverse()
+        .filter((token) => {
+        // skip this event if it a newer event says its deleted
+        if (deleted.has(token.id))
+            return false;
+        // add ids to deleted array
+        if (!isTokenContentLocked(token)) {
+            const details = getTokenContent(token);
+            for (const id of details.del)
+                deleted.add(id);
+        }
+        return true;
+    })
+        .reverse();
+}
+/** A model that subscribes to all token events for a wallet, passing locked will filter by token locked status */
+export function WalletTokensModel(pubkey, locked) {
+    return (events) => {
+        const updates = events.update$.pipe(filter((e) => e.kind === WALLET_TOKEN_KIND && e.pubkey === pubkey), startWith(undefined));
+        const timeline = events.timeline({ kinds: [WALLET_TOKEN_KIND], authors: [pubkey] });
+        return combineLatest([updates, timeline]).pipe(
+        // filter out locked tokens
+        map(([_, tokens]) => {
+            if (locked === undefined)
+                return tokens;
+            else
+                return tokens.filter((t) => isTokenContentLocked(t) === locked);
+        }), 
+        // remove deleted events
+        map(filterDeleted));
+    };
+}
+/** A model that returns the visible balance of a wallet for each mint */
+export function WalletBalanceModel(pubkey) {
+    return (events) => {
+        const updates = events.update$.pipe(filter((e) => e.kind === WALLET_TOKEN_KIND && e.pubkey === pubkey), startWith(undefined));
+        const timeline = events.timeline({ kinds: [WALLET_TOKEN_KIND], authors: [pubkey] });
+        return combineLatest([updates, timeline]).pipe(map(([_, tokens]) => tokens.filter((t) => !isTokenContentLocked(t))), 
+        // filter out deleted tokens
+        map(filterDeleted), 
+        // map tokens to totals
+        map((tokens) => {
+            // ignore duplicate proofs
+            const seen = new Set();
+            return tokens.reduce((totals, token) => {
+                const details = getTokenContent(token);
+                const total = details.proofs.filter(ignoreDuplicateProofs(seen)).reduce((t, p) => t + p.amount, 0);
+                return { ...totals, [details.mint]: (totals[details.mint] ?? 0) + total };
+            }, {});
+        }));
+    };
+}

package/dist/models/wallet.d.ts

@@ -0,0 +1,13 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+export type WalletInfo = {
+    locked: true;
+    event: NostrEvent;
+} | {
+    locked: false;
+    event: NostrEvent;
+    privateKey?: Uint8Array;
+    mints: string[];
+};
+/** A model to get the state of a NIP-60 wallet */
+export declare function WalletModel(pubkey: string): Model<WalletInfo | undefined>;

package/dist/models/wallet.js

@@ -0,0 +1,18 @@
+import { filter, map, merge } from "rxjs";
+import { getWalletMints, getWalletPrivateKey, isWalletLocked, WALLET_KIND } from "../helpers/wallet.js";
+/** A model to get the state of a NIP-60 wallet */
+export function WalletModel(pubkey) {
+    return (events) => merge(
+    // get the latest replaceable event
+    events.replaceable(WALLET_KIND, pubkey), 
+    // and listen for any updates to matching events
+    events.update$.pipe(filter((e) => e.kind === WALLET_KIND && e.pubkey === pubkey))).pipe(map((wallet) => {
+        if (!wallet)
+            return;
+        if (isWalletLocked(wallet))
+            return { locked: true, event: wallet };
+        const mints = getWalletMints(wallet);
+        const privateKey = getWalletPrivateKey(wallet);
+        return { locked: false, mints, privateKey, event: wallet };
+    }));
+}

package/dist/operations/history.d.ts

@@ -0,0 +1,7 @@
+import { EventOperation } from "applesauce-factory";
+import { EventPointer } from "nostr-tools/nip19";
+import { HistoryContent } from "../helpers/history.js";
+/** Sets the encrypted tags of a wallet history event */
+export declare function setHistoryContent(content: HistoryContent): EventOperation;
+/** Sets the "e" "redeemed" tags on a wallet history event */
+export declare function setHistoryRedeemed(redeemed: (string | EventPointer)[]): EventOperation;

package/dist/operations/history.js

@@ -0,0 +1,34 @@
+import { ensureMarkedEventPointerTag } from "applesauce-factory/helpers";
+import { modifyHiddenTags, modifyPublicTags } from "applesauce-factory/operations";
+import { setSingletonTag } from "applesauce-factory/operations/tag";
+/** Includes "e" "created" tags in wallet history tags */
+function includeHistoryCreatedTags(created) {
+    return (tags) => {
+        for (const id of created) {
+            tags = ensureMarkedEventPointerTag(tags, typeof id === "string" ? { id } : id, "created");
+        }
+        return tags;
+    };
+}
+/** Sets the encrypted tags of a wallet history event */
+export function setHistoryContent(content) {
+    const operations = [
+        setSingletonTag(["direction", content.direction], true),
+        setSingletonTag(["amount", String(content.amount)], true),
+        includeHistoryCreatedTags(content.created),
+    ];
+    if (content.fee !== undefined)
+        operations.push(setSingletonTag(["fee", String(content.fee)], true));
+    if (content.mint !== undefined)
+        operations.push(setSingletonTag(["mint", content.mint], true));
+    return modifyHiddenTags(...operations);
+}
+/** Sets the "e" "redeemed" tags on a wallet history event */
+export function setHistoryRedeemed(redeemed) {
+    return modifyPublicTags((tags) => {
+        for (const id of redeemed) {
+            tags = ensureMarkedEventPointerTag(tags, typeof id === "string" ? { id } : id, "redeemed");
+        }
+        return tags;
+    });
+}

package/dist/operations/index.d.ts

@@ -0,0 +1,5 @@
+export * as History from "./history.js";
+export * as Tokens from "./tokens.js";
+export * as Wallet from "./wallet.js";
+export * as ZapInfo from "./zap-info.js";
+export * as NutZap from "./nutzap.js";

package/dist/operations/index.js

@@ -0,0 +1,5 @@
+export * as History from "./history.js";
+export * as Tokens from "./tokens.js";
+export * as Wallet from "./wallet.js";
+export * as ZapInfo from "./zap-info.js";
+export * as NutZap from "./nutzap.js";

package/dist/operations/nutzap.d.ts

@@ -0,0 +1,14 @@
+import { Proof } from "@cashu/cashu-ts";
+import { EventOperation } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+/** Sets the cashu proofs for a nutzap event */
+export declare function setProofs(proofs: Proof[]): EventOperation;
+/** Sets the mint URL for a nutzap event */
+export declare function setMint(mint: string): EventOperation;
+/** Sets the recipient of a nutzap event */
+export declare function setRecipient(recipient: string | ProfilePointer): EventOperation;
+/** Sets the event that is being nutzapped */
+export declare function setEvent(event: EventPointer | AddressPointer | NostrEvent): EventOperation;
+/** Sets the comment content for a nutzap event */
+export declare function setComment(comment: string): EventOperation;

package/dist/operations/nutzap.js

@@ -0,0 +1,33 @@
+import { getReplaceableAddress, isAddressPointer, isEvent, isReplaceable } from "applesauce-core/helpers";
+import { modifyPublicTags } from "applesauce-factory/operations";
+import { setContent } from "applesauce-factory/operations/content";
+import { addAddressTag, addEventTag, addPubkeyTag, setSingletonTag } from "applesauce-factory/operations/tag";
+/** Sets the cashu proofs for a nutzap event */
+export function setProofs(proofs) {
+    // Create an operation to append proof tags
+    const operation = (tags) => [...tags, ...proofs.map((proof) => ["proof", JSON.stringify(proof)])];
+    return modifyPublicTags(operation);
+}
+/** Sets the mint URL for a nutzap event */
+export function setMint(mint) {
+    return modifyPublicTags(setSingletonTag(["u", mint]));
+}
+/** Sets the recipient of a nutzap event */
+export function setRecipient(recipient) {
+    return modifyPublicTags(addPubkeyTag(recipient, true));
+}
+/** Sets the event that is being nutzapped */
+export function setEvent(event) {
+    let operation;
+    if (isEvent(event))
+        operation = isReplaceable(event.kind) ? addEventTag(event.id) : addAddressTag(getReplaceableAddress(event));
+    else if (isAddressPointer(event))
+        operation = addAddressTag(event);
+    else
+        operation = addEventTag(event);
+    return modifyPublicTags(operation);
+}
+/** Sets the comment content for a nutzap event */
+export function setComment(comment) {
+    return setContent(comment);
+}

package/dist/operations/tokens.d.ts

@@ -0,0 +1,4 @@
+import { Token } from "@cashu/cashu-ts";
+import { EventOperation } from "applesauce-factory";
+/** Sets the content of a 7375 token event */
+export declare function setToken(token: Token, del?: string[]): EventOperation;

package/dist/operations/tokens.js

@@ -0,0 +1,24 @@
+import { EventContentEncryptionMethod } from "applesauce-core/helpers";
+import { setEncryptedContent } from "applesauce-factory/operations/content";
+/** Sets the content of a 7375 token event */
+export function setToken(token, del = []) {
+    return async (draft, ctx) => {
+        if (!ctx.signer)
+            throw new Error(`Missing signer`);
+        const pubkey = await ctx.signer.getPublicKey();
+        const method = EventContentEncryptionMethod[draft.kind];
+        if (!method)
+            throw new Error("Failed to find encryption method");
+        if (!token.mint)
+            throw new Error("Token mint is required");
+        if (!token.proofs || token.proofs.length === 0)
+            throw new Error("Token proofs are required");
+        const content = {
+            mint: token.mint,
+            proofs: token.proofs,
+            unit: token.unit,
+            del,
+        };
+        return await setEncryptedContent(pubkey, JSON.stringify(content), method)(draft, ctx);
+    };
+}

package/dist/operations/wallet.d.ts

@@ -0,0 +1,8 @@
+import { EventOperation } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+/** Sets the content of a kind 375 wallet backup event */
+export declare function setBackupContent(wallet: NostrEvent): EventOperation;
+/** Sets the "mint" tags in a wallet event */
+export declare function setMints(mints: string[]): EventOperation;
+/** Sets the "privkey" tag on a wallet event */
+export declare function setPrivateKey(privateKey: Uint8Array): EventOperation;