applesauce-wallet 0.0.0-next-20250808173123 → 0.0.0-next-20250828144630

package/dist/__tests__/exports.test.d.ts

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

package/dist/__tests__/exports.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "Actions",
+        "Blueprints",
+        "EventOperations",
+        "Helpers",
+        "Models",
+        "TagOperations",
+      ]
+    `);
+    });
+});

package/dist/__tests__/fake-user.d.ts

@@ -0,0 +1,10 @@
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import type { NostrEvent } from "nostr-tools";
+export declare class FakeUser extends SimpleSigner {
+    pubkey: string;
+    event(data?: Partial<NostrEvent>): NostrEvent;
+    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    contacts(pubkeys?: string[]): import("nostr-tools").Event;
+    list(tags?: string[][], extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+}

package/dist/__tests__/fake-user.js

@@ -0,0 +1,31 @@
+import { unixNow } from "applesauce-core/helpers";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import { finalizeEvent, getPublicKey, kinds } from "nostr-tools";
+export class FakeUser extends SimpleSigner {
+    pubkey = getPublicKey(this.key);
+    event(data) {
+        return finalizeEvent({
+            kind: data?.kind ?? kinds.ShortTextNote,
+            content: data?.content || "",
+            created_at: data?.created_at ?? unixNow(),
+            tags: data?.tags || [],
+        }, this.key);
+    }
+    note(content = "Hello World", extra) {
+        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
+    }
+    profile(profile, extra) {
+        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
+    }
+    contacts(pubkeys = []) {
+        return this.event({ kind: kinds.Contacts, tags: pubkeys.map((p) => ["p", p]) });
+    }
+    list(tags = [], extra) {
+        return this.event({
+            kind: kinds.Bookmarksets,
+            content: "",
+            tags: [["d", String(Math.round(Math.random() * 10000))], ...tags],
+            ...extra,
+        });
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "CompleteSpend",
+        "ConsolidateTokens",
+        "CreateWallet",
+        "ReceiveToken",
+        "RolloverTokens",
+        "UnlockWallet",
+        "WalletAddPrivateKey",
+      ]
+    `);
+    });
+});

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/__tests__/wallet.test.d.ts

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

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

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, vitest } from "vitest";
+import { unlockHiddenTags } from "applesauce-core/helpers";
+import { lastValueFrom } from "rxjs";
+import { generateSecretKey } from "nostr-tools";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { ActionHub } from "applesauce-actions";
+import { bytesToHex } from "@noble/hashes/utils";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { WalletAddPrivateKey, CreateWallet } from "../wallet.js";
+import { getWalletPrivateKey, unlockWallet, WALLET_BACKUP_KIND } from "../../helpers/wallet.js";
+import { WalletBlueprint } from "../../blueprints/wallet.js";
+const user = new FakeUser();
+let events;
+let factory;
+let publish;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    publish = vitest.fn().mockResolvedValue(undefined);
+    hub = new ActionHub(events, factory, publish);
+});
+describe("CreateWallet", () => {
+    it("should publish a wallet backup event", async () => {
+        await hub.run(CreateWallet, ["https://mint.money.com"]);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: WALLET_BACKUP_KIND }));
+    });
+    it("should publish a wallet event with mints", async () => {
+        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"]]));
+    });
+});
+describe("WalletAddPrivateKey", () => {
+    it("should add a private key to an existing wallet event without a private key", async () => {
+        const walletEvent = await factory.sign(await factory.create(WalletBlueprint, ["https://mint.money.com"]));
+        await events.add(walletEvent);
+        const privateKey = generateSecretKey();
+        const updatedWallet = await lastValueFrom(hub.exec(WalletAddPrivateKey, privateKey));
+        await unlockWallet(updatedWallet, user);
+        const key = getWalletPrivateKey(updatedWallet);
+        expect(key).toBeDefined();
+        expect(bytesToHex(key)).toEqual(bytesToHex(privateKey));
+    });
+    it("should throw an error if a wallet event already has a private key", async () => {
+        const walletEvent = await factory.sign(await factory.create(WalletBlueprint, ["https://mint.money.com"], generateSecretKey()));
+        await events.add(walletEvent);
+        await expect(hub.run(WalletAddPrivateKey, generateSecretKey())).rejects.toThrow("Wallet already has a private key");
+    });
+    it("should throw an error if the wallet event does not exist", async () => {
+        const privateKey = generateSecretKey();
+        await expect(hub.run(WalletAddPrivateKey, privateKey)).rejects.toThrow("Wallet does not exist");
+    });
+});

package/dist/blueprints/__tests__/exports.test.d.ts

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

package/dist/blueprints/__tests__/exports.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "WalletBackupBlueprint",
+        "WalletBlueprint",
+        "WalletTokenBlueprint",
+      ]
+    `);
+    });
+});

package/dist/helpers/__tests__/animated-qr.test.d.ts

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

package/dist/helpers/__tests__/animated-qr.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { getDecodedToken } from "@cashu/cashu-ts";
+import { lastValueFrom, map, take, timer } from "rxjs";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { receiveAnimated, sendAnimated } from "../animated-qr.js";
+const tokenStr = "cashuBo2FteBtodHRwczovL3Rlc3RudXQuY2FzaHUuc3BhY2VhdWNzYXRhdIGiYWlIAJofKTJT5B5hcIOkYWEQYXN4QDA2M2VlYjgwZDZjODM4NWU4NzYwODVhN2E4NzdkOTkyY2U4N2QwNTRmY2RjYzNiODMwMzhjOWY3MmNmMDY1ZGVhY1ghAynsxZ-OuZfZDcqYTLPYfCqHO7jkGjn97aolgtSYhYykYWSjYWVYIGbp_9B9aztSlZxz7g6Tqx5M_1PuFzJCVEMOVd8XAF8wYXNYINTOU77ODcj28v04pq7ektdf6sq2XuxvMjVE0wK6jFolYXJYIM_gZnUGT5jDOyZiQ-2vG9zYnuWaY8vPoWGe_3sXvrvbpGFhBGFzeEA0MWMwZDk1YTU5ZjkxNTdlYTc5NTJlNGFlMzYzYTI3NTMxNTllNmQ1NGJiNzExMTg5ZDk5YjU1MmYzYjIzZTJiYWNYIQM-49gen_1nPchxbaAiKprVr78VmMRVpHH_Tu9P8TO5mGFko2FlWCB9j7rlpdBH_m7tNYnLpzPhn-nGmS1CcbUfnPzjxy6G92FzWCDdsby7fGM5324T5UEoV858YWzZ9MCY59KgKP362fJDfmFyWCDL73v4FRo7iMe83bfMuEy3RJPtC1Vr1jdOpw2-x-7EAaRhYQFhc3hANjRhZDI3NmExOGNmNDhiMDZmYjdiMGYwOWFiMTU4ZTA0ZmM0NmIxYzA4YzMyNjJlODUxNzZkYTMzMTgyYzQ3YWFjWCECMDpCbNbrgA9FcQEIYxobU7ik_pTl8sByPqHDmkY4azxhZKNhZVggqHGaff9M270EU8LGxRpG_G4rn2bMgjyk3hFFg78ZXRVhc1ggP6DsNsWykwKE94yZF23gpCyapcoqh6DDZdVu0lKn2Z5hclggmPKig-lObsuxi_1XCm7_Y_tqaCcqEDz8eCwVhJ8gq9M";
+const token = getDecodedToken(tokenStr);
+describe("sendAnimated", () => {
+    it("should loop", async () => {
+        const qr$ = sendAnimated(token, { interval: 0 });
+        const spy = subscribeSpyTo(qr$);
+        // wait 100ms
+        await lastValueFrom(timer(100));
+        // should not have competed
+        expect(spy.receivedComplete()).toBeFalsy();
+        spy.unsubscribe();
+    });
+    it("should emit parts", async () => {
+        const qr$ = sendAnimated(token, { interval: 0 }).pipe(take(6));
+        const spy = subscribeSpyTo(qr$);
+        // wait 100ms
+        await lastValueFrom(qr$);
+        // should not have competed
+        expect(spy.getValues()).toEqual(Array(6)
+            .fill(0)
+            .map((_, i) => expect.stringContaining(`ur:bytes/${i + 1}-6/`)));
+    });
+});
+describe("receiveAnimated", () => {
+    it("should decode animated qr", async () => {
+        const qr$ = sendAnimated(token, { interval: 0 }).pipe(receiveAnimated, map((part) => (typeof part === "string" ? getDecodedToken(part) : part)));
+        const spy = subscribeSpyTo(qr$);
+        await lastValueFrom(qr$);
+        expect(spy.getValues()).toEqual([
+            expect.any(Number),
+            expect.any(Number),
+            expect.any(Number),
+            expect.any(Number),
+            expect.any(Number),
+            expect.any(Number),
+            token,
+        ]);
+    });
+});

package/dist/helpers/__tests__/exports.test.d.ts

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

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

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "ANIMATED_QR_FRAGMENTS",
+        "ANIMATED_QR_INTERVAL",
+        "HistoryContentSymbol",
+        "TokenContentSymbol",
+        "WALLET_BACKUP_KIND",
+        "WALLET_HISTORY_KIND",
+        "WALLET_KIND",
+        "WALLET_TOKEN_KIND",
+        "WalletMintsSymbol",
+        "WalletPrivateKeySymbol",
+        "decodeTokenFromEmojiString",
+        "dumbTokenSelection",
+        "encodeTokenToEmoji",
+        "getHistoryContent",
+        "getHistoryRedeemed",
+        "getProofUID",
+        "getTokenContent",
+        "getTokenProofsTotal",
+        "getWalletMints",
+        "getWalletPrivateKey",
+        "ignoreDuplicateProofs",
+        "isHistoryContentLocked",
+        "isTokenContentLocked",
+        "isWalletLocked",
+        "lockHistoryContent",
+        "lockTokenContent",
+        "lockWallet",
+        "receiveAnimated",
+        "sendAnimated",
+        "unlockHistoryContent",
+        "unlockTokenContent",
+        "unlockWallet",
+      ]
+    `);
+    });
+});

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

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

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

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import { EventFactory } from "applesauce-factory";
+import { EncryptedContentSymbol, unixNow } from "applesauce-core/helpers";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { WalletTokenBlueprint } from "../../blueprints/tokens.js";
+import { decodeTokenFromEmojiString, dumbTokenSelection, encodeTokenToEmoji, unlockTokenContent } from "../tokens.js";
+const user = new FakeUser();
+const factory = new EventFactory({ signer: user });
+describe("dumbTokenSelection", () => {
+    it("should select old tokens first", async () => {
+        const a = await user.signEvent(await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        await unlockTokenContent(a, user);
+        const bDraft = await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "B", C: "B", id: "B", amount: 50 }],
+        });
+        bDraft.created_at -= 60 * 60 * 7;
+        const b = await user.signEvent(bDraft);
+        await unlockTokenContent(b, user);
+        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, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        await unlockTokenContent(a, user);
+        const bDraft = await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "B", C: "B", id: "B", amount: 50 }],
+        });
+        bDraft.created_at -= 60 * 60 * 7;
+        const b = await user.signEvent(bDraft);
+        await unlockTokenContent(b, user);
+        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, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        await unlockTokenContent(a, user);
+        expect(() => dumbTokenSelection([a], 120)).toThrow();
+    });
+    it("should ignore locked tokens", async () => {
+        const a = await user.signEvent(await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "A", C: "A", id: "A", amount: 100 }],
+        }));
+        await unlockTokenContent(a, user);
+        const bDraft = await factory.create(WalletTokenBlueprint, {
+            mint: "https://money.com",
+            proofs: [{ secret: "B", C: "B", id: "B", amount: 50 }],
+        });
+        bDraft.created_at -= 60 * 60 * 7;
+        const b = await user.signEvent(bDraft);
+        // manually remove the hidden content to lock it again
+        Reflect.deleteProperty(b, EncryptedContentSymbol);
+        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/models/__tests__/exports.test.d.ts

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

package/dist/models/__tests__/exports.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "WalletBalanceModel",
+        "WalletHistoryModel",
+        "WalletModel",
+        "WalletRedeemedModel",
+        "WalletTokensModel",
+      ]
+    `);
+    });
+});

package/dist/models/__tests__/wallet.test.d.ts

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

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

@@ -0,0 +1,28 @@
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { generateSecretKey } from "nostr-tools";
+import { beforeEach, describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { WalletBlueprint } from "../../blueprints/wallet.js";
+import { lockWallet, unlockWallet } from "../../helpers/wallet.js";
+import { WalletModel } from "../wallet.js";
+const user = new FakeUser();
+const factory = new EventFactory({ signer: user });
+let eventStore;
+beforeEach(() => {
+    eventStore = new EventStore();
+});
+describe("WalletModel", () => {
+    it("it should update when event is unlocked", async () => {
+        const wallet = await user.signEvent(await factory.create(WalletBlueprint, [], generateSecretKey()));
+        lockWallet(wallet);
+        eventStore.add(wallet);
+        const spy = subscribeSpyTo(eventStore.model(WalletModel, await user.getPublicKey()));
+        await unlockWallet(wallet, user);
+        expect(spy.getValues()).toEqual([
+            expect.objectContaining({ locked: true }),
+            expect.objectContaining({ locked: false }),
+        ]);
+    });
+});

package/dist/operations/__tests__/exports.test.d.ts

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

package/dist/operations/__tests__/exports.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "EventOperations",
+        "TagOperations",
+      ]
+    `);
+    });
+});

package/dist/operations/__tests__/wallet.test.d.ts

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

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

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { setWalletBackupContent } from "../wallet.js";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { EventFactory } from "applesauce-factory";
+import { WalletBlueprint } from "../../blueprints/wallet.js";
+import { generateSecretKey } from "nostr-tools";
+import { WALLET_BACKUP_KIND } from "../../helpers/wallet.js";
+import { unixNow } from "applesauce-core/helpers";
+const user = new FakeUser();
+const factory = new EventFactory({ signer: user });
+describe("setWalletBackupContent", () => {
+    it("should throw if kind is not wallet kind", async () => {
+        const note = user.note();
+        await expect(setWalletBackupContent(note)({ kind: WALLET_BACKUP_KIND, tags: [], created_at: unixNow(), content: "" }, factory.context)).rejects.toThrow();
+    });
+    it("should throw if pubkey does not match", async () => {
+        const wallet = await factory.sign(await factory.create(WalletBlueprint, generateSecretKey(), []));
+        const user2 = new FakeUser();
+        await expect(setWalletBackupContent(wallet)({ kind: WALLET_BACKUP_KIND, tags: [], created_at: unixNow(), content: "" }, { signer: user2 })).rejects.toThrow();
+    });
+    it("should copy the content of the wallet event", async () => {
+        const wallet = await factory.sign(await factory.create(WalletBlueprint, generateSecretKey(), []));
+        expect(await setWalletBackupContent(wallet)({ kind: WALLET_BACKUP_KIND, tags: [], created_at: unixNow(), content: "" }, factory.context)).toEqual(expect.objectContaining({ content: wallet.content }));
+    });
+});

package/dist/operations/event/__tests__/exports.test.d.ts

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

package/dist/operations/event/__tests__/exports.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import * as exports from "../index.js";
+describe("exports", () => {
+    it("should export the expected functions", () => {
+        expect(Object.keys(exports).sort()).toMatchInlineSnapshot(`
+      [
+        "setHistoryContent",
+        "setHistoryRedeemed",
+        "setTokenContent",
+        "setWalletBackupContent",
+      ]
+    `);
+    });
+});