applesauce-wallet 6.0.0 → 6.2.0

package/dist/actions/tokens.js

@@ -1,12 +1,26 @@
-import { CheckStateEnum, sumProofs, Wallet } from "@cashu/cashu-ts";
+import { CheckStateEnum, normalizeProofAmounts, sumProofs, Wallet, } from "@cashu/cashu-ts";
 import { DeleteFactory } from "applesauce-core/factories";
 import { WalletHistoryFactory } from "../factories/history.js";
 import { WalletTokenFactory } from "../factories/tokens.js";
 import { getProofUID, ignoreDuplicateProofs } from "../helpers/cashu.js";
-import { dumbTokenSelection, getTokenContent, isTokenContentUnlocked, unlockTokenContent, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
+import { dumbTokenSelection, getTokenContent, getTokenDeletedIds, isTokenContentUnlocked, unlockTokenContent, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
 import { getUnlockedWallet } from "./common.js";
 // Make sure the wallet$ is registered on the user class
 import "../casts/__register__.js";
+/**
+ * Returns a loaded cashu {@link Wallet} for a mint url. Resolves in priority order: a pre-loaded `wallet`
+ * instance when given (so a caller can reuse a single instance across operations), then the `getCashuWallet`
+ * provider (so a caller can supply a cached, wallet-specific instance), otherwise creates and loads a fresh wallet.
+ */
+async function loadCashuWallet(mint, options) {
+    if (options?.wallet)
+        return options.wallet;
+    if (options?.getCashuWallet)
+        return options.getCashuWallet(mint);
+    const wallet = new Wallet(mint);
+    await wallet.loadMint();
+    return wallet;
+}
 /**
  * Adds a cashu token to the wallet and creates a history event
  * @param token the cashu token to add
@@ -18,7 +32,7 @@ export function AddToken(token, options) {
         if (!signer)
             throw new Error("Missing signer");
         const wallet = await getUnlockedWallet(user, signer);
-        const amount = sumProofs(token.proofs);
+        const amount = sumProofs(token.proofs).toNumber();
         // Create the token and history events
         const tokenEvent = await WalletTokenFactory.create(token).sign(signer);
         let history;
@@ -41,14 +55,13 @@ export function AddToken(token, options) {
 /** Similar to the AddToken action but swaps the tokens before receiving them */
 export function ReceiveToken(token, options) {
     return async ({ run }) => {
-        const { couch, ...restOptions } = options ?? {};
+        const { couch, wallet, getCashuWallet, ...restOptions } = options ?? {};
         // Get the cashu wallet
-        const cashuWallet = new Wallet(token.mint);
-        await cashuWallet.loadMint();
-        const amount = sumProofs(token.proofs);
+        const cashuWallet = await loadCashuWallet(token.mint, { wallet, getCashuWallet });
+        const amount = sumProofs(token.proofs).toNumber();
         // Swap cashu tokens
         const receivedProofs = await cashuWallet.ops.receive(token).run();
-        const fee = amount - sumProofs(receivedProofs);
+        const fee = amount - sumProofs(receivedProofs).toNumber();
         // Create a new token with the received proofs
         const receivedToken = {
             ...token,
@@ -68,22 +81,61 @@ export function ReceiveToken(token, options) {
         }
     };
 }
-/** An action that deletes old tokens and creates a new one but does not add a history event */
-export function RolloverTokens(tokens, token) {
-    return async ({ signer, user, publish }) => {
-        if (!signer)
-            throw new Error("Missing signer");
-        const wallet = await getUnlockedWallet(user, signer);
-        // create a new token event
-        const tokenEvent = await WalletTokenFactory.create(token, tokens.map((e) => e.id)).sign(signer);
-        // create a delete event for old tokens
-        const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
-        // publish events
-        await publish([tokenEvent, deleteEvent], wallet.relays);
+/**
+ * A method-agnostic action that mints new proofs from a paid mint quote and adds them to the wallet.
+ * The `mintProofs` callback performs the payment-method-specific mint call (bolt11, bolt12, onchain, …)
+ * against the loaded cashu {@link Wallet}; everything else (couch safety + token/history bookkeeping) is
+ * shared. {@link MintTokens} is the bolt11 wrapper over this action.
+ * @param mint the mint url to mint the proofs from
+ * @param mintProofs a callback that mints and returns the new proofs for the paid quote
+ * @param options.couch optional couch interface for temporarily storing the minted token
+ * @param options.wallet optional pre-loaded cashu Wallet for the mint
+ * @param options.getCashuWallet optional provider returning a cached cashu Wallet for a mint
+ */
+export function MintProofs(mint, mintProofs, options) {
+    return async ({ run }) => {
+        const { couch, wallet, getCashuWallet } = options ?? {};
+        // Mint the new proofs from the paid quote (throws if the quote has not been paid)
+        const cashuWallet = await loadCashuWallet(mint, { wallet, getCashuWallet });
+        const proofs = await mintProofs(cashuWallet);
+        const token = { mint, proofs, unit: "sat" };
+        // Store the token in the couch immediately after minting it
+        const clearStoredToken = await couch?.store(token);
+        try {
+            // Add the minted token to the wallet (creates a token event + "in" history)
+            await run(AddToken, token);
+            // Clear the stored token from the couch after successful completion
+            await clearStoredToken?.();
+        }
+        catch (error) {
+            // If an error occurs, don't clear the couch (tokens remain for recovery)
+            throw error;
+        }
     };
 }
-/** An action that deletes old token events and adds a spend history item */
-export function CompleteSpend(spent, change, couch) {
+/**
+ * Mints new proofs from an already-paid bolt11 mint quote and adds them to the wallet.
+ * A thin bolt11 wrapper over {@link MintProofs}.
+ * @param mint the mint url to mint the proofs from
+ * @param amount the amount of the paid mint quote in sats
+ * @param quote the paid mint quote id or response
+ * @param options.couch optional couch interface for temporarily storing the minted token
+ * @param options.wallet optional pre-loaded cashu Wallet for the mint
+ * @param options.getCashuWallet optional provider returning a cached cashu Wallet for a mint
+ */
+export function MintTokens(mint, amount, quote, options) {
+    return MintProofs(mint, (cashuWallet) => cashuWallet.mintProofsBolt11(amount, quote), options);
+}
+/**
+ * An action that deletes old token events and adds a spend history item
+ * @param options.createDeleteEvents whether to publish a NIP-09 delete event for the spent token events
+ *   (default true). The change token event always references the spent ids in its `del` field, so the
+ *   wallet can reconcile its balance without the delete event; skipping it saves a signing operation at
+ *   the cost of leaving the spent token events on relays until {@link CleanupDeletedTokens}.
+ * @param options.couch optional couch interface for temporarily storing the change token
+ */
+export function CompleteSpend(spent, change, options) {
+    const createDeleteEvents = options?.createDeleteEvents ?? true;
     return async ({ signer, user, publish }) => {
         if (!signer)
             throw new Error("Missing signer");
@@ -93,11 +145,11 @@ export function CompleteSpend(spent, change, couch) {
         if (unlocked.length !== spent.length)
             throw new Error("Cant complete spend with locked tokens");
         const wallet = await getUnlockedWallet(user, signer);
-        const changeAmount = sumProofs(change.proofs);
+        const changeAmount = sumProofs(change.proofs).toNumber();
         // Store change token in couch before creating token event
         let clearStoredToken;
-        if (couch && changeAmount > 0) {
-            clearStoredToken = await couch.store(change);
+        if (options?.couch && changeAmount > 0) {
+            clearStoredToken = await options.couch.store(change);
         }
         try {
             // create a new token event if needed
@@ -105,11 +157,11 @@ export function CompleteSpend(spent, change, couch) {
                 ? await WalletTokenFactory.create(change, spent.map((e) => e.id)).sign(signer)
                 : undefined;
             // Get tokens total amount
-            const total = sumProofs(unlocked.map((s) => getTokenContent(s).proofs).flat());
+            const total = sumProofs(unlocked.map((s) => getTokenContent(s).proofs).flat()).toNumber();
             // calculate the amount that was spent
             const diff = total - changeAmount;
-            // sign delete and token
-            const deleteEvent = await DeleteFactory.fromEvents(spent).sign(signer);
+            // optionally sign a delete event for the spent tokens
+            const deleteEvent = createDeleteEvents ? await DeleteFactory.fromEvents(spent).sign(signer) : undefined;
             // create a history entry
             const history = await WalletHistoryFactory.create({
                 direction: "out",
@@ -130,8 +182,13 @@ export function CompleteSpend(spent, change, couch) {
         }
     };
 }
-/** Combines all unlocked token events into a single event per mint */
+/**
+ * Combines all unlocked token events into a single event per mint
+ * @param options.createDeleteEvents whether to publish a single batched NIP-09 delete event for the old
+ *   token events (default true). The new token events always reference the old ids in their `del` field.
+ */
 export function ConsolidateTokens(options) {
+    const createDeleteEvents = options?.createDeleteEvents ?? true;
     return async ({ events, signer, self, user, publish }) => {
         if (!signer)
             throw new Error("Missing signer");
@@ -148,8 +205,19 @@ export function ConsolidateTokens(options) {
                 }
             }
         }
-        // Collect unlocked tokens
-        const unlockedTokens = tokens.filter(isTokenContentUnlocked);
+        // Collect the ids that other token events have already marked as deleted (public `del` tags merged with
+        // the decrypted content). Those proofs are most likely already spent at the mint, so consolidating them
+        // would fail the state check (or repackage spent proofs); exclude them just like {@link RolloverTokens}.
+        const deleted = new Set();
+        for (const token of tokens) {
+            for (const id of getTokenDeletedIds(token))
+                deleted.add(id);
+            if (isTokenContentUnlocked(token))
+                for (const id of getTokenContent(token).del)
+                    deleted.add(id);
+        }
+        // Collect unlocked, not-yet-deleted tokens
+        const unlockedTokens = tokens.filter(isTokenContentUnlocked).filter((token) => !deleted.has(token.id));
         // group tokens by mint
         const byMint = unlockedTokens.reduce((map, token) => {
             const mint = getTokenContent(token).mint;
@@ -158,50 +226,190 @@ export function ConsolidateTokens(options) {
             map.get(mint).push(token);
             return map;
         }, new Map());
+        // Collect the new consolidated token events and the old tokens to delete across all mints,
+        // so the old tokens can be removed with a single batched delete event instead of one per mint
+        const newTokenEvents = [];
+        const deletedTokens = [];
         // loop over each mint and consolidate proofs
         for (const [mint, tokens] of byMint) {
+            // Skip mints that already have a single token event (nothing to consolidate)
+            if (tokens.length < 2)
+                continue;
             // get all tokens proofs
             const proofs = tokens
                 .map((token) => getTokenContent(token).proofs)
                 .flat()
                 // filter out duplicate proofs
                 .filter(ignoreDuplicateProofs());
-            // If there are no proofs, just delete the old tokens without interacting with the mint
+            // If there are no proofs, just queue the old tokens for deletion without interacting with the mint
             if (proofs.length === 0) {
-                const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
-                await publish(deleteEvent, wallet.relays);
+                deletedTokens.push(...tokens);
                 continue;
             }
             // Only interact with the mint if there are proofs to check
-            const cashuWallet = new Wallet(mint);
-            await cashuWallet.loadMint();
+            const cashuWallet = await loadCashuWallet(mint, { getCashuWallet: options?.getCashuWallet });
             // NOTE: this assumes that the states array is the same length and order as the proofs array
             const states = await cashuWallet.checkProofsStates(proofs);
             const notSpent = proofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
             // Only create a token event if there are unspent proofs
-            const tokenEvent = notSpent.length > 0
-                ? await WalletTokenFactory.create({ mint, proofs: notSpent }, tokens.map((t) => t.id)).sign(signer)
-                : undefined;
-            // create delete event
-            const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
-            // Publish events
-            await publish([tokenEvent, deleteEvent].filter((e) => !!e), wallet.relays);
+            if (notSpent.length > 0)
+                newTokenEvents.push(await WalletTokenFactory.create({ mint, proofs: notSpent }, tokens.map((t) => t.id)).sign(signer));
+            // Queue the old tokens for the batched delete
+            deletedTokens.push(...tokens);
+        }
+        // Nothing to consolidate
+        if (deletedTokens.length === 0)
+            return;
+        // Optionally create a single delete event for all of the old tokens across every mint
+        const deleteEvent = createDeleteEvents ? await DeleteFactory.fromEvents(deletedTokens).sign(signer) : undefined;
+        // Publish the new token events and the single batched delete event together
+        await publish([...newTokenEvents, deleteEvent].filter((e) => !!e), wallet.relays);
+    };
+}
+/**
+ * Rolls every unlocked token over to a fresh cashu token. For each mint the proofs are swapped at the mint
+ * (rotating the secrets) and a single new token event is created whose `del` field references the
+ * rolled-over token events. Token events that another token has already marked as deleted are skipped so a
+ * repeated rollover does not try to swap already-spent proofs.
+ *
+ * To keep signer operations to a minimum, every new token event is published together with a *single*
+ * batched NIP-09 delete event covering the rolled-over token events across *all* mints — never one delete
+ * per mint.
+ *
+ * @param options.createDeleteEvents whether to publish the single batched NIP-09 delete event (default true).
+ *   The new token events always reference the old ids in their `del` field, so the wallet can reconcile its
+ *   balance without the delete event; skipping it leaves the spent token events on relays until
+ *   {@link CleanupDeletedTokens} removes them.
+ * @param options.couch optional couch used to keep each fresh token safe until its token event is published
+ */
+export function RolloverTokens(options) {
+    const createDeleteEvents = options?.createDeleteEvents ?? true;
+    return async ({ events, signer, self, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
+        const wallet = await getUnlockedWallet(user, signer);
+        const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
+        // Unlock tokens if requested
+        if (options?.unlockTokens) {
+            for (const token of tokens) {
+                if (!isTokenContentUnlocked(token)) {
+                    try {
+                        await unlockTokenContent(token, signer);
+                    }
+                    catch { }
+                }
+            }
         }
+        // Collect the ids that other token events have already marked as deleted (public `del` tags merged with
+        // the decrypted content). With delete events disabled the rolled-over token events stay in the store, so
+        // they must be excluded here or a later rollover would try to swap their already-spent proofs.
+        const deleted = new Set();
+        for (const token of tokens) {
+            for (const id of getTokenDeletedIds(token))
+                deleted.add(id);
+            if (isTokenContentUnlocked(token))
+                for (const id of getTokenContent(token).del)
+                    deleted.add(id);
+        }
+        // Group the unlocked, not-yet-deleted token events by mint
+        const byMint = new Map();
+        for (const token of tokens) {
+            if (!isTokenContentUnlocked(token) || deleted.has(token.id))
+                continue;
+            const mint = getTokenContent(token).mint;
+            if (!byMint.has(mint))
+                byMint.set(mint, []);
+            byMint.get(mint).push(token);
+        }
+        // Collect the old tokens to delete across all successfully published mints, so they can be removed with
+        // a single batched delete event instead of one per mint
+        const deletedTokens = [];
+        // loop over each mint and swap its proofs for fresh ones
+        for (const [mint, mintTokens] of byMint) {
+            // gather every proof across the mint's token events, ignoring duplicates
+            const proofs = mintTokens.flatMap((token) => getTokenContent(token).proofs).filter(ignoreDuplicateProofs());
+            if (proofs.length === 0)
+                continue;
+            // The unit the tokens are denominated in (cashu-ts rejects a token whose unit does not match the wallet)
+            const unit = getTokenContent(mintTokens[0]).unit ?? "sat";
+            // Swap the proofs for fresh ones at the mint (the mint marks the old proofs spent)
+            const cashuWallet = await loadCashuWallet(mint, { getCashuWallet: options?.getCashuWallet });
+            const freshProofs = await cashuWallet.ops.receive({ mint, proofs: normalizeProofAmounts(proofs), unit }).run();
+            const freshToken = { mint, proofs: freshProofs, unit };
+            // Keep the fresh token in the couch until its token event is published
+            const clear = await options?.couch?.store(freshToken);
+            // Create the new token event (the rolled-over token ids are recorded in its `del` field)
+            const tokenEvent = await WalletTokenFactory.create(freshToken, mintTokens.map((t) => t.id)).sign(signer);
+            await publish([tokenEvent], wallet.relays);
+            await clear?.();
+            // Queue the old tokens for the single batched delete
+            deletedTokens.push(...mintTokens);
+        }
+        // Nothing to roll over
+        if (deletedTokens.length === 0)
+            return;
+        // Optionally create a SINGLE delete event for all of the rolled-over tokens across every mint
+        const deleteEvent = createDeleteEvents ? await DeleteFactory.fromEvents(deletedTokens).sign(signer) : undefined;
+        if (deleteEvent)
+            await publish([deleteEvent], wallet.relays);
     };
 }
 /**
- * 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
+ * Detects token events that have been marked as deleted by a newer token event's `del` field but are
+ * still present, and publishes a single NIP-09 delete event for them. Use this to clean up the old
+ * token events left behind when operations run with `createDeleteEvents: false`, batching what would
+ * otherwise be many per-operation delete events into a single signing operation.
+ */
+export function CleanupDeletedTokens() {
+    return async ({ events, signer, self, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
+        const wallet = await getUnlockedWallet(user, signer);
+        const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
+        // Unlock tokens so their `del` references can be read
+        for (const token of tokens) {
+            if (!isTokenContentUnlocked(token)) {
+                try {
+                    await unlockTokenContent(token, signer);
+                }
+                catch { }
+            }
+        }
+        // Collect the ids that newer token events have marked as deleted, merging the public `del` tags
+        // (no decryption needed) with the decrypted content for events that only store the ids there
+        const deleted = new Set();
+        for (const token of tokens) {
+            for (const id of getTokenDeletedIds(token))
+                deleted.add(id);
+            if (isTokenContentUnlocked(token))
+                for (const id of getTokenContent(token).del)
+                    deleted.add(id);
+        }
+        // Find token events that are marked deleted but still present in the store
+        const stale = tokens.filter((token) => deleted.has(token.id));
+        if (stale.length === 0)
+            return;
+        // Publish a single delete event for all stale token events
+        const deleteEvent = await DeleteFactory.fromEvents(stale).sign(signer);
+        await publish(deleteEvent, wallet.relays);
+    };
+}
+/**
+ * Recovers tokens from a couch by checking if they exist in the wallet, verifying they are unspent, and
+ * creating token events for any recoverable proofs. Once every token has been processed the couch is
+ * cleared, so tokens that are already in the wallet or have been spent are cleaned out too. Any token
+ * whose recovered token event failed to publish is left in the couch so it can be retried on a later run.
  * @param couch the couch interface to recover tokens from
+ * @param options.getCashuWallet optional provider returning a cached cashu Wallet for a mint
  */
-export function RecoverFromCouch(couch) {
+export function RecoverFromCouch(couch, options) {
     return async ({ events, signer, self, user, publish }) => {
         if (!signer)
             throw new Error("Missing signer");
         const wallet = await getUnlockedWallet(user, signer);
         // Get all tokens from the couch
-        const couchTokens = await couch.getAll();
-        if (couchTokens.length === 0)
+        const tokens = await couch.getAll();
+        if (tokens.length === 0)
             return; // No tokens to recover
         // Get all token events from the wallet
         const walletTokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
@@ -214,57 +422,52 @@ export function RecoverFromCouch(couch) {
                 catch { }
             }
         }
-        // Collect all proofs from wallet tokens
-        const walletProofs = walletTokens
-            .filter(isTokenContentUnlocked)
-            .map((token) => getTokenContent(token).proofs)
-            .flat();
-        // Create a set of seen proof UIDs from wallet
+        // Create a set of proof UIDs already held by the wallet so we never recover a duplicate
         const seenProofUIDs = new Set();
-        walletProofs.forEach((proof) => {
-            seenProofUIDs.add(getProofUID(proof));
-        });
-        // Group couch tokens by mint
-        const couchTokensByMint = new Map();
-        for (const token of couchTokens) {
-            if (!couchTokensByMint.has(token.mint)) {
-                couchTokensByMint.set(token.mint, []);
-            }
-            couchTokensByMint.get(token.mint).push(token);
-        }
-        // Process each mint group
-        for (const [mint, tokens] of couchTokensByMint) {
-            // Get all proofs from couch tokens for this mint
-            const couchProofs = tokens.flatMap((token) => token.proofs);
-            // Filter out proofs that are already in the wallet
-            const newProofs = couchProofs.filter((proof) => {
+        for (const token of walletTokens.filter(isTokenContentUnlocked))
+            for (const proof of getTokenContent(token).proofs)
+                seenProofUIDs.add(getProofUID(proof));
+        // Tokens whose recovered token event failed to publish — kept in the couch for a later retry
+        const failed = new Set();
+        // Recover every token first, so we don't clear the couch until all recoverable proofs are published
+        for (const token of tokens) {
+            // Skip proofs that are already in the wallet (or were recovered from an earlier token this run)
+            const newProofs = token.proofs.filter((proof) => {
                 const uid = getProofUID(proof);
                 if (seenProofUIDs.has(uid))
                     return false;
                 seenProofUIDs.add(uid);
                 return true;
             });
+            // Nothing new to publish — already in the wallet or recovered earlier; cleared at the end
             if (newProofs.length === 0)
-                continue; // No new proofs to recover
-            // Check if proofs are unspent from the mint
-            const cashuWallet = new Wallet(mint);
-            await cashuWallet.loadMint();
+                continue;
+            // Keep only the proofs the mint reports as unspent
+            const cashuWallet = await loadCashuWallet(token.mint, { getCashuWallet: options?.getCashuWallet });
             const states = await cashuWallet.checkProofsStates(newProofs);
             const unspentProofs = newProofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
+            // No unspent proofs to publish — fully spent leftovers; cleared at the end
             if (unspentProofs.length === 0)
-                continue; // No unspent proofs to recover
-            // Create a token event with the recovered proofs
-            const recoveredToken = {
-                mint,
-                proofs: unspentProofs,
-                unit: tokens[0]?.unit,
-            };
+                continue;
+            // Create and publish a token event for the recovered proofs
+            const recoveredToken = { mint: token.mint, proofs: unspentProofs, unit: token.unit };
             const tokenEvent = await WalletTokenFactory.create(recoveredToken).sign(signer);
-            // Publish the token event
-            await publish(tokenEvent, wallet.relays);
-            // Clear the token from the couch
-            await couch.clear();
+            try {
+                await publish(tokenEvent, wallet.relays);
+            }
+            catch {
+                // Keep this token so its proofs can be recovered on a later run
+                failed.add(token);
+            }
         }
+        // Recovery complete: clear the couch. If every recovery published, clear it all in one call;
+        // otherwise remove each processed token individually and leave the failed ones for a retry.
+        if (failed.size === 0)
+            await couch.clear();
+        else
+            for (const token of tokens)
+                if (!failed.has(token))
+                    await couch.remove(token);
     };
 }
 /**
@@ -301,7 +504,7 @@ export function RecoverFromCouch(couch) {
  * }, { couch, tokenSelection: myCustomSelectionFunction });
  */
 export function TokensOperation(minAmount, operation, options) {
-    const { mint, couch, tokenSelection = dumbTokenSelection } = options;
+    const { mint, couch, wallet, getCashuWallet, createDeleteEvents, tokenSelection = dumbTokenSelection } = options;
     return async ({ events, self, user, signer, run }) => {
         if (!signer)
             throw new Error("Missing signer");
@@ -347,17 +550,16 @@ export function TokensOperation(minAmount, operation, options) {
             if (tokenMint !== selectedMint)
                 throw new Error(`Selected tokens must be from the same mint. Found ${tokenMint} and ${selectedMint}`);
         }
-        // Store selected tokens in couch for safety
+        // Store selected tokens in couch for safety (normalize to cashu Amount proofs for encoding)
         const selectedToken = {
             mint: selectedMint,
-            proofs: selectedProofs,
+            proofs: normalizeProofAmounts(selectedProofs),
             unit: "sat",
         };
         const clearStoredToken = await couch.store(selectedToken);
         try {
             // Create cashu wallet for the mint
-            const cashuWallet = new Wallet(selectedMint);
-            await cashuWallet.loadMint();
+            const cashuWallet = await loadCashuWallet(selectedMint, { wallet, getCashuWallet });
             // Perform the async operation
             // All selected proofs are considered used - the operation only needs to return change (if any)
             const { change } = await operation({
@@ -373,7 +575,7 @@ export function TokensOperation(minAmount, operation, options) {
             };
             // Complete the spend with change (if any)
             // If there's no change, all selected proofs were spent
-            await run(CompleteSpend, selectedTokenEvents, changeToken, couch);
+            await run(CompleteSpend, selectedTokenEvents, changeToken, { couch, createDeleteEvents });
             // Clear the stored token from the couch after successful completion
             await clearStoredToken();
         }

package/dist/casts/nutzap.d.ts

@@ -11,7 +11,7 @@ export declare class Nutzap extends EventCast<NutzapEvent> {
     get sender(): import("applesauce-core/casts").User;
     get comment(): string | undefined;
     /** The pointer to the event that was zapped */
-    get pointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer | undefined;
+    get zapPointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer | undefined;
     /** The event that was zapped */
     get zapped$(): import("applesauce-core").ChainableObservable<NostrEvent | undefined>;
 }

package/dist/casts/nutzap.js

@@ -28,11 +28,11 @@ export class Nutzap extends EventCast {
         return getNutzapComment(this.event);
     }
     /** The pointer to the event that was zapped */
-    get pointer() {
+    get zapPointer() {
         return getNutzapAddressPointer(this.event) ?? getNutzapEventPointer(this.event);
     }
     /** The event that was zapped */
     get zapped$() {
-        return this.$$ref("zapped$", (store) => (this.pointer ? store.event(this.pointer) : of(undefined)));
+        return this.$$ref("zapped$", (store) => (this.zapPointer ? store.event(this.zapPointer) : of(undefined)));
     }
 }

package/dist/casts/wallet-token.d.ts

@@ -6,25 +6,16 @@ import { WalletTokenEvent } from "../helpers/tokens.js";
 export declare class WalletToken extends EventCast<WalletTokenEvent> {
     constructor(event: NostrEvent, store: CastRefEventStore);
     get meta(): import("../helpers/tokens.js").TokenContent | undefined;
-    get proofs(): {
-        amount: number;
-        secret: string;
-        C: string;
-        id: string;
-    }[] | undefined;
+    get proofs(): import("../helpers/cashu.js").StoredProof[] | undefined;
     get mint(): string | undefined;
     get amount(): number | undefined;
-    get deleted(): string[] | undefined;
+    /** The token event ids this token marked as deleted, merging the public `del` tags with the encrypted content */
+    get deleted(): string[];
     get unlocked(): boolean;
     unlock(signer: HiddenContentSigner): Promise<import("../helpers/tokens.js").TokenContent>;
     get meta$(): import("applesauce-core/observable").ChainableObservable<import("../helpers/tokens.js").TokenContent>;
     get mint$(): import("applesauce-core/observable").ChainableObservable<string>;
-    get proofs$(): import("applesauce-core/observable").ChainableObservable<{
-        amount: number;
-        secret: string;
-        C: string;
-        id: string;
-    }[]>;
+    get proofs$(): import("applesauce-core/observable").ChainableObservable<import("../helpers/cashu.js").StoredProof[]>;
     get amount$(): import("applesauce-core/observable").ChainableObservable<number>;
     get deleted$(): import("applesauce-core/observable").ChainableObservable<string[]>;
 }

package/dist/casts/wallet-token.js

@@ -3,7 +3,7 @@ import { EventCast } from "applesauce-common/casts";
 import { defined, watchEventUpdates } from "applesauce-core/observable";
 import { of } from "rxjs";
 import { map } from "rxjs/operators";
-import { getTokenContent, isTokenContentUnlocked, isValidWalletToken, unlockTokenContent, } from "../helpers/tokens.js";
+import { getTokenContent, getTokenDeletedIds, isTokenContentUnlocked, isValidWalletToken, unlockTokenContent, } from "../helpers/tokens.js";
 /** A cast for a NIP-60 wallet token event */
 export class WalletToken extends EventCast {
     constructor(event, store) {
@@ -22,10 +22,11 @@ export class WalletToken extends EventCast {
         return this.meta?.mint;
     }
     get amount() {
-        return this.proofs && sumProofs(this.proofs);
+        return this.proofs && sumProofs(this.proofs).toNumber();
     }
+    /** The token event ids this token marked as deleted, merging the public `del` tags with the encrypted content */
     get deleted() {
-        return this.meta?.del;
+        return Array.from(new Set([...getTokenDeletedIds(this.event), ...(this.meta?.del ?? [])]));
     }
     // Unlocking pattern
     get unlocked() {
@@ -45,9 +46,12 @@ export class WalletToken extends EventCast {
         return this.$$ref("proofs$", () => this.meta$.pipe(map((meta) => meta?.proofs)));
     }
     get amount$() {
-        return this.$$ref("amount$", () => this.proofs$.pipe(map(sumProofs)));
+        return this.$$ref("amount$", () => this.proofs$.pipe(map((proofs) => sumProofs(proofs).toNumber())));
     }
     get deleted$() {
-        return this.$$ref("deleted$", () => this.meta$.pipe(map((meta) => meta?.del)));
+        return this.$$ref("deleted$", () => of(this.event).pipe(watchEventUpdates(this.store), map((event) => {
+            const content = event && isTokenContentUnlocked(event) ? getTokenContent(event).del : [];
+            return Array.from(new Set([...getTokenDeletedIds(this.event), ...content]));
+        })));
     }
 }

package/dist/casts/wallet.d.ts

@@ -16,6 +16,8 @@ export declare class Wallet extends EventCast<WalletEvent> {
         privateKey: Uint8Array | null;
         relays: string[];
     }>;
+    /** Emits whether the wallet is unlocked, reacting to in-place unlock/lock updates */
+    get unlocked$(): import("applesauce-common/observable").ChainableObservable<boolean>;
     get mints$(): import("applesauce-common/observable").ChainableObservable<string[] | undefined>;
     get relays$(): import("applesauce-common/observable").ChainableObservable<string[] | undefined>;
     get balance$(): import("applesauce-common/observable").ChainableObservable<Record<string, number>>;