applesauce-wallet 0.11.0 → 0.12.0

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

@@ -0,0 +1,127 @@
+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 { 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", () => {
+    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, HiddenContentSymbol);
+        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/animated-qr.d.ts

@@ -0,0 +1,30 @@
+import { Token } from "@cashu/cashu-ts";
+import { Observable } from "rxjs";
+/** Preset speeds for the animated qr code */
+export declare const ANIMATED_QR_INTERVAL: {
+    SLOW: number;
+    MEDIUM: number;
+    FAST: number;
+};
+/** Presets for fragment length for animated qr code */
+export declare const ANIMATED_QR_FRAGMENTS: {
+    SHORT: number;
+    MEDIUM: number;
+    LONG: number;
+};
+export type SendAnimatedOptions = {
+    /**
+     * The interval between the parts ( 150 - 500 )
+     * @default 150
+     */
+    interval?: number;
+    /**
+     * max fragment length ( 50 - 200 )
+     * @default 100
+     */
+    fragmentLength?: number;
+};
+/** Creates an observable that iterates through a multi-part animated qr code */
+export declare function sendAnimated(token: Token | string, options?: SendAnimatedOptions): Observable<string>;
+/** Creates an observable that completes with decoded token */
+export declare function receiveAnimated(input: Observable<string>): Observable<string | number>;

package/dist/helpers/animated-qr.js

@@ -0,0 +1,71 @@
+import { getEncodedTokenV4 } from "@cashu/cashu-ts";
+import { UR, URDecoder, UREncoder } from "@gandlaf21/bc-ur/dist/lib/es6/index.js";
+import { defer, filter, interval, map, Observable, shareReplay } from "rxjs";
+/** Preset speeds for the animated qr code */
+export const ANIMATED_QR_INTERVAL = {
+    SLOW: 500,
+    MEDIUM: 250,
+    FAST: 150,
+};
+/** Presets for fragment length for animated qr code */
+export const ANIMATED_QR_FRAGMENTS = {
+    SHORT: 50,
+    MEDIUM: 100,
+    LONG: 150,
+};
+/** Creates an observable that iterates through a multi-part animated qr code */
+export function sendAnimated(token, options) {
+    // start the stream as soon as there is subscriber
+    return defer(() => {
+        let str = typeof token === "string" ? token : getEncodedTokenV4(token);
+        let utf8 = new TextEncoder();
+        let buffer = utf8.encode(str);
+        let ur = UR.from(buffer);
+        let encoder = new UREncoder(ur, options?.fragmentLength ?? 100, 0);
+        return interval(options?.interval ?? ANIMATED_QR_INTERVAL.FAST).pipe(map(() => encoder.nextPart()));
+    });
+}
+/** An operator that decodes UR, emits progress percent and completes with final result or error */
+function urDecoder() {
+    return (source) => new Observable((observer) => {
+        const decoder = new URDecoder();
+        return source.subscribe((part) => {
+            decoder.receivePart(part);
+            if (decoder.isComplete() && decoder.isSuccess()) {
+                // emit progress
+                const progress = decoder.estimatedPercentComplete();
+                observer.next(progress);
+                // emit result
+                const ur = decoder.resultUR();
+                const decoded = ur.decodeCBOR();
+                const utf8 = new TextDecoder();
+                const tokenStr = utf8.decode(decoded);
+                observer.next(tokenStr);
+                // complete
+                observer.complete();
+            }
+            else if (decoder.isError()) {
+                // emit error
+                const reason = decoder.resultError();
+                observer.error(new Error(reason));
+            }
+            else {
+                // emit progress
+                const progress = decoder.estimatedPercentComplete();
+                observer.next(progress);
+            }
+        });
+    });
+}
+/** Creates an observable that completes with decoded token */
+export function receiveAnimated(input) {
+    return input.pipe(
+    // convert to lower case
+    map((str) => str.toLowerCase()), 
+    // filter out non UR parts
+    filter((str) => str.startsWith("ur:bytes")), 
+    // decode UR and complete
+    urDecoder(), 
+    // only run one decoder
+    shareReplay(1));
+}

package/dist/helpers/history.d.ts

@@ -0,0 +1,26 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+export declare const WALLET_HISTORY_KIND = 7376;
+export type HistoryDirection = "in" | "out";
+export type HistoryContent = {
+    /** The direction of the transaction, in = received, out = sent */
+    direction: HistoryDirection;
+    /** The amount of the transaction */
+    amount: number;
+    /** An array of token event ids created */
+    created: string[];
+    /** The mint that was spent from */
+    mint?: string;
+    /** The fee paid */
+    fee?: number;
+};
+export declare const HistoryContentSymbol: unique symbol;
+/** returns an array of redeemed event ids in a history event */
+export declare function getHistoryRedeemed(history: NostrEvent): string[];
+/** Checks if the history contents are locked */
+export declare function isHistoryContentLocked(history: NostrEvent): boolean;
+/** Returns the parsed content of a 7376 history event */
+export declare function getHistoryContent(history: NostrEvent): HistoryContent | undefined;
+/** Decrypts a wallet history event */
+export declare function unlockHistoryContent(history: NostrEvent, signer: HiddenContentSigner): Promise<HistoryContent>;
+export declare function lockHistoryContent(history: NostrEvent): void;

package/dist/helpers/history.js

@@ -0,0 +1,45 @@
+import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, unlockHiddenTags, } from "applesauce-core/helpers";
+export const WALLET_HISTORY_KIND = 7376;
+export const HistoryContentSymbol = Symbol.for("history-content");
+/** returns an array of redeemed event ids in a history event */
+export function getHistoryRedeemed(history) {
+    return history.tags.filter((t) => isETag(t) && t[3] === "redeemed").map((t) => t[1]);
+}
+/** Checks if the history contents are locked */
+export function isHistoryContentLocked(history) {
+    return isHiddenTagsLocked(history);
+}
+/** Returns the parsed content of a 7376 history event */
+export function getHistoryContent(history) {
+    if (isHistoryContentLocked(history))
+        return undefined;
+    return getOrComputeCachedValue(history, HistoryContentSymbol, () => {
+        const tags = getHiddenTags(history);
+        if (!tags)
+            throw new Error("History event is locked");
+        const direction = tags.find((t) => t[0] === "direction")?.[1];
+        if (!direction)
+            throw new Error("History event missing direction");
+        const amountStr = tags.find((t) => t[0] === "amount")?.[1];
+        if (!amountStr)
+            throw new Error("History event missing amount");
+        const amount = parseInt(amountStr);
+        if (!Number.isFinite(amount))
+            throw new Error("Failed to parse amount");
+        const mint = tags.find((t) => t[0] === "mint")?.[1];
+        const feeStr = tags.find((t) => t[0] === "fee")?.[1];
+        const fee = feeStr ? parseInt(feeStr) : undefined;
+        const created = tags.filter((t) => isETag(t) && t[3] === "created").map((t) => t[1]);
+        return { direction, amount, created, mint, fee };
+    });
+}
+/** Decrypts a wallet history event */
+export async function unlockHistoryContent(history, signer) {
+    if (isHiddenContentLocked(history))
+        await unlockHiddenTags(history, signer);
+    return getHistoryContent(history);
+}
+export function lockHistoryContent(history) {
+    Reflect.deleteProperty(history, HistoryContentSymbol);
+    lockHiddenTags(history);
+}

package/dist/helpers/index.d.ts

@@ -1 +1,4 @@
 export * from "./wallet.js";
+export * from "./tokens.js";
+export * from "./history.js";
+export * from "./animated-qr.js";

package/dist/helpers/index.js

@@ -1 +1,4 @@
 export * from "./wallet.js";
+export * from "./tokens.js";
+export * from "./history.js";
+export * from "./animated-qr.js";

package/dist/helpers/tokens.d.ts

@@ -0,0 +1,58 @@
+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 */
+    mint: string;
+    /** Cashu proofs */
+    proofs: {
+        amount: number;
+        secret: string;
+        C: string;
+        id: string;
+    }[];
+    /** The cashu unit */
+    unit?: string;
+    /** tokens that were destroyed in the creation of this token (helps on wallet state transitions) */
+    del: string[];
+};
+export declare const TokenContentSymbol: unique symbol;
+/**
+ * Returns the decrypted and parsed details of a 7375 token event
+ * @throws
+ */
+export declare function getTokenContent(token: NostrEvent): TokenContent | undefined;
+/** Returns if token details are locked */
+export declare function isTokenContentLocked(token: NostrEvent): boolean;
+/** Decrypts a k:7375 token event */
+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
+ * @param token The token event to calculate the total
+ */
+export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
+/**
+ * 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): {
+    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

@@ -0,0 +1,160 @@
+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");
+/**
+ * Returns the decrypted and parsed details of a 7375 token event
+ * @throws
+ */
+export function getTokenContent(token) {
+    if (isHiddenTagsLocked(token))
+        return undefined;
+    return getOrComputeCachedValue(token, TokenContentSymbol, () => {
+        const plaintext = getHiddenContent(token);
+        if (!plaintext)
+            throw new Error("Token is locked");
+        const details = JSON.parse(plaintext);
+        if (!details.mint)
+            throw new Error("Token missing mint");
+        if (!details.proofs)
+            throw new Error("Token missing proofs");
+        if (!details.del)
+            details.del = [];
+        return details;
+    });
+}
+/** Returns if token details are locked */
+export function isTokenContentLocked(token) {
+    return isHiddenContentLocked(token);
+}
+/** Decrypts a k:7375 token event */
+export async function unlockTokenContent(token, signer) {
+    if (isHiddenContentLocked(token))
+        await unlockHiddenContent(token, signer);
+    return getTokenContent(token);
+}
+/** Removes the unencrypted hidden content */
+export function lockTokenContent(token) {
+    Reflect.deleteProperty(token, TokenContentSymbol);
+    lockHiddenContent(token);
+}
+/**
+ * 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;
+    const content = getTokenContent(token);
+    return content.proofs.reduce((t, p) => t + p.amount, 0);
+}
+/**
+ * Selects oldest tokens and proofs that total up to more than the min amount
+ * @throws
+ */
+export function dumbTokenSelection(tokens, minAmount, mint) {
+    // sort newest to oldest
+    const sorted = tokens
+        .filter((token) => !isTokenContentLocked(token) && (mint ? getTokenContent(token).mint === mint : true))
+        .sort((a, b) => b.created_at - a.created_at);
+    let amount = 0;
+    const seen = new Set();
+    const selectedTokens = [];
+    const selectedProofs = [];
+    while (amount < minAmount) {
+        const token = sorted.pop();
+        if (!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;
+    }
+}
+/**
+ * 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/helpers/wallet.d.ts

@@ -1,13 +1,15 @@
 import { HiddenContentSigner } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 export declare const WALLET_KIND = 17375;
+export declare const WALLET_BACKUP_KIND = 375;
 export declare const WalletPrivateKeySymbol: unique symbol;
 export declare const WalletMintsSymbol: unique symbol;
 /** Returns if a wallet is locked */
 export declare function isWalletLocked(wallet: NostrEvent): boolean;
 /** Unlocks a wallet and returns the hidden tags */
 export declare function unlockWallet(wallet: NostrEvent, signer: HiddenContentSigner): Promise<string[][]>;
+export declare function lockWallet(wallet: NostrEvent): void;
 /** Returns the wallets mints */
 export declare function getWalletMints(wallet: NostrEvent): string[];
 /** Returns the wallets private key as a string */
-export declare function getWalletPrivateKey(wallet: NostrEvent): string;
+export declare function getWalletPrivateKey(wallet: NostrEvent): Uint8Array | undefined;

package/dist/helpers/wallet.js

@@ -1,5 +1,7 @@
-import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, unlockHiddenTags, } from "applesauce-core/helpers";
+import { hexToBytes } from "@noble/hashes/utils";
+import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_KIND = 17375;
+export const WALLET_BACKUP_KIND = 375;
 export const WalletPrivateKeySymbol = Symbol.for("wallet-private-key");
 export const WalletMintsSymbol = Symbol.for("wallet-mints");
 /** Returns if a wallet is locked */
@@ -10,6 +12,11 @@ export function isWalletLocked(wallet) {
 export async function unlockWallet(wallet, signer) {
     return await unlockHiddenTags(wallet, signer);
 }
+export function lockWallet(wallet) {
+    Reflect.deleteProperty(wallet, WalletPrivateKeySymbol);
+    Reflect.deleteProperty(wallet, WalletMintsSymbol);
+    lockHiddenTags(wallet);
+}
 /** Returns the wallets mints */
 export function getWalletMints(wallet) {
     return getOrComputeCachedValue(wallet, WalletMintsSymbol, () => {
@@ -26,8 +33,6 @@ export function getWalletPrivateKey(wallet) {
         if (!tags)
             throw new Error("Wallet is locked");
         const key = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
-        if (!key)
-            throw new Error("Wallet missing private key");
-        return key;
+        return key ? hexToBytes(key) : undefined;
     });
 }

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-export * as Queries from "./queries/index.js";
+export * as Actions from "./actions/index.js";
+export * as Blueprints from "./blueprints/index.js";
 export * as Helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";
+export * from "./operations/index.js";

package/dist/index.js

@@ -1,2 +1,5 @@
-export * as Queries from "./queries/index.js";
+export * as Actions from "./actions/index.js";
+export * as Blueprints from "./blueprints/index.js";
 export * as Helpers from "./helpers/index.js";
+export * as Queries from "./queries/index.js";
+export * from "./operations/index.js";

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

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

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

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { setWalletBackupContent } from "../wallet.js";
+import { EventFactory } from "applesauce-factory";
+import { generateSecretKey } from "nostr-tools";
+import { unixNow } from "applesauce-core/helpers";
+import { WALLET_BACKUP_KIND } from "../../../helpers/wallet.js";
+import { FakeUser } from "../../../__tests__/fake-user.js";
+import { WalletBlueprint } from "../../../blueprints/wallet.js";
+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/history.d.ts

@@ -0,0 +1,7 @@
+import { EventOperation } from "applesauce-factory";
+import { HistoryContent } from "../../helpers/history.js";
+import { EventPointer } from "nostr-tools/nip19";
+/** Sets the encrypted tags of a wallet history event */
+export declare function setHistoryContent(content: HistoryContent): EventOperation;
+/** Sets the "redeemed" tags on a wallet history event */
+export declare function setHistoryRedeemed(redeemed: (string | EventPointer)[]): EventOperation;

package/dist/operations/event/history.js

@@ -0,0 +1,19 @@
+import { modifyHiddenTags, modifyPublicTags } from "applesauce-factory/operations/event";
+import { includeHistoryCreatedTags, includeHistoryRedeemedTags, setHistoryAmountTag, setHistoryDirectionTag, setHistoryFeeTag, setHistoryMintTag, } from "../tag/history.js";
+/** Sets the encrypted tags of a wallet history event */
+export function setHistoryContent(content) {
+    const operations = [
+        setHistoryDirectionTag(content.direction),
+        setHistoryAmountTag(content.amount),
+        includeHistoryCreatedTags(content.created),
+    ];
+    if (content.fee !== undefined)
+        operations.push(setHistoryFeeTag(content.fee));
+    if (content.mint !== undefined)
+        operations.push(setHistoryMintTag(content.mint));
+    return modifyHiddenTags(...operations);
+}
+/** Sets the "redeemed" tags on a wallet history event */
+export function setHistoryRedeemed(redeemed) {
+    return modifyPublicTags(includeHistoryRedeemedTags(redeemed));
+}