applesauce-wallet 0.0.0-next-20250314151125 → 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,4 +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 existing token events into a single event per mint */
+/** 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,32 +63,48 @@ export function CompleteSpend(spent, change) {
         yield signedHistory;
     };
 }
-/** combines all unlocked existing token events into a single event per mint */
-// export function ConsolidateTokens({ ignoreLocked = true }): Action {
-//   return async function* ({ events, factory, self }) {
-//     const tokens = Array.from(events.getAll({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
-//       if (isTokenContentLocked(token)) {
-//         if (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<string, NostrEvent[]>());
-//     for (const [mint, tokens] of byMint) {
-//       const cashuMint = new CashuMint(mint);
-//       const cashuWallet = new CashuWallet(cashuMint);
-//       const proofs = tokens
-//         .map((t) => getTokenContent(t)!.proofs)
-//         .flat()
-//         .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);
-//       // delete old
-//     }
-//   };
-// }
+/** 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet",
-  "version": "0.0.0-next-20250314151125",
+  "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-20250314151125",
-    "applesauce-core": "0.0.0-next-20250314151125",
-    "applesauce-factory": "0.0.0-next-20250314151125",
+    "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-20250314151125",
+    "applesauce-signers": "0.0.0-next-20250315131629",
     "typescript": "^5.7.3",
     "vitest": "^3.0.5"
   },