applesauce-wallet 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/actions/common.d.ts

@@ -0,0 +1,4 @@
+import { User } from "applesauce-common/casts";
+import { EventSigner } from "applesauce-core";
+import "../casts/__register__.js";
+export declare function getUnlockedWallet(user: User, signer?: EventSigner): Promise<import("../casts/wallet.js").Wallet>;

package/dist/actions/common.js

@@ -0,0 +1,15 @@
+import { unlockWallet } from "../helpers/wallet.js";
+// Make sure the wallet$ is registered on the user class
+import "../casts/__register__.js";
+export async function getUnlockedWallet(user, signer) {
+    // NOTE: hard coding the timeout here isn't ideal, but no idea where else to put it
+    const wallet = await user.wallet$.$first(5000, undefined);
+    if (!wallet)
+        throw new Error("Unable to find wallet");
+    if (!wallet.unlocked) {
+        if (!signer)
+            throw new Error("Missing signer");
+        await unlockWallet(wallet.event, signer);
+    }
+    return wallet;
+}

package/dist/actions/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./wallet.js";
 export * from "./tokens.js";
-export * from "./zaps.js";
-export * from "./zap-info.js";
+export * from "./nutzaps.js";
+export * from "./nutzap-info.js";
+export * from "./mint-recomendation.js";

package/dist/actions/index.js

@@ -1,4 +1,5 @@
 export * from "./wallet.js";
 export * from "./tokens.js";
-export * from "./zaps.js";
-export * from "./zap-info.js";
+export * from "./nutzaps.js";
+export * from "./nutzap-info.js";
+export * from "./mint-recomendation.js";

package/dist/actions/mint-recomendation.d.ts

@@ -0,0 +1,30 @@
+import { Wallet } from "@cashu/cashu-ts";
+import { Action } from "applesauce-actions";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import "../casts/__register__.js";
+/**
+ * Options for reviewing a mint
+ */
+export type ReviewMintOptions = {
+    /** Optional review/comment content */
+    comment?: string;
+    /** Optional relays to publish to */
+    relays?: string[];
+};
+/**
+ * An action that creates and publishes a mint recommendation event.
+ * Can accept a mint URL, Wallet instance, or MintInfo event.
+ */
+export declare function RecommendMint(input: string | Wallet | NostrEvent, options?: ReviewMintOptions): Action;
+/**
+ * Options for updating a mint recommendation
+ */
+export type UpdateMintRecommendationOptions = {
+    /** Optional relays to publish to */
+    relays?: string[];
+};
+/**
+ * An action that updates the comment on an existing mint recommendation event.
+ * Can accept a mint pubkey (to find the recommendation) or the recommendation event directly.
+ */
+export declare function UpdateMintRecommendation(input: string | NostrEvent, comment: string, options?: UpdateMintRecommendationOptions): Action;

package/dist/actions/mint-recomendation.js

@@ -0,0 +1,96 @@
+import { Wallet } from "@cashu/cashu-ts";
+import { MintRecommendationBlueprint } from "../blueprints/mint-recommendation.js";
+import { getCashuMintPubkey, getCashuMintURL, isValidCashuMintInfo } from "../helpers/mint-info.js";
+import { MINT_RECOMMENDATION_KIND, getRecommendationMintPubkey, isValidMintRecommendation, } from "../helpers/mint-recommendation.js";
+import { setComment } from "../operations/mint-recommendation.js";
+// Helper function to fetch mint pubkey from URL
+async function fetchMintPubkey(mintUrl) {
+    // Fetch mint info directly from the /v1/info endpoint
+    const infoUrl = new URL("/v1/info", mintUrl).toString();
+    const response = await fetch(infoUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch mint info from ${mintUrl}: ${response.statusText}`);
+    }
+    const mintInfo = (await response.json());
+    return mintInfo.pubkey;
+}
+// Make sure the mint recommendation cast is registered
+import "../casts/__register__.js";
+/**
+ * An action that creates and publishes a mint recommendation event.
+ * Can accept a mint URL, Wallet instance, or MintInfo event.
+ */
+export function RecommendMint(input, options) {
+    return async ({ factory, sign, publish }) => {
+        let mintPubkey;
+        let url;
+        let addressPointer = undefined;
+        // Handle different input types
+        if (typeof input === "string") {
+            if (!URL.canParse(input))
+                throw new Error("Invalid mint URL");
+            // Input is a mint URL - fetch info directly
+            url = input;
+            mintPubkey = await fetchMintPubkey(url);
+        }
+        else if (input instanceof Wallet) {
+            const info = input.getMintInfo();
+            mintPubkey = info.pubkey;
+        }
+        else {
+            // Input is a MintInfo event (kind:38172)
+            if (!isValidCashuMintInfo(input))
+                throw new Error("Invalid mint info event. Expected kind:38172 with required `d` and `u` tags.");
+            mintPubkey = getCashuMintPubkey(input);
+            url = getCashuMintURL(input);
+            // Use the event itself as address pointer (blueprint will convert it)
+            addressPointer = input;
+        }
+        // Create the mint recommendation event
+        const recommendation = await factory
+            .create(MintRecommendationBlueprint, {
+            mintPubkey,
+            url,
+            addressPointer,
+            comment: options?.comment,
+        })
+            .then(sign);
+        // Publish the event
+        await publish(recommendation, options?.relays);
+    };
+}
+/**
+ * An action that updates the comment on an existing mint recommendation event.
+ * Can accept a mint pubkey (to find the recommendation) or the recommendation event directly.
+ */
+export function UpdateMintRecommendation(input, comment, options) {
+    return async ({ events, factory, self, sign, publish }) => {
+        let recommendation;
+        // Handle different input types
+        if (typeof input === "string") {
+            // Input is a mint pubkey - find the recommendation event
+            const recommendations = events.getTimeline({ kinds: [MINT_RECOMMENDATION_KIND], authors: [self] });
+            recommendation = recommendations.find((rec) => {
+                if (!isValidMintRecommendation(rec))
+                    return false;
+                const recMintPubkey = getRecommendationMintPubkey(rec);
+                return recMintPubkey === input;
+            });
+            if (!recommendation)
+                throw new Error(`No mint recommendation found for mint pubkey: ${input}`);
+        }
+        else {
+            // Input is a recommendation event
+            if (!isValidMintRecommendation(input))
+                throw new Error("Invalid mint recommendation event");
+            // Verify the event belongs to the current user
+            if (input.pubkey !== self)
+                throw new Error("Cannot update a mint recommendation that belongs to another user");
+            recommendation = input;
+        }
+        // Update the comment
+        const updated = await factory.modify(recommendation, setComment(comment)).then(sign);
+        // Publish the updated event
+        await publish(updated, options?.relays);
+    };
+}

package/dist/actions/{zap-info.d.ts → nutzap-info.d.ts}

@@ -1,4 +1,5 @@
 import { Action } from "applesauce-actions";
+import "../casts/__register__.js";
 /** An action to add a relay to the kind 10019 nutzap info event */
 export declare function AddNutzapInfoRelay(relay: string | string[]): Action;
 /** An action to remove a relay from the kind 10019 nutzap info event */
@@ -13,10 +14,26 @@ export declare function AddNutzapInfoMint(mint: {
 }>): Action;
 /** An action to remove a mint from the kind 10019 nutzap info event */
 export declare function RemoveNutzapInfoMint(mint: string | string[]): Action;
-/** An action to set the pubkey for the kind 10019 nutzap info event */
-export declare function SetNutzapInfoPubkey(pubkey: string): Action;
 /** An action to update the entire nutzap info event */
 export declare function UpdateNutzapInfo(relays: string[], mints: Array<{
     url: string;
     units?: string[];
-}>, pubkey: string): Action;
+}>): Action;
+/**
+ * Sets the mints on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export declare function SetNutzapInfoMints(mints: Array<{
+    url: string;
+    units?: string[];
+}>): Action;
+/**
+ * Sets the relays on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export declare function SetNutzapInfoRelays(relays: string[]): Action;
+/**
+ * Sets the pubkey on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export declare function SetNutzapInfoPubkey(privateKey: Uint8Array): Action;

package/dist/actions/nutzap-info.js

@@ -0,0 +1,117 @@
+import { getNutzapInfoRelays, NUTZAP_INFO_KIND } from "../helpers/nutzap-info.js";
+import { addNutzapInfoMint, addNutzapInfoRelay, removeNutzapInfoMint, removeNutzapInfoRelay, setNutzapInfoMints, setNutzapInfoPubkey, setNutzapInfoRelays, } from "../operations/nutzap-info.js";
+// Make sure the nutzap$ is registered on the user class
+import "../casts/__register__.js";
+/** An action to add a relay to the kind 10019 nutzap info event */
+export function AddNutzapInfoRelay(relay) {
+    return async ({ events, factory, self, sign, publish }) => {
+        if (typeof relay === "string")
+            relay = [relay];
+        const operations = relay.map((r) => addNutzapInfoRelay(r));
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const signed = nutzapInfo
+            ? await factory.modify(nutzapInfo, ...operations).then(sign)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}
+/** An action to remove a relay from the kind 10019 nutzap info event */
+export function RemoveNutzapInfoRelay(relay) {
+    return async ({ events, factory, self, sign, publish }) => {
+        if (typeof relay === "string")
+            relay = [relay];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            return;
+        const operations = relay.map((r) => removeNutzapInfoRelay(r));
+        const signed = await factory.modify(nutzapInfo, ...operations).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}
+/** An action to add a mint to the kind 10019 nutzap info event */
+export function AddNutzapInfoMint(mint) {
+    return async ({ events, factory, self, sign, publish }) => {
+        const mints = Array.isArray(mint) ? mint : [mint];
+        const operations = mints.map((m) => addNutzapInfoMint(m));
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const signed = nutzapInfo
+            ? await factory.modify(nutzapInfo, ...operations).then(sign)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}
+/** An action to remove a mint from the kind 10019 nutzap info event */
+export function RemoveNutzapInfoMint(mint) {
+    return async ({ events, factory, self, sign, publish }) => {
+        if (typeof mint === "string")
+            mint = [mint];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            return;
+        const operations = mint.map((m) => removeNutzapInfoMint(m));
+        const signed = await factory.modify(nutzapInfo, ...operations).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}
+/** An action to update the entire nutzap info event */
+export function UpdateNutzapInfo(relays, mints) {
+    return async ({ events, factory, self, sign, publish }) => {
+        const operations = [setNutzapInfoRelays(relays), setNutzapInfoMints(mints)];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const signed = nutzapInfo
+            ? await factory.modify(nutzapInfo, ...operations).then(sign)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
+        await publish(signed, relays);
+    };
+}
+/**
+ * Sets the mints on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export function SetNutzapInfoMints(mints) {
+    return async ({ events, self, factory, sign, publish }) => {
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            throw new Error("Nutzap info does not exist");
+        const signed = await factory.modify(nutzapInfo, setNutzapInfoMints(mints)).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}
+/**
+ * Sets the relays on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export function SetNutzapInfoRelays(relays) {
+    return async ({ events, self, factory, sign, publish }) => {
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            throw new Error("Nutzap info does not exist");
+        const signed = await factory.modify(nutzapInfo, setNutzapInfoRelays(relays)).then(sign);
+        await publish(signed, relays);
+    };
+}
+/**
+ * Sets the pubkey on a nutzap info event
+ * @throws if the nutzap info does not exist
+ */
+export function SetNutzapInfoPubkey(privateKey) {
+    return async ({ events, self, factory, sign, publish }) => {
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            throw new Error("Nutzap info does not exist");
+        const signed = await factory.modify(nutzapInfo, setNutzapInfoPubkey(privateKey)).then(sign);
+        // Use relays from the updated event
+        const relays = getNutzapInfoRelays(signed);
+        await publish(signed, relays);
+    };
+}

package/dist/actions/nutzaps.d.ts

@@ -0,0 +1,24 @@
+import { Token } from "@cashu/cashu-ts";
+import { Action } from "applesauce-actions";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { ProfilePointer } from "applesauce-core/helpers/pointers";
+import { Couch } from "../helpers/couch.js";
+import "../casts/__register__.js";
+/** Creates a NIP-61 nutzap event for an event with a token */
+export declare function NutzapEvent(event: NostrEvent, token: Token, options?: {
+    comment?: string;
+    couch?: Couch;
+}): Action;
+/** Creates a NIP-61 nutzap event to a users profile */
+export declare function NutzapProfile(user: string | ProfilePointer, token: Token, options?: {
+    comment?: string;
+    couch?: Couch;
+}): Action;
+/**
+ * Receives a P2PK-locked cashu token from a nutzap event(s) by unlocking it with the wallet's private key
+ * and marks the nutzap event(s) as redeemed
+ * Supports nutzaps with different mints by grouping them by mint and redeeming each group separately
+ * @param nutzaps single nutzap event or array of nutzap events
+ * @param couch optional couch interface for temporarily storing tokens during the operation
+ */
+export declare function ReceiveNutzaps(nutzaps: NostrEvent | NostrEvent[], couch?: Couch): Action;

package/dist/actions/nutzaps.js

@@ -0,0 +1,154 @@
+import { sumProofs, Wallet } from "@cashu/cashu-ts";
+import { castUser } from "applesauce-common/casts";
+import { bytesToHex } from "applesauce-core/helpers/event";
+import { WalletHistoryBlueprint } from "../blueprints/history.js";
+import { WalletTokenBlueprint } from "../blueprints/tokens.js";
+import { NutzapBlueprint, ProfileNutzapBlueprint } from "../blueprints/zaps.js";
+import { verifyProofsLocked } from "../helpers/nutzap-info.js";
+import { getNutzapMint, getNutzapProofs, isValidNutzap } from "../helpers/nutzap.js";
+import { getUnlockedWallet } from "./common.js";
+// Make sure the nutzap$ is registered on the user class
+import "../casts/__register__.js";
+/** Creates a NIP-61 nutzap event for an event with a token */
+export function NutzapEvent(event, token, options) {
+    return async ({ events, factory, user, signer, sign, publish }) => {
+        const { comment, couch } = options ?? {};
+        const clearStoredToken = await couch?.store(token);
+        try {
+            const recipient = castUser(event.pubkey, events);
+            // Get the recipient's nutzap info
+            const info = await recipient.nutzap$.$first(5000, undefined);
+            if (!info)
+                throw new Error("Nutzap info not found");
+            // Get the users wallet
+            const wallet = await getUnlockedWallet(user, signer);
+            // Verify all tokens are p2pk locked
+            verifyProofsLocked(token.proofs, info.event);
+            // Create the nutzap event
+            const nutzap = await factory.create(NutzapBlueprint, event, token, comment || token.memo).then(sign);
+            // Publish the nutzap event
+            await publish(nutzap, wallet.relays);
+        }
+        catch { }
+        await clearStoredToken?.();
+    };
+}
+/** Creates a NIP-61 nutzap event to a users profile */
+export function NutzapProfile(user, token, options) {
+    return async ({ events, factory, sign, publish }) => {
+        const { comment, couch } = options ?? {};
+        const clearStoredToken = await couch?.store(token);
+        try {
+            const recipient = castUser(user, events);
+            // Get the target's nutzap info
+            const info = await recipient.nutzap$.$first(5000, undefined);
+            if (!info)
+                throw new Error("Nutzap info not found");
+            // Verify all tokens are p2pk locked
+            verifyProofsLocked(token.proofs, info.event);
+            // Create the nutzap event
+            const nutzap = await factory.create(ProfileNutzapBlueprint, recipient, token, comment || token.memo).then(sign);
+            // Publish the nutzap event
+            await publish(nutzap, info.relays);
+        }
+        catch { }
+        await clearStoredToken?.();
+    };
+}
+/**
+ * Receives a P2PK-locked cashu token from a nutzap event(s) by unlocking it with the wallet's private key
+ * and marks the nutzap event(s) as redeemed
+ * Supports nutzaps with different mints by grouping them by mint and redeeming each group separately
+ * @param nutzaps single nutzap event or array of nutzap events
+ * @param couch optional couch interface for temporarily storing tokens during the operation
+ */
+export function ReceiveNutzaps(nutzaps, couch) {
+    return async ({ factory, user, signer, sign, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
+        // Normalize to array
+        nutzaps = Array.isArray(nutzaps) ? nutzaps : [nutzaps];
+        if (nutzaps.length === 0)
+            throw new Error("No nutzap events provided");
+        // Filter out nutzaps without mints or proofs (ignore them)
+        const validNutzaps = nutzaps.filter((n) => isValidNutzap(n));
+        if (validNutzaps.length === 0)
+            throw new Error("No valid nutzaps with mints and proofs found");
+        // Get private key from current wallet event
+        const wallet = await getUnlockedWallet(user, signer);
+        // Group nutzaps by mint
+        const nutzapsByMint = new Map();
+        for (const nutzap of validNutzaps) {
+            const mint = getNutzapMint(nutzap);
+            if (!mint)
+                continue; // Should not happen after filtering, but TypeScript needs this
+            if (!nutzapsByMint.has(mint)) {
+                nutzapsByMint.set(mint, []);
+            }
+            nutzapsByMint.get(mint).push(nutzap);
+        }
+        if (nutzapsByMint.size === 0)
+            throw new Error("No valid nutzaps with mints found");
+        if (!wallet.privateKey)
+            throw new Error("No private key found in wallet");
+        // Convert private key to hex string for cashu-ts
+        const privkeyHex = bytesToHex(wallet.privateKey);
+        // Track clear methods for all stored tokens
+        const clearMethods = [];
+        try {
+            // Process each mint group separately
+            for (const [mint, mintNutzaps] of nutzapsByMint) {
+                // Extract all proofs from nutzaps for this mint
+                const allProofs = mintNutzaps.flatMap(getNutzapProofs);
+                if (allProofs.length === 0)
+                    continue;
+                // Construct token from nutzap proofs
+                const token = {
+                    mint,
+                    proofs: allProofs,
+                    unit: "sat",
+                };
+                // Use cashu-ts to receive/unlock the P2PK-locked token
+                const cashuWallet = new Wallet(mint);
+                await cashuWallet.loadMint();
+                // Receive the token using the new wallet.ops API
+                // This will swap P2PK-locked proofs with unlocked proofs
+                let receivedProofs;
+                try {
+                    receivedProofs = await cashuWallet.ops.receive(token).privkey(privkeyHex).run();
+                }
+                catch (error) {
+                    throw new Error(`Failed to receive token for mint ${mint}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                // Calculate total amount
+                const amount = sumProofs(receivedProofs);
+                // Create token event with received unlocked proofs
+                const receivedToken = {
+                    mint,
+                    proofs: receivedProofs,
+                    unit: "sat",
+                };
+                // Store token in couch immediately after receiving it
+                const clearStoredToken = await couch?.store(receivedToken);
+                if (clearStoredToken) {
+                    clearMethods.push(clearStoredToken);
+                }
+                const tokenEvent = await factory.create(WalletTokenBlueprint, receivedToken, []).then(sign);
+                // Create history event marking nutzap events as redeemed
+                const nutzapIds = mintNutzaps.map((n) => n.id);
+                const history = await factory
+                    .create(WalletHistoryBlueprint, { direction: "in", amount, mint, created: [tokenEvent.id] }, nutzapIds)
+                    .then(sign);
+                // Publish events
+                await publish(tokenEvent, wallet.relays);
+                await publish(history, wallet.relays);
+            }
+            // Clear all stored tokens from the couch after successfully publishing all events for all mints
+            await Promise.all(clearMethods.map((clear) => clear()));
+        }
+        catch (error) {
+            // If an error occurs, don't clear the couch (tokens remain for recovery)
+            throw error;
+        }
+    };
+}

package/dist/actions/tokens.d.ts

@@ -1,17 +1,87 @@
-import { Token } from "@cashu/cashu-ts";
+import { Proof, Token, Wallet } from "@cashu/cashu-ts";
 import { Action } from "applesauce-actions";
 import { NostrEvent } from "applesauce-core/helpers/event";
+import { Couch } from "../helpers/couch.js";
+import "../casts/__register__.js";
 /**
- * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * Adds a cashu token to the wallet and creates a history event
  * @param token the cashu token to add
- * @param redeemed an array of nutzap event ids to mark as redeemed
+ * @param redeemed an array of event ids to mark as redeemed
  */
-export declare function ReceiveToken(token: Token, redeemed?: string[], fee?: number): Action;
+export declare function AddToken(token: Token, options?: {
+    redeemed?: string[];
+    fee?: number;
+    addHistory?: boolean;
+}): Action;
+/** Similar to the AddToken action but swaps the tokens before receiving them */
+export declare function ReceiveToken(token: Token, options?: {
+    addHistory?: boolean;
+    couch?: Couch;
+}): Action;
 /** An action that deletes old tokens and creates a new one but does not add a history event */
 export declare function RolloverTokens(tokens: NostrEvent[], token: Token): Action;
 /** An action that deletes old token events and adds a spend history item */
-export declare function CompleteSpend(spent: NostrEvent[], change: Token): Action;
+export declare function CompleteSpend(spent: NostrEvent[], change: Token, couch?: Couch): Action;
 /** Combines all unlocked token events into a single event per mint */
-export declare function ConsolidateTokens(opts?: {
-    ignoreLocked?: boolean;
+export declare function ConsolidateTokens(options?: {
+    unlockTokens?: boolean;
+}): Action;
+/**
+ * Recovers tokens from a couch by checking if they exist in the wallet,
+ * verifying they are unspent, and creating token events for any recoverable tokens
+ * @param couch the couch interface to recover tokens from
+ */
+export declare function RecoverFromCouch(couch: Couch): Action;
+/**
+ * Token selection function type that matches dumbTokenSelection signature.
+ * Must return tokens from a single mint and ensure all selected tokens are from that mint.
+ * If mint is undefined, the function should find a mint with sufficient balance.
+ */
+export type TokenSelectionFunction = (tokens: NostrEvent[], minAmount: number, mint?: string) => {
+    events: NostrEvent[];
+    proofs: Proof[];
+};
+/**
+ * A generic action that safely selects tokens, performs an async operation, and handles change.
+ * This action requires a couch for safety - tokens are stored in the couch before the operation
+ * and can be recovered if something goes wrong.
+ *
+ * @param minAmount The minimum amount of tokens to select (in sats)
+ * @param operation An async function that receives selected proofs and performs the operation.
+ *                  Should return any change proofs. All selected proofs are considered used.
+ * @param options Configuration options including mint filter, required couch, and optional custom token selection
+ *
+ * @example
+ * // Use with NutzapProfile
+ * await run(TokensOperation, 100, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   const { keep, send } = await cashuWallet.ops.send(100, selectedProofs).asP2PK({ pubkey }).run();
+ *   await run(NutzapProfile, recipient, { mint, proofs: send, unit: "sat" });
+ *   return { change: keep };
+ * }, { couch });
+ *
+ * @example
+ * // Use with melt
+ * await run(TokensOperation, meltAmount + feeReserve, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   const meltQuote = await cashuWallet.createMeltQuoteBolt11(invoice);
+ *   const { keep, send } = await cashuWallet.send(meltAmount + meltQuote.fee_reserve, selectedProofs, { includeFees: true });
+ *   const meltResponse = await cashuWallet.meltProofs(meltQuote, send);
+ *   return { change: meltResponse.change };
+ * }, { couch });
+ *
+ * @example
+ * // Use with custom token selection
+ * await run(TokensOperation, 100, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   // ... operation
+ * }, { couch, tokenSelection: myCustomSelectionFunction });
+ */
+export declare function TokensOperation(minAmount: number, operation: (params: {
+    selectedProofs: Proof[];
+    mint: string;
+    cashuWallet: Wallet;
+}) => Promise<{
+    change?: Proof[];
+}>, options: {
+    mint?: string;
+    couch: Couch;
+    tokenSelection?: TokenSelectionFunction;
 }): Action;