applesauce-wallet 0.0.0-next-20250313225050 → 0.0.0-next-20250314151125

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

@@ -6,6 +6,7 @@ import { FakeUser } from "../../__tests__/fake-user.js";
 import { CreateWallet } from "../wallet.js";
 import { WALLET_BACKUP_KIND } from "../../helpers/wallet.js";
 import { unlockHiddenTags } from "applesauce-core/helpers";
+import { lastValueFrom } from "rxjs";
 const user = new FakeUser();
 let events;
 let factory;
@@ -20,13 +21,11 @@ beforeEach(() => {
 describe("CreateWallet", () => {
     it("should publish a wallet backup event", async () => {
         await hub.run(CreateWallet, ["https://mint.money.com"]);
-        expect(publish).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ kind: WALLET_BACKUP_KIND }));
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: WALLET_BACKUP_KIND }));
     });
     it("should publish a wallet event with mints", async () => {
-        await hub.run(CreateWallet, ["https://mint.money.com"]);
-        // @ts-expect-error
-        const walletEvent = publish.mock.calls[1][1];
-        const hiddenTags = await unlockHiddenTags(walletEvent, user);
+        const event = await lastValueFrom(hub.exec(CreateWallet, ["https://mint.money.com"]));
+        const hiddenTags = await unlockHiddenTags(event, user);
         // the second call should be the wallet event
         expect(hiddenTags).toEqual(expect.arrayContaining([["mint", "https://mint.money.com"]]));
     });

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

@@ -8,17 +8,17 @@ import { WalletHistoryBlueprint } from "../blueprints/history.js";
  * @param redeemed an array of nutzap event ids to mark as redeemed
  */
 export function ReceiveToken(token, redeemed, fee) {
-    return async ({ factory, publish }) => {
+    return async function* ({ factory }) {
         const amount = token.proofs.reduce((t, p) => t + p.amount, 0);
         const tokenEvent = await factory.sign(await factory.create(WalletTokenBlueprint, token, []));
         const history = await factory.sign(await factory.create(WalletHistoryBlueprint, { direction: "in", amount, mint: token.mint, created: [tokenEvent.id], fee }, redeemed ?? []));
-        await publish("Save tokens", tokenEvent);
-        await publish("Save transaction", history);
+        yield tokenEvent;
+        yield history;
     };
 }
 /** 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 ({ factory, publish }) => {
+    return async function* ({ factory }) {
         // create a delete event for old tokens
         const deleteDraft = await factory.create(DeleteBlueprint, tokens);
         // create a new token event
@@ -27,13 +27,13 @@ export function RolloverTokens(tokens, token) {
         const signedDelete = await factory.sign(deleteDraft);
         const signedToken = await factory.sign(tokenDraft);
         // publish events
-        await publish("Delete old tokens", signedDelete);
-        await publish("Save new token", signedToken);
+        yield signedDelete;
+        yield signedToken;
     };
 }
 /** An action that deletes old token events and adds a spend history item */
 export function CompleteSpend(spent, change) {
-    return async ({ factory, publish }) => {
+    return async function* ({ factory }) {
         if (spent.length === 0)
             throw new Error("Cant complete spent with no token events");
         if (spent.some((s) => isTokenContentLocked(s)))
@@ -56,9 +56,38 @@ export function CompleteSpend(spent, change) {
         // sign history
         const signedHistory = await factory.sign(history);
         // publish events
-        await publish("Delete old tokens", signedDelete);
+        yield signedDelete;
         if (signedToken)
-            await publish("Save change", signedToken);
-        await publish("Save transaction", signedHistory);
+            yield signedToken;
+        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/actions/wallet.js

@@ -5,19 +5,20 @@ import { isTokenContentLocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../
 import { isHistoryContentLocked, unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
 /** An action that creates a new 17375 wallet event and 375 wallet backup */
 export function CreateWallet(mints, privateKey = generateSecretKey()) {
-    return async ({ events, factory, self, publish }) => {
+    return async function* ({ events, factory, self }) {
         const existing = events.getReplaceable(WALLET_KIND, self);
         if (existing)
             throw new Error("Wallet already exists");
         const wallet = await factory.sign(await factory.create(WalletBlueprint, privateKey, mints));
         const backup = await factory.sign(await factory.create(WalletBackupBlueprint, wallet));
-        await publish("Wallet backup", backup);
-        await publish("Create wallet", wallet);
+        // publish the backup first
+        yield backup;
+        yield wallet;
     };
 }
 /** Unlocks the wallet event and optionally the tokens and history events */
 export function UnlockWallet(unlock) {
-    return async ({ events, self, factory }) => {
+    return async function* ({ events, self, factory }) {
         const signer = factory.context.signer;
         if (!signer)
             throw new Error("Missing signer");

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

@@ -2,8 +2,8 @@ import { describe, expect, it } from "vitest";
 import { EventFactory } from "applesauce-factory";
 import { FakeUser } from "../../__tests__/fake-user.js";
 import { WalletTokenBlueprint } from "../../blueprints/tokens.js";
-import { dumbTokenSelection, unlockTokenContent } from "../tokens.js";
-import { HiddenContentSymbol } from "applesauce-core/helpers";
+import { decodeTokenFromEmojiString, dumbTokenSelection, encodeTokenToEmoji, unlockTokenContent } from "../tokens.js";
+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,6 +59,69 @@ 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", () => {
+    it("should encode token into emoji string", () => {
+        const token = "cashuBo2FteBtodHRwczovL3Rlc3RudXQuY2FzaHUuc3BhY2VhdWNzYXRhdIGiYWlIAJofKTJT5B5hcIGkYWEBYXN4QDdlZDBkMzk3NGQ5ZWM2OTc2YTAzYmZmYjdkMTA4NzIzZTBiMDRjMzRhNDc3MjlmNjMwOGJlODc3OTA2NTY0NDVhY1ghA36iYyOHCe4CnTxzORbcXFVeAbkMUFE6FqPWInujnAOcYWSjYWVYIJmHRwCQ0Uopkd3P5xb0MdcWQEaZz9hXWtcn-FMhZj8LYXNYIF4X9ybXxg5Pp0KSowfu4y_Aovo9iy3TXlLSaKyVJzz2YXJYIC_UFkoC5U9BpSgBTGUQgsjfz_emv5xykDiavZUfRN8E";
+        expect(encodeTokenToEmoji(token).length).toBeGreaterThan(token.length);
+    });
+});
+const emoji = "🥜󠅓󠅑󠅣󠅘󠅥󠄲󠅟󠄢󠄶󠅤󠅕󠄲󠅤󠅟󠅔󠄸󠅂󠅧󠅓󠅪󠅟󠅦󠄼󠄣󠅂󠅜󠅓󠄣󠅂󠅥󠅔󠅈󠅁󠅥󠅉󠄢󠄶󠅪󠅑󠄸󠅅󠅥󠅓󠄣󠄲󠅘󠅉󠄢󠅆󠅘󠅔󠅇󠄾󠅪󠅉󠅈󠅂󠅘󠅔󠄹󠄷󠅙󠅉󠅇󠅜󠄹󠄱󠄺󠅟󠅖󠄻󠅄󠄺󠅄󠄥󠄲󠄥󠅘󠅓󠄹󠄷󠅛󠅉󠅇󠄵󠄲󠅉󠅈󠄾󠄤󠅁󠄴󠅔󠅜󠅊󠄴󠄲󠅛󠄽󠅪󠅛󠄣󠄾󠄷󠅁󠄥󠅊󠅇󠄽󠄢󠄿󠅄󠅓󠄢󠅉󠅄󠄱󠅪󠅉󠅝󠅊󠅝󠅉󠅚󠅔󠅛󠄽󠅄󠄱󠄤󠄾󠅪󠄹󠅪󠅊󠅄󠄲󠅙󠄽󠄴󠅂󠅚󠄽󠅪󠅂󠅘󠄾󠄴󠅓󠄣󠄽󠅚󠅜󠅝󠄾󠅚󠄽󠅧󠄿󠄷󠄺󠅜󠄿󠄴󠅓󠄣󠄿󠅄󠄱󠄢󠄾󠅄󠅉󠄠󠄾󠄴󠅆󠅘󠅉󠄡󠅗󠅘󠄱󠄣󠄦󠅙󠅉󠅩󠄿󠄸󠄳󠅕󠄤󠄳󠅞󠅄󠅨󠅪󠄿󠅂󠅒󠅓󠅈󠄶󠅆󠅕󠄱󠅒󠅛󠄽󠅅󠄶󠄵󠄦󠄶󠅡󠅀󠅇󠄹󠅞󠅥󠅚󠅞󠄱󠄿󠅓󠅉󠅇󠅃󠅚󠅉󠅇󠅆󠅉󠄹󠄺󠅝󠄸󠅂󠅧󠄳󠅁󠄠󠅅󠅟󠅠󠅛󠅔󠄣󠅀󠄥󠅨󠅒󠄠󠄽󠅔󠅓󠅇󠅁󠄵󠅑󠅊󠅪󠄩󠅘󠅈󠅇󠅤󠅓󠅞󠄝󠄶󠄽󠅘󠅊󠅚󠄨󠄼󠅉󠅈󠄾󠅉󠄹󠄶󠄤󠅈󠄩󠅩󠅒󠅈󠅨󠅗󠄥󠅀󠅠󠄠󠄻󠅃󠅟󠅧󠅖󠅥󠄤󠅩󠅏󠄱󠅟󠅦󠅟󠄩󠅙󠅩󠄣󠅄󠅈󠅜󠄼󠅃󠅑󠄻󠅩󠅆󠄺󠅪󠅪󠄢󠅉󠅈󠄺󠅉󠄹󠄳󠅏󠅅󠄶󠅛󠅟󠄳󠄥󠅅󠄩󠄲󠅠󠅃󠅗󠄲󠅄󠄷󠅅󠅁󠅗󠅣󠅚󠅖󠅪󠅏󠅕󠅝󠅦󠄥󠅨󠅩󠅛󠄴󠅙󠅑󠅦󠅊󠅅󠅖󠅂󠄾󠄨󠄵";
+describe("decodeTokenFromEmojiString", () => {
+    it("should decode single emoji", () => {
+        expect(decodeTokenFromEmojiString(emoji)).toEqual(expect.objectContaining({
+            mint: "https://testnut.cashu.space",
+            proofs: [expect.any(Object)],
+            unit: "sat",
+        }));
+    });
+    it("should decode an emoji in text", () => {
+        expect(decodeTokenFromEmojiString("the money is in the emoji, " + emoji + " you can redeem it using cashu.me")).toEqual(expect.objectContaining({
+            mint: "https://testnut.cashu.space",
+            proofs: [expect.any(Object)],
+            unit: "sat",
+        }));
     });
 });

package/dist/helpers/tokens.d.ts

@@ -1,5 +1,10 @@
+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 */
@@ -17,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
@@ -29,10 +33,26 @@ 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
+ */
+export declare function decodeTokenFromEmojiString(str: string): Token | undefined;
+/**
+ * Encodes a token into an emoji char
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
+ */
+export declare function encodeTokenToEmoji(token: Token | string, emoji?: string): string;

package/dist/helpers/tokens.js

@@ -1,7 +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
@@ -36,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) {
@@ -57,17 +73,88 @@ 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 { events: selectedTokens, proofs: selectedProofs };
+}
+/**
+ * Returns a decoded cashu token inside an unicode emoji
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
+ */
+export function decodeTokenFromEmojiString(str) {
+    try {
+        let decoded = [];
+        const chars = Array.from(str);
+        if (!chars.length)
+            return undefined;
+        const fromVariationSelector = function (char) {
+            const codePoint = char.codePointAt(0);
+            if (codePoint === undefined)
+                return null;
+            // Handle Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) {
+                // Maps FE00->0, FE01->1, ..., FE0F->15
+                const byteValue = codePoint - 0xfe00;
+                return String.fromCharCode(byteValue);
+            }
+            // Handle Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (codePoint >= 0xe0100 && codePoint <= 0xe01ef) {
+                // Maps E0100->16, E0101->17, ..., E01EF->255
+                const byteValue = codePoint - 0xe0100 + 16;
+                return String.fromCharCode(byteValue);
+            }
+            // No Variation Selector
+            return null;
+        };
+        // Check all input chars for peanut data
+        for (const char of chars) {
+            let byte = fromVariationSelector(char);
+            if (byte === null && decoded.length > 0) {
+                break;
+            }
+            else if (byte === null) {
+                continue;
+            }
+            decoded.push(byte); // got some
+        }
+        // Switch out token if we found peanut data
+        let decodedString = decoded.join("");
+        return getDecodedToken(decodedString);
+    }
+    catch (error) {
+        return undefined;
     }
-    return selected;
+}
+/**
+ * Encodes a token into an emoji char
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
+ */
+export function encodeTokenToEmoji(token, emoji = "🥜") {
+    return (emoji +
+        Array.from(typeof token === "string" ? token : getEncodedToken(token))
+            .map((char) => {
+            const byteValue = char.charCodeAt(0);
+            // For byte values 0-15, use Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (byteValue >= 0 && byteValue <= 15) {
+                return String.fromCodePoint(0xfe00 + byteValue);
+            }
+            // For byte values 16-255, use Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (byteValue >= 16 && byteValue <= 255) {
+                return String.fromCodePoint(0xe0100 + (byteValue - 16));
+            }
+            return "";
+        })
+            .join(""));
 }

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