applesauce-wallet 0.0.0-next-20251205152544 → 0.0.0-next-20251220152312

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/{zap-info.d.ts → nutzap-info.d.ts}

@@ -1,6 +1,11 @@
 import { Proof } from "@cashu/cashu-ts";
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { NameValueTag } from "applesauce-core/helpers";
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 export declare const NUTZAP_INFO_KIND = 10019;
+/** Validated nutzap info event */
+export type NutzapInfoEvent = KnownEvent<typeof NUTZAP_INFO_KIND>;
+/** Checks if an event is a valid nutzap info event */
+export declare function isValidNutzapInfo(event: NostrEvent): event is NutzapInfoEvent;
 export declare const NutzapMintsSymbol: unique symbol;
 export declare const NutzapRelaysSymbol: unique symbol;
 /** Returns the relay URLs from a kind:10019 nutzap info event */
@@ -12,8 +17,12 @@ export declare function getNutzapInfoMints(event: NostrEvent): {
 }[];
 /** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
 export declare function getNutzapInfoPubkey(event: NostrEvent): string | undefined;
+/** Returns the P2PK pubkey from a kind:10019 nutzap info event */
+export declare function getNutzapInfoP2PKPubkey(event: NostrEvent): string | undefined;
 /**
  * verfies if proofs are locked to nutzap info
  * @throws {Error} if proofs are not locked to nutzap info
  */
 export declare function verifyProofsLocked(proofs: Proof[], info: NostrEvent): void;
+/** Creates a pubkey tag for a kind:10019 nutzap info event from a private key */
+export declare function createNutzapInfoPubkeyTag(key: Uint8Array): NameValueTag<"pubkey">;

package/dist/helpers/{zap-info.js → nutzap-info.js}

@@ -1,5 +1,10 @@
-import { getOrComputeCachedValue, mergeRelaySets, safeParse } from "applesauce-core/helpers";
+import { getOrComputeCachedValue, getPublicKey, mergeRelaySets } from "applesauce-core/helpers";
+import { getProofP2PKPubkey } from "./cashu.js";
 export const NUTZAP_INFO_KIND = 10019;
+/** Checks if an event is a valid nutzap info event */
+export function isValidNutzapInfo(event) {
+    return event.kind === NUTZAP_INFO_KIND;
+}
 // Symbols for caching computed values
 export const NutzapMintsSymbol = Symbol.for("nutzap-mints");
 export const NutzapRelaysSymbol = Symbol.for("nutzap-relays");
@@ -17,7 +22,14 @@ export function getNutzapInfoMints(event) {
 }
 /** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
 export function getNutzapInfoPubkey(event) {
-    return event.tags.find((t) => t[0] === "pubkey")?.[1];
+    const pubkey = event.tags.find((t) => t[0] === "pubkey")?.[1];
+    if (!pubkey)
+        return undefined;
+    return pubkey.length === 64 ? `02${pubkey}` : pubkey;
+}
+/** Returns the P2PK pubkey from a kind:10019 nutzap info event */
+export function getNutzapInfoP2PKPubkey(event) {
+    return getNutzapInfoPubkey(event);
 }
 /**
  * verfies if proofs are locked to nutzap info
@@ -27,16 +39,16 @@ export function verifyProofsLocked(proofs, info) {
     const pubkey = getNutzapInfoPubkey(info);
     if (!pubkey)
         throw new Error("Nutzap info must have a pubkey");
-    const fullPubkey = pubkey.length === 64 ? `02${pubkey}` : pubkey;
     for (const proof of proofs) {
-        const secret = safeParse(proof.secret);
-        if (!secret)
-            throw new Error(`Cashu token must have a spending condition`);
-        if (!Array.isArray(secret))
-            throw new Error("Invalid spending condition");
-        if (secret[0] !== "P2PK")
+        const proofPubkey = getProofP2PKPubkey(proof);
+        if (!proofPubkey)
             throw new Error("Token proofs must be P2PK locked");
-        if (secret[1].data !== fullPubkey)
+        if (proofPubkey !== pubkey)
             throw new Error("Token proofs must be P2PK locked to the recipient's nutzap pubkey");
     }
 }
+/** Creates a pubkey tag for a kind:10019 nutzap info event from a private key */
+export function createNutzapInfoPubkeyTag(key) {
+    const pubkey = "02" + getPublicKey(key);
+    return ["pubkey", pubkey];
+}

package/dist/helpers/nutzap.d.ts

@@ -31,3 +31,18 @@ export declare function getNutzapAmount(event: NostrEvent): number | undefined;
 export declare function isValidNutzap(nutzap: NostrEvent): nutzap is NutzapEvent;
 /** Checks if a nutzap event has already been redeemed based on kind:7376 wallet history events */
 export declare function isNutzapRedeemed(nutzapId: string, history: NostrEvent[]): boolean;
+/**
+ * Extracts the P2PK locking pubkey from proofs in a nutzap event
+ * @param nutzap the nutzap event containing P2PK-locked proofs
+ * @returns the pubkey that the proofs are locked to, or undefined if not found
+ * @throws {Error} if proofs are not P2PK locked or have inconsistent pubkeys
+ */
+export declare function getNutzapP2PKPubkey(nutzap: NostrEvent): string | undefined;
+/**
+ * Finds the matching private key for the P2PK lock in a nutzap event's proofs
+ * @param nutzap the nutzap event containing P2PK-locked proofs
+ * @param privateKeys array of private keys to search through
+ * @returns the matching private key, or undefined if none match
+ * @throws {Error} if proofs are not P2PK locked or have inconsistent pubkeys
+ */
+export declare function findMatchingPrivateKeyForNutzap(nutzap: NostrEvent, privateKeys: Uint8Array[]): Uint8Array | undefined;

package/dist/helpers/nutzap.js

@@ -1,5 +1,6 @@
-import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, getTagValue, isPTag, processTags, safeParse, } from "applesauce-core/helpers";
+import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, getPublicKey, getTagValue, isPTag, processTags, safeParse, } from "applesauce-core/helpers";
 import { getHistoryRedeemed } from "./history.js";
+import { getProofP2PKPubkey } from "./cashu.js";
 export const NUTZAP_KIND = 9321;
 // Symbols for caching computed values
 export const NutzapProofsSymbol = Symbol.for("nutzap-proofs");
@@ -19,21 +20,21 @@ export function getNutzapMint(event) {
 }
 export function getNutzapRecipient(event) {
     const tag = event.tags.find(isPTag);
-    return tag && getProfilePointerFromPTag(tag);
+    return tag ? (getProfilePointerFromPTag(tag) ?? undefined) : undefined;
 }
 /** Returns the event ID being nutzapped from a kind:9321 nutzap event */
 export function getNutzapEventPointer(event) {
     const tag = event.tags.find((t) => t[0] === "e");
     if (!tag)
         return;
-    return getEventPointerFromETag(tag);
+    return getEventPointerFromETag(tag) ?? undefined;
 }
 /** Returns the event ID being nutzapped from a kind:9321 nutzap event */
 export function getNutzapAddressPointer(event) {
     const tag = event.tags.find((t) => t[0] === "a");
     if (!tag)
         return;
-    return getAddressPointerFromATag(tag);
+    return getAddressPointerFromATag(tag) ?? undefined;
 }
 /** Returns the EventPointer or AddressPointer from a kind:9321 nutzap event */
 export function getNutzapPointer(event) {
@@ -54,8 +55,6 @@ export function isValidNutzap(nutzap) {
     if (nutzap.kind !== NUTZAP_KIND)
         return false;
     // Check if the nutzap has a mint, recipient, and proofs
-    if (getNutzapPointer(nutzap) === undefined)
-        return false;
     if (getNutzapMint(nutzap) === undefined)
         return false;
     if (getNutzapRecipient(nutzap) === undefined)
@@ -68,3 +67,58 @@ export function isValidNutzap(nutzap) {
 export function isNutzapRedeemed(nutzapId, history) {
     return history.some((entry) => getHistoryRedeemed(entry).includes(nutzapId));
 }
+/**
+ * Extracts the P2PK locking pubkey from proofs in a nutzap event
+ * @param nutzap the nutzap event containing P2PK-locked proofs
+ * @returns the pubkey that the proofs are locked to, or undefined if not found
+ * @throws {Error} if proofs are not P2PK locked or have inconsistent pubkeys
+ */
+export function getNutzapP2PKPubkey(nutzap) {
+    const proofs = getNutzapProofs(nutzap);
+    if (proofs.length === 0)
+        return undefined;
+    let p2pkPubkey;
+    for (const proof of proofs) {
+        const proofPubkey = getProofP2PKPubkey(proof);
+        if (!proofPubkey)
+            throw new Error("Proof is not P2PK locked");
+        if (!p2pkPubkey) {
+            p2pkPubkey = proofPubkey;
+        }
+        else if (p2pkPubkey !== proofPubkey) {
+            throw new Error("Proofs are locked to different pubkeys");
+        }
+    }
+    return p2pkPubkey;
+}
+/**
+ * Finds the matching private key for the P2PK lock in a nutzap event's proofs
+ * @param nutzap the nutzap event containing P2PK-locked proofs
+ * @param privateKeys array of private keys to search through
+ * @returns the matching private key, or undefined if none match
+ * @throws {Error} if proofs are not P2PK locked or have inconsistent pubkeys
+ */
+export function findMatchingPrivateKeyForNutzap(nutzap, privateKeys) {
+    const p2pkPubkey = getNutzapP2PKPubkey(nutzap);
+    if (!p2pkPubkey)
+        return undefined;
+    // Normalize target pubkey to full format (with 02 prefix) for comparison
+    // getNutzapP2PKPubkey already normalizes to full format, so p2pkPubkey is 66 chars
+    const targetPubkeyFull = p2pkPubkey;
+    const targetPubkeyXOnly = p2pkPubkey.length === 66 ? p2pkPubkey.slice(2) : p2pkPubkey;
+    for (const privateKey of privateKeys) {
+        try {
+            // Derive public key from private key (returns 64-char x-only format)
+            const derivedPubkey = getPublicKey(privateKey);
+            // Compare: derived pubkey is x-only, so compare both formats
+            if (derivedPubkey === targetPubkeyXOnly || `02${derivedPubkey}` === targetPubkeyFull) {
+                return privateKey;
+            }
+        }
+        catch (error) {
+            // Skip invalid private keys
+            continue;
+        }
+    }
+    return undefined;
+}

package/dist/helpers/tokens.d.ts

@@ -1,11 +1,11 @@
-import { Proof, Token } from "@cashu/cashu-ts";
+import { Proof } from "@cashu/cashu-ts";
 import { HiddenContentSigner, UnlockedHiddenContent } from "applesauce-core/helpers";
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 export declare const WALLET_TOKEN_KIND = 7375;
-/** 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;
+/** Validated wallet token event */
+export type WalletTokenEvent = KnownEvent<typeof WALLET_TOKEN_KIND>;
+/** Checks if an event is a valid wallet token event */
+export declare function isValidWalletToken(event: NostrEvent): event is WalletTokenEvent;
 export type TokenContent = {
     /** Cashu mint for the proofs */
     mint: string;
@@ -27,14 +27,14 @@ export declare const TokenContentSymbol: unique symbol;
 export type UnlockedTokenContent = UnlockedHiddenContent & {
     [TokenContentSymbol]: TokenContent;
 };
+/** Returns if token details are locked */
+export declare function isTokenContentUnlocked<T extends NostrEvent>(token: T): token is T & UnlockedTokenContent;
 /**
  * Returns the decrypted and parsed details of a 7375 token event
  * @throws {Error} If the token content is invalid
  */
 export declare function getTokenContent(token: UnlockedTokenContent): TokenContent;
 export declare function getTokenContent(token: NostrEvent): TokenContent | undefined;
-/** Returns if token details are locked */
-export declare function isTokenContentUnlocked<T extends NostrEvent>(token: T): token is T & UnlockedTokenContent;
 /** Decrypts a k:7375 token event */
 export declare function unlockTokenContent(token: NostrEvent, signer: HiddenContentSigner): Promise<TokenContent>;
 /** Removes the unencrypted hidden content */
@@ -47,19 +47,10 @@ export declare function getTokenProofsTotal(token: UnlockedTokenContent): number
 export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
 /**
  * Selects oldest tokens and proofs that total up to more than the min amount
+ * If mint is undefined, finds a mint with sufficient balance and selects only from that mint
  * @throws {Error} If there are insufficient funds
  */
 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;