applesauce-wallet 0.11.0 → 0.12.0

package/README.md

@@ -0,0 +1,3 @@
+# Applesauce Wallet
+
+The `applesauce-wallet` package is a package of helpers, queries, blueprints and other useful stuff for [NIP-60](https://github.com/nostr-protocol/nips/blob/master/60.md) wallets and [NIP-61](https://github.com/nostr-protocol/nips/blob/master/61.md) nutzaps

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__/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/actions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./wallet.js";
+export * from "./tokens.js";

package/dist/actions/index.js

@@ -0,0 +1,2 @@
+export * from "./wallet.js";
+export * from "./tokens.js";

package/dist/actions/tokens.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "@cashu/cashu-ts";
+import { Action } from "applesauce-actions";
+import { NostrEvent } from "nostr-tools";
+/**
+ * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * @param token the cashu token to add
+ * @param redeemed an array of nutzap event ids to mark as redeemed
+ */
+export declare function ReceiveToken(token: Token, redeemed?: string[], fee?: number): Action;
+/** An action that deletes old tokens and creates a new one but does not add a history event */
+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

@@ -0,0 +1,110 @@
+import { CashuMint, CashuWallet, CheckStateEnum } from "@cashu/cashu-ts";
+import { DeleteBlueprint } from "applesauce-factory/blueprints";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { WalletTokenBlueprint } from "../blueprints/tokens.js";
+import { WalletHistoryBlueprint } from "../blueprints/history.js";
+/**
+ * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * @param token the cashu token to add
+ * @param redeemed an array of nutzap event ids to mark as redeemed
+ */
+export function ReceiveToken(token, redeemed, fee) {
+    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 ?? []));
+        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 function* ({ factory }) {
+        // create a delete event for old tokens
+        const deleteDraft = await factory.create(DeleteBlueprint, tokens);
+        // create a new token event
+        const tokenDraft = await factory.create(WalletTokenBlueprint, token, tokens.map((e) => e.id));
+        // sign events
+        const signedDelete = await factory.sign(deleteDraft);
+        const signedToken = await factory.sign(tokenDraft);
+        // publish events
+        yield signedDelete;
+        yield signedToken;
+    };
+}
+/** An action that deletes old token events and adds a spend history item */
+export function CompleteSpend(spent, change) {
+    return async function* ({ factory }) {
+        if (spent.length === 0)
+            throw new Error("Cant complete spent with no token events");
+        if (spent.some((s) => isTokenContentLocked(s)))
+            throw new Error("Cant complete spend with locked tokens");
+        // create the nip-09 delete event for previous events
+        const deleteDraft = await factory.create(DeleteBlueprint, spent);
+        const changeAmount = change.proofs.reduce((t, p) => t + p.amount, 0);
+        // create a new token event if needed
+        const changeDraft = changeAmount > 0
+            ? await factory.create(WalletTokenBlueprint, change, spent.map((e) => e.id))
+            : undefined;
+        const total = spent.reduce((total, token) => total + getTokenContent(token).proofs.reduce((t, p) => t + p.amount, 0), 0);
+        // calculate the amount that was spent
+        const diff = total - changeAmount;
+        // sign delete and token
+        const signedDelete = await factory.sign(deleteDraft);
+        const signedToken = changeDraft && (await factory.sign(changeDraft));
+        // create a history entry
+        const history = await factory.create(WalletHistoryBlueprint, { direction: "out", mint: change.mint, amount: diff, created: signedToken ? [signedToken.id] : [] }, []);
+        // sign history
+        const signedHistory = await factory.sign(history);
+        // publish events
+        yield signedDelete;
+        if (signedToken)
+            yield signedToken;
+        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/actions/wallet.d.ts

@@ -0,0 +1,13 @@
+import { Action } from "applesauce-actions";
+/** An action that creates a new 17375 wallet event and 375 wallet backup */
+export declare function CreateWallet(mints: string[], privateKey?: Uint8Array): Action;
+/**
+ * Adds a private key to a wallet event
+ * @throws if the wallet does not exist or is locked
+ */
+export declare function WalletAddPrivateKey(privateKey: Uint8Array): Action;
+/** Unlocks the wallet event and optionally the tokens and history events */
+export declare function UnlockWallet(unlock?: {
+    history?: boolean;
+    tokens?: boolean;
+}): Action;

package/dist/actions/wallet.js

@@ -0,0 +1,64 @@
+import { getWalletMints, getWalletPrivateKey, isWalletLocked, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
+import { WalletBackupBlueprint, WalletBlueprint } from "../blueprints/wallet.js";
+import { isTokenContentLocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+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) {
+    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, mints, privateKey));
+        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, wallet));
+        // publish the backup first
+        yield backup;
+        yield wallet;
+    };
+}
+/**
+ * Adds a private key to a wallet event
+ * @throws if the wallet does not exist or is locked
+ */
+export function WalletAddPrivateKey(privateKey) {
+    return async function* ({ events, self, factory }) {
+        const wallet = events.getReplaceable(WALLET_KIND, self);
+        if (!wallet)
+            throw new Error("Wallet does not exist");
+        if (isWalletLocked(wallet))
+            throw new Error("Wallet is locked");
+        if (getWalletPrivateKey(wallet))
+            throw new Error("Wallet already has a private key");
+        const draft = await factory.create(WalletBlueprint, getWalletMints(wallet), privateKey);
+        const signed = await factory.sign(draft);
+        // create backup event for wallet
+        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, signed));
+        // publish events
+        yield backup;
+        yield signed;
+    };
+}
+/** Unlocks the wallet event and optionally the tokens and history events */
+export function UnlockWallet(unlock) {
+    return async function* ({ events, self, factory }) {
+        const signer = factory.context.signer;
+        if (!signer)
+            throw new Error("Missing signer");
+        const wallet = events.getReplaceable(WALLET_KIND, self);
+        if (!wallet)
+            throw new Error("Wallet does not exist");
+        if (isWalletLocked(wallet))
+            await unlockWallet(wallet, signer);
+        if (unlock?.tokens) {
+            const tokens = events.getTimeline({ kinds: [WALLET_TOKEN_KIND], authors: [self] });
+            for (const token of tokens)
+                if (isTokenContentLocked(token))
+                    await unlockTokenContent(token, signer);
+        }
+        if (unlock?.history) {
+            const history = events.getTimeline({ kinds: [WALLET_HISTORY_KIND], authors: [self] });
+            for (const entry of history)
+                if (isHistoryContentLocked(entry))
+                    await unlockHistoryContent(entry, signer);
+        }
+    };
+}

package/dist/blueprints/history.d.ts

@@ -0,0 +1,5 @@
+import { EventPointer } from "nostr-tools/nip19";
+import { HistoryContent } from "../helpers/history.js";
+import { EventBlueprint } from "applesauce-factory";
+/** A blueprint that creates a wallet history event */
+export declare function WalletHistoryBlueprint(content: HistoryContent, redeemed: (string | EventPointer)[]): EventBlueprint;

package/dist/blueprints/history.js

@@ -0,0 +1,11 @@
+import { WALLET_HISTORY_KIND } from "../helpers/history.js";
+import { EventFactory } from "applesauce-factory";
+import { setHistoryContent, setHistoryRedeemed } from "../operations/event/history.js";
+/** A blueprint that creates a wallet history event */
+export function WalletHistoryBlueprint(content, redeemed) {
+    return (ctx) => EventFactory.runProcess({ kind: WALLET_HISTORY_KIND }, ctx, 
+    // set the encrypted tags on the event
+    setHistoryContent(content), 
+    // set the public redeemed tags
+    setHistoryRedeemed(redeemed));
+}

package/dist/blueprints/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./wallet.js";
+export * from "./tokens.js";

package/dist/blueprints/index.js

@@ -0,0 +1,2 @@
+export * from "./wallet.js";
+export * from "./tokens.js";

package/dist/blueprints/tokens.d.ts

@@ -0,0 +1,8 @@
+import { Token } from "@cashu/cashu-ts";
+import { EventBlueprint } from "applesauce-factory";
+/**
+ * A blueprint for a wallet token event, takes a cashu token and previous deleted token event ids
+ * @param token the cashu token to store
+ * @param [del=[]] an array of previous token event ids that are deleted
+ */
+export declare function WalletTokenBlueprint(token: Token, del?: string[]): EventBlueprint;

package/dist/blueprints/tokens.js

@@ -0,0 +1,11 @@
+import { EventFactory } from "applesauce-factory";
+import { WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { setTokenContent } from "../operations/event/tokens.js";
+/**
+ * A blueprint for a wallet token event, takes a cashu token and previous deleted token event ids
+ * @param token the cashu token to store
+ * @param [del=[]] an array of previous token event ids that are deleted
+ */
+export function WalletTokenBlueprint(token, del = []) {
+    return (ctx) => EventFactory.runProcess({ kind: WALLET_TOKEN_KIND }, ctx, setTokenContent(token, del));
+}

package/dist/blueprints/wallet.d.ts

@@ -0,0 +1,6 @@
+import { EventBlueprint } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+/** A blueprint to create a new 17375 wallet */
+export declare function WalletBlueprint(mints: string[], privateKey?: Uint8Array): EventBlueprint;
+/** A blueprint that creates a new 375 wallet backup event */
+export declare function WalletBackupBlueprint(wallet: NostrEvent): EventBlueprint;

package/dist/blueprints/wallet.js

@@ -0,0 +1,13 @@
+import { EventFactory } from "applesauce-factory";
+import { modifyHiddenTags } from "applesauce-factory/operations/event";
+import { WALLET_BACKUP_KIND, WALLET_KIND } from "../helpers/wallet.js";
+import { setWalletBackupContent } from "../operations/event/wallet.js";
+import { setMintTags, setPrivateKeyTag } from "../operations/tag/wallet.js";
+/** A blueprint to create a new 17375 wallet */
+export function WalletBlueprint(mints, privateKey) {
+    return (ctx) => EventFactory.runProcess({ kind: WALLET_KIND }, ctx, modifyHiddenTags(privateKey ? setPrivateKeyTag(privateKey) : undefined, setMintTags(mints)));
+}
+/** A blueprint that creates a new 375 wallet backup event */
+export function WalletBackupBlueprint(wallet) {
+    return (ctx) => EventFactory.runProcess({ kind: WALLET_BACKUP_KIND }, ctx, setWalletBackupContent(wallet));
+}

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__/tokens.test.d.ts

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