applesauce-wallet 0.0.0-next-20250314133024 → 0.0.0-next-20250314151125

package/dist/actions/tokens.d.ts

@@ -11,3 +11,4 @@ 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 */

package/dist/actions/tokens.js

@@ -62,3 +62,32 @@ 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
+//     }
+//   };
+// }

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/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-20250314151125",
   "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-20250314151125",
+    "applesauce-core": "0.0.0-next-20250314151125",
+    "applesauce-factory": "0.0.0-next-20250314151125",
     "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-20250314151125",
     "typescript": "^5.7.3",
     "vitest": "^3.0.5"
   },