applesauce-wallet 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/helpers/cashu.js

@@ -0,0 +1,105 @@
+import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
+import { safeParse } 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;
+}
+/**
+ * Extracts the P2PK locking pubkey from a proof's secret
+ * @param proof the cashu proof to extract the pubkey from
+ * @returns the pubkey, or undefined if not P2PK locked
+ */
+export function getProofP2PKPubkey(proof) {
+    const secret = safeParse(proof.secret);
+    if (!secret)
+        return;
+    if (!Array.isArray(secret))
+        return;
+    if (secret[0] !== "P2PK")
+        return;
+    const proofPubkey = secret[1]?.data;
+    if (!proofPubkey || typeof proofPubkey !== "string")
+        return;
+    return proofPubkey;
+}
+/** 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;
+        }
+    };
+}
+/**
+ * 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/couch.d.ts

@@ -0,0 +1,11 @@
+import { Token } from "@cashu/cashu-ts";
+type ClearMethod = () => void | Promise<void>;
+export interface Couch {
+    /** Store a token in the couch */
+    store(token: Token): ClearMethod | Promise<ClearMethod>;
+    /** Clear all tokens from the couch */
+    clear(): void | Promise<void>;
+    /** Get all tokens currently stored in the couch */
+    getAll(): Token[] | Promise<Token[]>;
+}
+export {};

package/dist/helpers/couch.js

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

package/dist/helpers/history.d.ts

@@ -1,6 +1,10 @@
 import { HiddenContentSigner, UnlockedHiddenTags } from "applesauce-core/helpers";
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 export declare const WALLET_HISTORY_KIND = 7376;
+/** Validated wallet history event */
+export type WalletHistoryEvent = KnownEvent<typeof WALLET_HISTORY_KIND>;
+/** Checks if an event is a valid wallet history event */
+export declare function isValidWalletHistory(event: NostrEvent): event is WalletHistoryEvent;
 export type HistoryDirection = "in" | "out";
 export type HistoryContent = {
     /** The direction of the transaction, in = received, out = sent */

package/dist/helpers/history.js

@@ -1,5 +1,9 @@
-import { getHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, hasHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_HISTORY_KIND = 7376;
+/** Checks if an event is a valid wallet history event */
+export function isValidWalletHistory(event) {
+    return event.kind === WALLET_HISTORY_KIND && hasHiddenTags(event);
+}
 // Enable hidden content for wallet history kind
 setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
 export const HistoryContentSymbol = Symbol.for("history-content");
@@ -9,11 +13,16 @@ export function getHistoryRedeemed(history) {
 }
 /** Checks if the history contents are locked */
 export function isHistoryContentUnlocked(history) {
-    return isHiddenTagsUnlocked(history) && Reflect.has(history, HistoryContentSymbol) === true;
+    // Wrap in try catch to avoid throwing validation errors
+    try {
+        return (HistoryContentSymbol in history || (isHiddenTagsUnlocked(history) && getHistoryContent(history) !== undefined));
+    }
+    catch { }
+    return false;
 }
 export function getHistoryContent(history) {
     // Return cached value if it exists
-    if (isHistoryContentUnlocked(history))
+    if (HistoryContentSymbol in history)
         return history[HistoryContentSymbol];
     // Get hidden tags
     const tags = getHiddenTags(history);
@@ -41,7 +50,7 @@ export function getHistoryContent(history) {
 /** Decrypts a wallet history event */
 export async function unlockHistoryContent(history, signer) {
     // Return cached value if it exists
-    if (isHistoryContentUnlocked(history))
+    if (HistoryContentSymbol in history)
         return history[HistoryContentSymbol];
     // Unlock hidden tags if needed
     await unlockHiddenTags(history, signer);

package/dist/helpers/index.d.ts

@@ -2,5 +2,11 @@ export * from "./animated-qr.js";
 export * from "./history.js";
 export * from "./tokens.js";
 export * from "./wallet.js";
-export * from "./zap-info.js";
+export * from "./nutzap-info.js";
 export * from "./nutzap.js";
+export * from "./cashu.js";
+export * from "./couch.js";
+export * from "./local-storage-couch.js";
+export * from "./indexed-db-couch.js";
+export * from "./mint-info.js";
+export * from "./mint-recommendation.js";

package/dist/helpers/index.js

@@ -2,5 +2,11 @@ export * from "./animated-qr.js";
 export * from "./history.js";
 export * from "./tokens.js";
 export * from "./wallet.js";
-export * from "./zap-info.js";
+export * from "./nutzap-info.js";
 export * from "./nutzap.js";
+export * from "./cashu.js";
+export * from "./couch.js";
+export * from "./local-storage-couch.js";
+export * from "./indexed-db-couch.js";
+export * from "./mint-info.js";
+export * from "./mint-recommendation.js";

package/dist/helpers/indexed-db-couch.d.ts

@@ -0,0 +1,34 @@
+import { Token } from "@cashu/cashu-ts";
+import type { Couch } from "./couch.js";
+/**
+ * A simple IndexedDB-based implementation of the Couch interface.
+ * Stores tokens in the browser's IndexedDB for better performance with larger datasets.
+ */
+export declare class IndexedDBCouch implements Couch {
+    private dbName;
+    private storeName;
+    private db;
+    private initPromise;
+    constructor(dbName?: string, storeName?: string);
+    /**
+     * Generate a unique ID for each stored token.
+     */
+    private generateId;
+    /**
+     * Initialize the IndexedDB database and object store.
+     */
+    private init;
+    /**
+     * Store a token in the couch.
+     * Returns a function that can be called to remove this specific token.
+     */
+    store(token: Token): Promise<() => Promise<void>>;
+    /**
+     * Clear all tokens from the couch.
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all tokens currently stored in the couch.
+     */
+    getAll(): Promise<Token[]>;
+}

package/dist/helpers/indexed-db-couch.js

@@ -0,0 +1,119 @@
+import { getEncodedToken, getDecodedToken } from "@cashu/cashu-ts";
+const DB_NAME = "applesauce-wallet-couch";
+const STORE_NAME = "tokens";
+const DB_VERSION = 1;
+/**
+ * A simple IndexedDB-based implementation of the Couch interface.
+ * Stores tokens in the browser's IndexedDB for better performance with larger datasets.
+ */
+export class IndexedDBCouch {
+    dbName;
+    storeName;
+    db = null;
+    initPromise = null;
+    constructor(dbName = DB_NAME, storeName = STORE_NAME) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+    }
+    /**
+     * Generate a unique ID for each stored token.
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Initialize the IndexedDB database and object store.
+     */
+    async init() {
+        if (this.db)
+            return this.db;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = new Promise((resolve, reject) => {
+            if (typeof window === "undefined" || !window.indexedDB) {
+                reject(new Error("IndexedDB is not available"));
+                return;
+            }
+            const request = window.indexedDB.open(this.dbName, DB_VERSION);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    db.createObjectStore(this.storeName, { keyPath: "id" });
+                }
+            };
+        });
+        return this.initPromise;
+    }
+    /**
+     * Store a token in the couch.
+     * Returns a function that can be called to remove this specific token.
+     */
+    async store(token) {
+        const db = await this.init();
+        const id = this.generateId();
+        const encodedToken = getEncodedToken(token);
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.add({ id, encodedToken });
+            request.onsuccess = () => {
+                // Return a function to remove this specific token by ID
+                resolve(async () => {
+                    const removeDb = await this.init();
+                    const removeTransaction = removeDb.transaction([this.storeName], "readwrite");
+                    const removeStore = removeTransaction.objectStore(this.storeName);
+                    const removeRequest = removeStore.delete(id);
+                    await new Promise((resolve, reject) => {
+                        removeRequest.onsuccess = () => resolve();
+                        removeRequest.onerror = () => reject(removeRequest.error);
+                    });
+                });
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Clear all tokens from the couch.
+     */
+    async clear() {
+        const db = await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Get all tokens currently stored in the couch.
+     */
+    async getAll() {
+        const db = await this.init();
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.getAll();
+            request.onsuccess = () => {
+                const results = request.result;
+                const tokens = results
+                    .map((item) => {
+                    try {
+                        return getDecodedToken(item.encodedToken);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((token) => token !== null);
+                resolve(tokens);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+}

package/dist/helpers/local-storage-couch.d.ts

@@ -0,0 +1,29 @@
+import { Token } from "@cashu/cashu-ts";
+import type { Couch } from "./couch.js";
+/**
+ * A simple localStorage-based implementation of the Couch interface.
+ * Stores tokens in the browser's localStorage.
+ */
+export declare class LocalStorageCouch implements Couch {
+    private storageKey;
+    constructor(storageKey?: string);
+    /**
+     * Generate a unique ID for each stored token.
+     */
+    private generateId;
+    /**
+     * Store a token in the couch.
+     * Returns a function that can be called to remove this specific token.
+     */
+    store(token: Token): () => void;
+    /**
+     * Clear all tokens from the couch.
+     */
+    clear(): void;
+    /**
+     * Get all tokens currently stored in the couch.
+     */
+    getAll(): Token[];
+    private getStoredTokens;
+    private saveStoredTokens;
+}

package/dist/helpers/local-storage-couch.js

@@ -0,0 +1,78 @@
+import { getEncodedToken, getDecodedToken } from "@cashu/cashu-ts";
+const STORAGE_KEY = "applesauce:couch:tokens";
+/**
+ * A simple localStorage-based implementation of the Couch interface.
+ * Stores tokens in the browser's localStorage.
+ */
+export class LocalStorageCouch {
+    storageKey;
+    constructor(storageKey = STORAGE_KEY) {
+        this.storageKey = storageKey;
+    }
+    /**
+     * Generate a unique ID for each stored token.
+     */
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Store a token in the couch.
+     * Returns a function that can be called to remove this specific token.
+     */
+    store(token) {
+        const id = this.generateId();
+        const encodedToken = getEncodedToken(token);
+        const stored = this.getStoredTokens();
+        stored.push({ id, encodedToken });
+        this.saveStoredTokens(stored);
+        // Return a function to remove this specific token by ID
+        return () => {
+            const currentStored = this.getStoredTokens();
+            const filtered = currentStored.filter((item) => item.id !== id);
+            this.saveStoredTokens(filtered);
+        };
+    }
+    /**
+     * Clear all tokens from the couch.
+     */
+    clear() {
+        if (typeof window !== "undefined" && window.localStorage) {
+            window.localStorage.removeItem(this.storageKey);
+        }
+    }
+    /**
+     * Get all tokens currently stored in the couch.
+     */
+    getAll() {
+        const stored = this.getStoredTokens();
+        return stored
+            .map((item) => {
+            try {
+                return getDecodedToken(item.encodedToken);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((token) => token !== null);
+    }
+    getStoredTokens() {
+        if (typeof window === "undefined" || !window.localStorage) {
+            return [];
+        }
+        try {
+            const stored = window.localStorage.getItem(this.storageKey);
+            if (!stored)
+                return [];
+            return JSON.parse(stored);
+        }
+        catch {
+            return [];
+        }
+    }
+    saveStoredTokens(tokens) {
+        if (typeof window !== "undefined" && window.localStorage) {
+            window.localStorage.setItem(this.storageKey, JSON.stringify(tokens));
+        }
+    }
+}

package/dist/helpers/mint-info.d.ts

@@ -0,0 +1,40 @@
+import { KnownEvent } from "applesauce-core/helpers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+export declare const CASHU_MINT_INFO_KIND = 38172;
+export type CashuMintInfoEvent = KnownEvent<typeof CASHU_MINT_INFO_KIND>;
+export type NetworkType = "mainnet" | "testnet" | "signet" | "regtest";
+export declare const CashuMintPubkeySymbol: unique symbol;
+export declare const CashuMintURLSymbol: unique symbol;
+export declare const CashuMintNutsSymbol: unique symbol;
+export declare const CashuMintNetworkSymbol: unique symbol;
+/**
+ * Returns the mint's pubkey from a kind:38172 cashu mint info event
+ * This is found in the `d` tag and is the pubkey from the mint's `/v1/info` endpoint
+ */
+export declare function getCashuMintPubkey(event: NostrEvent): string | undefined;
+/**
+ * Returns the mint URL from a kind:38172 cashu mint info event
+ * This is the URL to the cashu mint (from the `u` tag)
+ */
+export declare function getCashuMintURL(event: CashuMintInfoEvent): string;
+export declare function getCashuMintURL(event: NostrEvent): string | undefined;
+/**
+ * Returns the supported nuts from a kind:38172 cashu mint info event
+ * This is a comma-separated list of nut numbers (e.g., "1,2,3,4,5,6,7")
+ */
+export declare function getCashuMintNuts(event: NostrEvent): number[];
+/**
+ * Returns the network type from a kind:38172 cashu mint info event
+ * Should be one of: mainnet, testnet, signet, or regtest
+ */
+export declare function getCashuMintNetwork(event: NostrEvent): NetworkType | undefined;
+/**
+ * Returns the optional metadata content from a kind:38172 cashu mint info event
+ * This is a kind:0-style metadata JSON object, useful when the pubkey is not a normal user
+ */
+export declare function getCashuMintMetadata(event: NostrEvent): Record<string, any> | undefined;
+/**
+ * Validates that an event is a proper kind:38172 cashu mint info event
+ * Checks that the event is kind 38172 and has the required `d` and `u` tags
+ */
+export declare function isValidCashuMintInfo(event?: NostrEvent): event is CashuMintInfoEvent;

package/dist/helpers/mint-info.js

@@ -0,0 +1,80 @@
+import { getOrComputeCachedValue, getTagValue, isHex, safeParse } from "applesauce-core/helpers";
+import { getReplaceableIdentifier } from "applesauce-core/helpers/event";
+// NIP-87 Cashu Mint Information Event Kind
+export const CASHU_MINT_INFO_KIND = 38172;
+// Symbols for caching computed values
+export const CashuMintPubkeySymbol = Symbol.for("cashu-mint-pubkey");
+export const CashuMintURLSymbol = Symbol.for("cashu-mint-url");
+export const CashuMintNutsSymbol = Symbol.for("cashu-mint-nuts");
+export const CashuMintNetworkSymbol = Symbol.for("cashu-mint-network");
+// ============================================================================
+// Cashu Mint Information Event (kind:38172) Helpers
+// ============================================================================
+/**
+ * Returns the mint's pubkey from a kind:38172 cashu mint info event
+ * This is found in the `d` tag and is the pubkey from the mint's `/v1/info` endpoint
+ */
+export function getCashuMintPubkey(event) {
+    return getOrComputeCachedValue(event, CashuMintPubkeySymbol, () => {
+        const identifier = getReplaceableIdentifier(event);
+        // Only return hex pubkeys
+        if (!isHex(identifier))
+            return undefined;
+        return identifier || undefined;
+    });
+}
+export function getCashuMintURL(event) {
+    return getOrComputeCachedValue(event, CashuMintURLSymbol, () => {
+        const url = getTagValue(event, "u");
+        return url && URL.canParse(url) ? url : undefined;
+    });
+}
+/**
+ * Returns the supported nuts from a kind:38172 cashu mint info event
+ * This is a comma-separated list of nut numbers (e.g., "1,2,3,4,5,6,7")
+ */
+export function getCashuMintNuts(event) {
+    return getOrComputeCachedValue(event, CashuMintNutsSymbol, () => {
+        const nutsStr = getTagValue(event, "nuts");
+        if (!nutsStr)
+            return [];
+        return nutsStr
+            .split(",")
+            .map((n) => parseInt(n.trim(), 10))
+            .filter((n) => !isNaN(n));
+    });
+}
+/**
+ * Returns the network type from a kind:38172 cashu mint info event
+ * Should be one of: mainnet, testnet, signet, or regtest
+ */
+export function getCashuMintNetwork(event) {
+    return getOrComputeCachedValue(event, CashuMintNetworkSymbol, () => {
+        const network = getTagValue(event, "n");
+        if (!network)
+            return undefined;
+        const validNetworks = ["mainnet", "testnet", "signet", "regtest"];
+        return validNetworks.includes(network) ? network : undefined;
+    });
+}
+/**
+ * Returns the optional metadata content from a kind:38172 cashu mint info event
+ * This is a kind:0-style metadata JSON object, useful when the pubkey is not a normal user
+ */
+export function getCashuMintMetadata(event) {
+    if (!event.content)
+        return undefined;
+    return safeParse(event.content);
+}
+/**
+ * Validates that an event is a proper kind:38172 cashu mint info event
+ * Checks that the event is kind 38172 and has the required `d` and `u` tags
+ */
+export function isValidCashuMintInfo(event) {
+    if (!event)
+        return false;
+    if (event.kind !== CASHU_MINT_INFO_KIND)
+        return false;
+    const url = getCashuMintURL(event);
+    return url !== undefined;
+}

package/dist/helpers/mint-recommendation.d.ts

@@ -0,0 +1,41 @@
+import { KnownEvent } from "applesauce-core/helpers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+export declare const MINT_RECOMMENDATION_KIND = 38000;
+export type MintRecommendationEvent = KnownEvent<typeof MINT_RECOMMENDATION_KIND>;
+export declare const RecommendationKindSymbol: unique symbol;
+export declare const RecommendationURLSymbol: unique symbol;
+export declare const RecommendationAddressPointerSymbol: unique symbol;
+/**
+ * Returns the recommended event kind from a kind:38000 recommendation event
+ * This should be 38172 for cashu mints
+ */
+export declare function getRecommendationKind(event: MintRecommendationEvent): number;
+export declare function getRecommendationKind(event: NostrEvent): number | undefined;
+/**
+ * Returns the d-identifier from a kind:38000 recommendation event
+ * This is the kind:38172 event identifier this event is recommending
+ */
+export declare function getRecommendationMintPubkey(event: NostrEvent): string | undefined;
+/**
+ * Returns the URL from a kind:38000 recommendation event
+ * This is an optional `u` tag that provides a recommended way to connect to the cashu mint
+ * Each recommendation event recommends a single mint, so there is at most one `u` tag
+ */
+export declare function getRecommendationURL(event: MintRecommendationEvent): string | undefined;
+export declare function getRecommendationURL(event: NostrEvent): string | undefined;
+/**
+ * Returns the address pointer from a kind:38000 recommendation event
+ * This `a` tag points to the kind:38172 event of the cashu mint
+ * The first value is the event identifier, the second value is a relay hint
+ * Each recommendation event recommends a single mint, so there is at most one `a` tag
+ */
+export declare function getRecommendationAddressPointer(event: MintRecommendationEvent): AddressPointer | undefined;
+export declare function getRecommendationAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/**
+ * Validates that an event is a proper kind:38000 recommendation event
+ * Checks that the event is kind 38000, has the required `k` and `d` tags,
+ * and that the `k` tag is 38172 (cashu mint kind)
+ * Each recommendation event recommends a single cashu mint
+ */
+export declare function isValidMintRecommendation(event?: NostrEvent): event is MintRecommendationEvent;