applesauce-wallet 0.0.0-next-20250314133024 → 0.0.0-next-20250315131629

package/dist/actions/__tests__/tokens.test.d.ts

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

package/dist/actions/__tests__/tokens.test.js

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, vitest } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { ActionHub } from "applesauce-actions";
+import { CheckStateEnum } from "@cashu/cashu-ts";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ConsolidateTokens } from "../tokens.js";
+import { WalletTokenBlueprint } from "../../blueprints/tokens.js";
+import { unlockTokenContent, WALLET_TOKEN_KIND } from "../../helpers/tokens.js";
+// Update the mock to allow controlling the states
+const mockCheckProofsStates = vitest.fn();
+vitest.mock("@cashu/cashu-ts", () => ({
+    CashuMint: vitest.fn(),
+    CashuWallet: vitest.fn().mockImplementation(() => ({
+        checkProofsStates: mockCheckProofsStates,
+    })),
+    CheckStateEnum: { UNSPENT: "UNSPENT", SPENT: "SPENT" },
+}));
+const user = new FakeUser();
+const testMint = "https://mint.test.com";
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+    // Reset the mock before each test
+    mockCheckProofsStates.mockReset();
+});
+describe("ConsolidateTokens", () => {
+    it("should combine multiple token events into a single event", async () => {
+        // Set all proofs to be unspent
+        mockCheckProofsStates.mockResolvedValue([{ state: CheckStateEnum.UNSPENT }, { state: CheckStateEnum.UNSPENT }]);
+        // Create two token events with different proofs
+        const token1 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [{ amount: 10, secret: "secret1", C: "C", id: "id" }],
+        }));
+        const token2 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [{ amount: 20, secret: "secret2", C: "C", id: "id" }],
+        }));
+        // Add tokens to event store
+        events.add(token1);
+        events.add(token2);
+        // Run consolidate action
+        const spy = subscribeSpyTo(hub.exec(ConsolidateTokens));
+        await spy.onComplete();
+        // First event should be the new consolidated token
+        expect(spy.getValueAt(0).kind).toBe(WALLET_TOKEN_KIND);
+        // Extract token content and verify proofs were combined
+        const content = await unlockTokenContent(spy.getValueAt(0), user);
+        expect(content.proofs).toHaveLength(2);
+        expect(content.proofs).toEqual(expect.arrayContaining([
+            expect.objectContaining({ amount: 10, secret: "secret1" }),
+            expect.objectContaining({ amount: 20, secret: "secret2" }),
+        ]));
+        expect(content.mint).toBe(testMint);
+    });
+    it("should handle duplicate proofs", async () => {
+        // Set all proofs to be unspent
+        mockCheckProofsStates.mockResolvedValue([{ state: CheckStateEnum.UNSPENT }, { state: CheckStateEnum.UNSPENT }]);
+        // Create two token events with different proofs
+        const token1 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [{ amount: 10, secret: "secret1", C: "C", id: "id" }],
+        }));
+        const token2 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [
+                { amount: 20, secret: "secret2", C: "C", id: "id" },
+                { amount: 10, secret: "secret1", C: "C", id: "id" },
+            ],
+        }));
+        // Add tokens to event store
+        events.add(token1);
+        events.add(token2);
+        // Run consolidate action
+        const spy = subscribeSpyTo(hub.exec(ConsolidateTokens));
+        await spy.onComplete();
+        // First event should be the new consolidated token
+        expect(spy.getValueAt(0).kind).toBe(WALLET_TOKEN_KIND);
+        // Extract token content and verify proofs were combined
+        const content = await unlockTokenContent(spy.getValueAt(0), user);
+        expect(content.proofs).toHaveLength(2);
+        expect(content.proofs).toEqual(expect.arrayContaining([
+            expect.objectContaining({ amount: 10, secret: "secret1" }),
+            expect.objectContaining({ amount: 20, secret: "secret2" }),
+        ]));
+        expect(content.mint).toBe(testMint);
+    });
+    it("should filter out spent proofs", async () => {
+        // Create token events with multiple proofs
+        const token1 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [
+                { amount: 10, secret: "secret1", C: "C", id: "id" },
+                { amount: 20, secret: "secret2", C: "C", id: "id" },
+            ],
+        }, []));
+        const token2 = await factory.sign(await factory.create(WalletTokenBlueprint, {
+            mint: testMint,
+            proofs: [
+                { amount: 30, secret: "secret3", C: "C", id: "id" },
+                { amount: 40, secret: "secret4", C: "C", id: "id" },
+            ],
+        }, []));
+        // Add tokens to event store
+        events.add(token1);
+        events.add(token2);
+        // Mock some proofs as spent
+        mockCheckProofsStates.mockResolvedValue([
+            { state: CheckStateEnum.UNSPENT }, // secret1
+            { state: CheckStateEnum.SPENT }, // secret2
+            { state: CheckStateEnum.SPENT }, // secret3
+            { state: CheckStateEnum.UNSPENT }, // secret4
+        ]);
+        // Run consolidate action
+        const spy = subscribeSpyTo(hub.exec(ConsolidateTokens));
+        await spy.onComplete();
+        // Verify the consolidated token only contains unspent proofs
+        const content = await unlockTokenContent(spy.getValueAt(0), user);
+        expect(content.proofs).toHaveLength(2);
+        expect(content.proofs).toEqual(expect.arrayContaining([
+            expect.objectContaining({ amount: 10, secret: "secret1" }),
+            expect.objectContaining({ amount: 40, secret: "secret4" }),
+        ]));
+        expect(content.mint).toBe(testMint);
+        // Verify checkProofsStates was called with all proofs
+        expect(mockCheckProofsStates).toHaveBeenCalledWith(expect.arrayContaining([
+            expect.objectContaining({ amount: 10, secret: "secret1" }),
+            expect.objectContaining({ amount: 20, secret: "secret2" }),
+            expect.objectContaining({ amount: 30, secret: "secret3" }),
+            expect.objectContaining({ amount: 40, secret: "secret4" }),
+        ]));
+    });
+});

package/dist/actions/tokens.d.ts

@@ -11,3 +11,7 @@ export declare function ReceiveToken(token: Token, redeemed?: string[], fee?: nu
 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;
+/** Combines all unlocked token events into a single event per mint */
+export declare function ConsolidateTokens(opts?: {
+    ignoreLocked?: boolean;
+}): Action;

package/dist/actions/tokens.js

@@ -1,5 +1,6 @@
+import { CashuMint, CashuWallet, CheckStateEnum } from "@cashu/cashu-ts";
 import { DeleteBlueprint } from "applesauce-factory/blueprints";
-import { getTokenContent, isTokenContentLocked } from "../helpers/tokens.js";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
 import { WalletTokenBlueprint } from "../blueprints/tokens.js";
 import { WalletHistoryBlueprint } from "../blueprints/history.js";
 /**
@@ -62,3 +63,48 @@ export function CompleteSpend(spent, change) {
         yield signedHistory;
     };
 }
+/** Combines all unlocked token events into a single event per mint */
+export function ConsolidateTokens(opts) {
+    return async function* ({ events, factory, self }) {
+        const tokens = Array.from(events.getAll({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
+            if (isTokenContentLocked(token)) {
+                if (opts?.ignoreLocked)
+                    return false;
+                else
+                    throw new Error("Token is locked");
+            }
+            else
+                return true;
+        });
+        const byMint = tokens.reduce((map, token) => {
+            const mint = getTokenContent(token).mint;
+            if (!map.has(mint))
+                map.set(mint, []);
+            map.get(mint).push(token);
+            return map;
+        }, new Map());
+        // loop over each mint and consolidate proofs
+        for (const [mint, tokens] of byMint) {
+            const cashuMint = new CashuMint(mint);
+            const cashuWallet = new CashuWallet(cashuMint);
+            // get all tokens proofs
+            const proofs = tokens
+                .map((t) => getTokenContent(t).proofs)
+                .flat()
+                // filter out duplicate proofs
+                .filter(ignoreDuplicateProofs());
+            // 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);
+            // create delete and token event
+            const deleteDraft = await factory.create(DeleteBlueprint, tokens);
+            const tokenDraft = await factory.create(WalletTokenBlueprint, { mint, proofs: notSpent }, tokens.map((t) => t.id));
+            // sign events
+            const signedToken = await factory.sign(tokenDraft);
+            const signedDelete = await factory.sign(deleteDraft);
+            // publish events for mint
+            yield signedToken;
+            yield signedDelete;
+        }
+    };
+}

package/dist/helpers/__tests__/tokens.test.js

@@ -3,7 +3,7 @@ import { EventFactory } from "applesauce-factory";
 import { FakeUser } from "../../__tests__/fake-user.js";
 import { WalletTokenBlueprint } from "../../blueprints/tokens.js";
 import { decodeTokenFromEmojiString, dumbTokenSelection, encodeTokenToEmoji, unlockTokenContent } from "../tokens.js";
-import { HiddenContentSymbol } from "applesauce-core/helpers";
+import { HiddenContentSymbol, unixNow } from "applesauce-core/helpers";
 const user = new FakeUser();
 const factory = new EventFactory({ signer: user });
 describe("dumbTokenSelection", () => {
@@ -20,7 +20,7 @@ describe("dumbTokenSelection", () => {
         bDraft.created_at -= 60 * 60 * 7;
         const b = await user.signEvent(bDraft);
         await unlockTokenContent(b, user);
-        expect(dumbTokenSelection([a, b], 40)).toEqual([b]);
+        expect(dumbTokenSelection([a, b], 40).events).toEqual([b]);
     });
     it("should select enough tokens to total min amount", async () => {
         const a = await user.signEvent(await factory.create(WalletTokenBlueprint, {
@@ -35,7 +35,7 @@ describe("dumbTokenSelection", () => {
         bDraft.created_at -= 60 * 60 * 7;
         const b = await user.signEvent(bDraft);
         await unlockTokenContent(b, user);
-        expect(dumbTokenSelection([a, b], 120)).toEqual(expect.arrayContaining([a, b]));
+        expect(dumbTokenSelection([a, b], 120).events).toEqual(expect.arrayContaining([a, b]));
     });
     it("should throw if not enough funds", async () => {
         const a = await user.signEvent(await factory.create(WalletTokenBlueprint, {
@@ -59,7 +59,47 @@ describe("dumbTokenSelection", () => {
         const b = await user.signEvent(bDraft);
         // manually remove the hidden content to lock it again
         Reflect.deleteProperty(b, HiddenContentSymbol);
-        expect(dumbTokenSelection([a, b], 20)).toEqual([a]);
+        expect(dumbTokenSelection([a, b], 20).events).toEqual([a]);
+    });
+    it("should ignore duplicate proofs", async () => {
+        const a = await user.signEvent(await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        // create a second event with the same proofs
+        const b = await user.signEvent(await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        expect(() => dumbTokenSelection([a, b], 150)).toThrow();
+    });
+    it("should include duplicate token events and ignore duplicate proofs", async () => {
+        const A = { secret: "A", C: "A", id: "A", amount: 100 };
+        const a = await user.signEvent({
+            ...(await factory.create(WalletTokenBlueprint, {
+                mint: "https://money.com",
+                proofs: [A],
+            })),
+            // make event older
+            created_at: unixNow() - 100,
+        });
+        // create a second event with the same proofs
+        const a2 = await user.signEvent({
+            ...(await factory.create(WalletTokenBlueprint, {
+                mint: "https://money.com",
+                proofs: [A],
+            })),
+            // make event older
+            created_at: a.created_at - 200,
+        });
+        const B = { secret: "B", C: "B", id: "B", amount: 50 };
+        const b = await user.signEvent(await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [B],
+        }));
+        const result = dumbTokenSelection([a, a2, b], 150);
+        expect(result.events.map((e) => e.id)).toEqual(expect.arrayContaining([a.id, a2.id, b.id]));
+        expect(result.proofs).toEqual([A, B]);
     });
 });
 describe("encodeTokenToEmoji", () => {

package/dist/helpers/tokens.d.ts

@@ -1,6 +1,10 @@
-import { Token } from "@cashu/cashu-ts";
+import { Proof, Token } from "@cashu/cashu-ts";
 import { HiddenContentSigner } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
+/** Internal method for creating a unique id for each proof */
+export declare function getProofUID(proof: Proof): string;
+/** Internal method to filter out duplicate proofs */
+export declare function ignoreDuplicateProofs(seen?: Set<string>): (proof: Proof) => boolean;
 export declare const WALLET_TOKEN_KIND = 7375;
 export type TokenContent = {
     /** Cashu mint for the proofs */
@@ -18,7 +22,6 @@ export type TokenContent = {
     del: string[];
 };
 export declare const TokenContentSymbol: unique symbol;
-export declare const TokenProofsTotalSymbol: unique symbol;
 /**
  * Returns the decrypted and parsed details of a 7375 token event
  * @throws
@@ -30,13 +33,19 @@ export declare function isTokenContentLocked(token: NostrEvent): boolean;
 export declare function unlockTokenContent(token: NostrEvent, signer: HiddenContentSigner): Promise<TokenContent>;
 /** Removes the unencrypted hidden content */
 export declare function lockTokenContent(token: NostrEvent): void;
-/** Gets the totaled amount of proofs in a token event */
+/**
+ * Gets the totaled amount of proofs in a token event
+ * @param token The token event to calculate the total
+ */
 export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
 /**
- * Selects oldest tokens that total up to more than the min amount
+ * Selects oldest tokens and proofs that total up to more than the min amount
  * @throws
  */
-export declare function dumbTokenSelection(tokens: NostrEvent[], minAmount: number, mint?: string): import("nostr-tools").Event[];
+export declare function dumbTokenSelection(tokens: NostrEvent[], minAmount: number, mint?: string): {
+    events: NostrEvent[];
+    proofs: Proof[];
+};
 /**
  * Returns a decoded cashu token inside an unicode emoji
  * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387

package/dist/helpers/tokens.js

@@ -1,8 +1,23 @@
 import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
 import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, unlockHiddenContent, } from "applesauce-core/helpers";
+/** 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 WALLET_TOKEN_KIND = 7375;
 export const TokenContentSymbol = Symbol.for("token-content");
-export const TokenProofsTotalSymbol = Symbol.for("token-proofs-total");
 /**
  * Returns the decrypted and parsed details of a 7375 token event
  * @throws
@@ -37,20 +52,20 @@ export async function unlockTokenContent(token, signer) {
 /** Removes the unencrypted hidden content */
 export function lockTokenContent(token) {
     Reflect.deleteProperty(token, TokenContentSymbol);
-    Reflect.deleteProperty(token, TokenProofsTotalSymbol);
     lockHiddenContent(token);
 }
-/** Gets the totaled amount of proofs in a token event */
+/**
+ * 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;
-    return getOrComputeCachedValue(token, TokenProofsTotalSymbol, () => {
-        const content = getTokenContent(token);
-        return content.proofs.reduce((t, p) => t + p.amount, 0);
-    });
+    const content = getTokenContent(token);
+    return content.proofs.reduce((t, p) => t + p.amount, 0);
 }
 /**
- * Selects oldest tokens that total up to more than the min amount
+ * Selects oldest tokens and proofs that total up to more than the min amount
  * @throws
  */
 export function dumbTokenSelection(tokens, minAmount, mint) {
@@ -58,19 +73,21 @@ export function dumbTokenSelection(tokens, minAmount, mint) {
     const sorted = tokens
         .filter((token) => !isTokenContentLocked(token) && (mint ? getTokenContent(token).mint === mint : true))
         .sort((a, b) => b.created_at - a.created_at);
-    const total = sorted.reduce((t, token) => t + getTokenProofsTotal(token), 0);
-    if (total < minAmount)
-        throw new Error("Insufficient funds");
     let amount = 0;
-    const selected = [];
+    const seen = new Set();
+    const selectedTokens = [];
+    const selectedProofs = [];
     while (amount < minAmount) {
         const token = sorted.pop();
         if (!token)
-            throw new Error("Ran out of tokens");
-        selected.push(token);
-        amount += getTokenProofsTotal(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 selected;
+    return { events: selectedTokens, proofs: selectedProofs };
 }
 /**
  * Returns a decoded cashu token inside an unicode emoji

package/dist/operations/event/tokens.js

@@ -9,6 +9,10 @@ export function setTokenContent(token, del = []) {
         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,

package/dist/queries/tokens.js

@@ -1,5 +1,5 @@
 import { combineLatest, filter, map, startWith } from "rxjs";
-import { getTokenContent, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
 /** removes deleted events from sorted array */
 function filterDeleted(tokens) {
     const deleted = new Set();
@@ -50,11 +50,15 @@ export function WalletBalanceQuery(pubkey) {
             // filter out deleted tokens
             map(filterDeleted), 
             // map tokens to totals
-            map((tokens) => tokens.reduce((totals, token) => {
-                const details = getTokenContent(token);
-                const total = details.proofs.reduce((t, p) => t + p.amount, 0);
-                return { ...totals, [details.mint]: (totals[details.mint] ?? 0) + total };
-            }, {})));
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet",
-  "version": "0.0.0-next-20250314133024",
+  "version": "0.0.0-next-20250315131629",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -80,16 +80,16 @@
     "@cashu/cashu-ts": "2.0.0-rc1",
     "@gandlaf21/bc-ur": "^1.1.12",
     "@noble/hashes": "^1.7.1",
-    "applesauce-actions": "0.0.0-next-20250314133024",
-    "applesauce-core": "0.0.0-next-20250314133024",
-    "applesauce-factory": "0.0.0-next-20250314133024",
+    "applesauce-actions": "0.0.0-next-20250315131629",
+    "applesauce-core": "0.0.0-next-20250315131629",
+    "applesauce-factory": "0.0.0-next-20250315131629",
     "nostr-tools": "^2.10.4",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
-    "applesauce-signers": "0.0.0-next-20250314133024",
+    "applesauce-signers": "0.0.0-next-20250315131629",
     "typescript": "^5.7.3",
     "vitest": "^3.0.5"
   },