applesauce-wallet 6.2.0 → 7.0.0

package/dist/actions/mint-recomendation.js

@@ -6,7 +6,7 @@ import { MINT_RECOMMENDATION_KIND, getRecommendationMintPubkey, isValidMintRecom
 async function fetchMintPubkey(mintUrl) {
     // Fetch mint info directly from the /v1/info endpoint
     const infoUrl = new URL("/v1/info", mintUrl).toString();
-    const response = await fetch(infoUrl);
+    const response = await fetch(infoUrl, { signal: AbortSignal.timeout(10_000) });
     if (!response.ok) {
         throw new Error(`Failed to fetch mint info from ${mintUrl}: ${response.statusText}`);
     }

package/dist/casts/nutzap.d.ts

@@ -11,7 +11,7 @@ export declare class Nutzap extends EventCast<NutzapEvent> {
     get sender(): import("applesauce-core/casts").User;
     get comment(): string | undefined;
     /** The pointer to the event that was zapped */
-    get zapPointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer | undefined;
+    get zapPointer(): import("nostr-tools/nip19").AddressPointer | import("nostr-tools/nip19").EventPointer | undefined;
     /** The event that was zapped */
     get zapped$(): import("applesauce-core").ChainableObservable<NostrEvent | undefined>;
 }

package/dist/helpers/animated-qr.js

@@ -1,6 +1,5 @@
 import { getEncodedToken } 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";
+import { defer, filter, interval, map, Observable, shareReplay, switchMap } from "rxjs";
 /** Preset speeds for the animated qr code */
 export const ANIMATED_QR_INTERVAL = {
     SLOW: 500,
@@ -16,45 +15,134 @@ export const ANIMATED_QR_FRAGMENTS = {
 /** 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(() => {
+    return defer(() => import("@gandlaf21/bc-ur/dist/lib/es6/index.js")).pipe(switchMap(({ UR, UREncoder }) => {
         let str = typeof token === "string" ? token : getEncodedToken(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 */
+/**
+ * An operator that decodes UR, emits progress percent and completes with final result or error.
+ * Subscribes to its source synchronously so fragments/terminal signals emitted by a hot source
+ * while bc-ur is still loading are buffered in order and drained into one decoder once ready.
+ */
 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();
+        let cancelled = false;
+        let settled = false;
+        let decoder = null;
+        const queue = [];
+        const decode = (part) => {
+            if (settled || !decoder)
+                return;
+            try {
+                decoder.receivePart(part);
+                if (decoder.isComplete() && decoder.isSuccess()) {
+                    settled = true;
+                    // 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()) {
+                    settled = true;
+                    // emit error
+                    const reason = decoder.resultError();
+                    observer.error(new Error(reason));
+                }
+                else {
+                    // emit progress
+                    const progress = decoder.estimatedPercentComplete();
+                    observer.next(progress);
+                }
+            }
+            catch (error) {
+                settled = true;
+                observer.error(error);
             }
-            else if (decoder.isError()) {
-                // emit error
-                const reason = decoder.resultError();
-                observer.error(new Error(reason));
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            observer.error(error);
+        };
+        const complete = () => {
+            if (settled)
+                return;
+            settled = true;
+            observer.error(new Error("Animated QR input completed before a complete UR was decoded"));
+        };
+        const drain = (signal) => {
+            if (signal.kind === "next")
+                decode(signal.value);
+            else if (signal.kind === "error")
+                fail(signal.error);
+            else
+                complete();
+        };
+        // subscribe to the (possibly hot) source synchronously, before bc-ur has loaded
+        const sourceSubscription = source.subscribe({
+            next: (part) => {
+                if (cancelled || settled)
+                    return;
+                if (decoder)
+                    decode(part);
+                else
+                    queue.push({ kind: "next", value: part });
+            },
+            error: (error) => {
+                if (cancelled || settled)
+                    return;
+                if (decoder)
+                    fail(error);
+                else
+                    queue.push({ kind: "error", error });
+            },
+            complete: () => {
+                if (cancelled || settled)
+                    return;
+                if (decoder)
+                    complete();
+                else
+                    queue.push({ kind: "complete" });
+            },
+        });
+        // start loading without awaiting, so the source subscription above happens synchronously
+        import("@gandlaf21/bc-ur/dist/lib/es6/index.js").then(({ URDecoder }) => {
+            if (cancelled || settled)
+                return;
+            try {
+                decoder = new URDecoder();
+                // drain buffered fragments/terminal signal in original arrival order
+                while (queue.length > 0 && !settled)
+                    drain(queue.shift());
             }
-            else {
-                // emit progress
-                const progress = decoder.estimatedPercentComplete();
-                observer.next(progress);
+            catch (error) {
+                // a throw here (e.g. a module-shape mismatch) would otherwise escape as an
+                // unhandled rejection, since promise.then(onFulfilled) never forwards its own throw
+                fail(error);
             }
+        }, (error) => {
+            if (cancelled || settled)
+                return;
+            fail(error);
         });
+        return () => {
+            cancelled = true;
+            queue.length = 0;
+            sourceSubscription.unsubscribe();
+        };
     });
 }
 /** Creates an observable that completes with decoded token */
@@ -67,5 +155,5 @@ export function receiveAnimated(input) {
     // decode UR and complete
     urDecoder(), 
     // only run one decoder
-    shareReplay(1));
+    shareReplay({ bufferSize: 1, refCount: true }));
 }

package/dist/helpers/cashu.d.ts

@@ -24,10 +24,11 @@ export declare function getProofP2PKPubkey(proof: ProofLike): string | undefined
 /** Internal method to filter out duplicate proofs */
 export declare function ignoreDuplicateProofs(seen?: Set<string>): (proof: ProofLike) => boolean;
 /**
- * Returns a decoded cashu token inside an unicode emoji
+ * Returns a decoded cashu token inside a Unicode emoji
+ * @param keysetIds Full mint keyset IDs used to resolve shortened v2 IDs
  * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
  */
-export declare function decodeTokenFromEmojiString(str: string): Token | undefined;
+export declare function decodeTokenFromEmojiString(str: string, keysetIds?: string[]): Token | undefined;
 /**
  * Encodes a token into an emoji char
  * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710

package/dist/helpers/cashu.js

@@ -42,10 +42,11 @@ export function ignoreDuplicateProofs(seen = new Set()) {
     };
 }
 /**
- * Returns a decoded cashu token inside an unicode emoji
+ * Returns a decoded cashu token inside a Unicode emoji
+ * @param keysetIds Full mint keyset IDs used to resolve shortened v2 IDs
  * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
  */
-export function decodeTokenFromEmojiString(str) {
+export function decodeTokenFromEmojiString(str, keysetIds = []) {
     try {
         let decoded = [];
         const chars = Array.from(str);
@@ -83,8 +84,7 @@ export function decodeTokenFromEmojiString(str) {
         }
         // Switch out token if we found peanut data
         let decodedString = decoded.join("");
-        // Pass an empty keyset list — works for tokens with standard hex keyset ids
-        return getDecodedToken(decodedString, []);
+        return getDecodedToken(decodedString, keysetIds);
     }
     catch (error) {
         return undefined;

package/dist/helpers/history.js

@@ -1,4 +1,4 @@
-import { getHiddenTags, hasHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, hasHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setCachedValue, 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) {
@@ -13,12 +13,11 @@ export function getHistoryRedeemed(history) {
 }
 /** Checks if the history contents are locked */
 export function isHistoryContentUnlocked(history) {
-    // Wrap in try catch to avoid throwing validation errors
-    try {
-        return (HistoryContentSymbol in history || (isHiddenTagsUnlocked(history) && getHistoryContent(history) !== undefined));
-    }
-    catch { }
-    return false;
+    // No try/catch needed: `history` is typed so the `in` test cannot throw, getHiddenTags stopped
+    // throwing on malformed content, and getHistoryContent now returns undefined rather than
+    // raising. The defensive catch this used to carry was masking those throws and silently
+    // reporting a malformed history event as merely locked.
+    return HistoryContentSymbol in history || (isHiddenTagsUnlocked(history) && getHistoryContent(history) !== undefined);
 }
 export function getHistoryContent(history) {
     // Return cached value if it exists
@@ -28,23 +27,26 @@ export function getHistoryContent(history) {
     const tags = getHiddenTags(history);
     if (!tags)
         return;
-    // Read tags
+    // Read tags. A history event missing its required tags, or carrying an unparseable amount, is
+    // unusable — return undefined rather than throwing, consistent with the locked case above and
+    // with what this getter's own return type already promises. The rejection is not cached, so the
+    // event stays readable if correct tags are decrypted in later.
     const direction = tags.find((t) => t[0] === "direction")?.[1];
     if (!direction)
-        throw new Error("History event missing direction");
+        return undefined;
     const amountStr = tags.find((t) => t[0] === "amount")?.[1];
     if (!amountStr)
-        throw new Error("History event missing amount");
+        return undefined;
     const amount = parseInt(amountStr);
     if (!Number.isFinite(amount))
-        throw new Error("Failed to parse amount");
+        return undefined;
     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]);
     const content = { direction, amount, created, mint, fee };
-    // Set the cached value
-    Reflect.set(history, HistoryContentSymbol, content);
+    // Set the cached value (identity memo, non-enumerable so a spread drops it)
+    setCachedValue(history, HistoryContentSymbol, content);
     return content;
 }
 /** Decrypts a wallet history event */

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

@@ -57,10 +57,12 @@ export class IndexedDBCouch {
         const db = await this.init();
         const id = this.generateId();
         const encodedToken = getEncodedToken(token);
+        // Token encoding shortens v2 IDs; keep full IDs for offline recovery.
+        const keysetIds = [...new Set(token.proofs.map((proof) => proof.id))];
         return new Promise((resolve, reject) => {
             const transaction = db.transaction([this.storeName], "readwrite");
             const store = transaction.objectStore(this.storeName);
-            const request = store.add({ id, encodedToken });
+            const request = store.add({ id, encodedToken, keysetIds });
             request.onsuccess = () => {
                 // Return a function to remove this specific token by ID
                 resolve(async () => {
@@ -98,7 +100,7 @@ export class IndexedDBCouch {
         return stored
             .map((item) => {
             try {
-                return getDecodedToken(item.encodedToken, []);
+                return getDecodedToken(item.encodedToken, item.keysetIds ?? []);
             }
             catch {
                 return null;

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

@@ -22,8 +22,10 @@ export class LocalStorageCouch {
     store(token) {
         const id = this.generateId();
         const encodedToken = getEncodedToken(token);
+        // Token encoding shortens v2 IDs; keep full IDs for offline recovery.
+        const keysetIds = [...new Set(token.proofs.map((proof) => proof.id))];
         const stored = this.getStoredTokens();
-        stored.push({ id, encodedToken });
+        stored.push({ id, encodedToken, keysetIds });
         this.saveStoredTokens(stored);
         // Return a function to remove this specific token by ID
         return () => {
@@ -47,7 +49,7 @@ export class LocalStorageCouch {
         return this.getStoredTokens()
             .map((item) => {
             try {
-                return getDecodedToken(item.encodedToken, []);
+                return getDecodedToken(item.encodedToken, item.keysetIds ?? []);
             }
             catch {
                 return null;

package/dist/helpers/nutzap.d.ts

@@ -34,15 +34,19 @@ export declare function isNutzapRedeemed(nutzapId: string, history: NostrEvent[]
 /**
  * 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
+ * @returns the single pubkey every proof is locked to, or undefined if there is no such pubkey —
+ * no proofs, a proof that is not P2PK locked, or proofs locked to more than one pubkey. A nutzap
+ * arrives from a stranger, so all three are hostile input rather than programmer errors, and none
+ * of them throw. This matches getProofP2PKPubkey one level down, which already returns undefined
+ * for every failure.
  */
 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
+ * @returns the matching private key, or undefined if none match — including when the nutzap has no
+ * single P2PK pubkey to match against, which getNutzapP2PKPubkey now reports as undefined rather
+ * than by throwing
  */
 export declare function findMatchingPrivateKeyForNutzap(nutzap: NostrEvent, privateKeys: Uint8Array[]): Uint8Array | undefined;

package/dist/helpers/nutzap.js

@@ -70,8 +70,11 @@ export function isNutzapRedeemed(nutzapId, history) {
 /**
  * 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
+ * @returns the single pubkey every proof is locked to, or undefined if there is no such pubkey —
+ * no proofs, a proof that is not P2PK locked, or proofs locked to more than one pubkey. A nutzap
+ * arrives from a stranger, so all three are hostile input rather than programmer errors, and none
+ * of them throw. This matches getProofP2PKPubkey one level down, which already returns undefined
+ * for every failure.
  */
 export function getNutzapP2PKPubkey(nutzap) {
     const proofs = getNutzapProofs(nutzap);
@@ -81,12 +84,14 @@ export function getNutzapP2PKPubkey(nutzap) {
     for (const proof of proofs) {
         const proofPubkey = getProofP2PKPubkey(proof);
         if (!proofPubkey)
-            throw new Error("Proof is not P2PK locked");
+            return undefined;
         if (!p2pkPubkey) {
             p2pkPubkey = proofPubkey;
         }
         else if (p2pkPubkey !== proofPubkey) {
-            throw new Error("Proofs are locked to different pubkeys");
+            // Mixed locks mean there is no single pubkey to report, so the answer is undefined rather
+            // than the first one seen — returning p2pkPubkey here would silently hide the mismatch.
+            return undefined;
         }
     }
     return p2pkPubkey;
@@ -95,8 +100,9 @@ export function getNutzapP2PKPubkey(nutzap) {
  * 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
+ * @returns the matching private key, or undefined if none match — including when the nutzap has no
+ * single P2PK pubkey to match against, which getNutzapP2PKPubkey now reports as undefined rather
+ * than by throwing
  */
 export function findMatchingPrivateKeyForNutzap(nutzap, privateKeys) {
     const p2pkPubkey = getNutzapP2PKPubkey(nutzap);

package/dist/helpers/tokens.d.ts

@@ -38,7 +38,12 @@ export type UnlockedTokenContent = UnlockedHiddenContent & {
 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
+ *
+ * Returns undefined for anything that does not yield usable content — still locked, not valid
+ * JSON, not an object, or missing `mint`/`proofs`. None of these throw: this getter is read from
+ * inside RxJS pipes (see WalletToken's `meta$`), where a throw errors the observable and is
+ * terminal, killing the wallet's token stream rather than skipping one malformed event.
+ * `unlockTokenContent` is the imperative counterpart that does throw.
  */
 export declare function getTokenContent(token: UnlockedTokenContent): TokenContent;
 export declare function getTokenContent(token: NostrEvent): TokenContent | undefined;

package/dist/helpers/tokens.js

@@ -1,4 +1,4 @@
-import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, notifyEventUpdate, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, notifyEventUpdate, safeParse, setCachedValue, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
 import { ignoreDuplicateProofs } from "./cashu.js";
 export const WALLET_TOKEN_KIND = 7375;
 /** Checks if an event is a valid wallet token event */
@@ -21,12 +21,11 @@ setHiddenContentEncryptionMethod(WALLET_TOKEN_KIND, "nip44");
 export const TokenContentSymbol = Symbol.for("token-content");
 /** Returns if token details are locked */
 export function isTokenContentUnlocked(token) {
-    // Wrap in try catch to avoid throwing validation errors
-    try {
-        return TokenContentSymbol in token || (isHiddenContentUnlocked(token) && getTokenContent(token) !== undefined);
-    }
-    catch { }
-    return false;
+    // No try/catch needed: `token` is typed so the `in` test cannot throw, and neither
+    // isHiddenContentUnlocked nor getTokenContent throws — getTokenContent returns undefined for
+    // malformed content rather than raising. The defensive catch this used to carry was masking
+    // that throw and silently reporting a malformed token as merely locked.
+    return TokenContentSymbol in token || (isHiddenContentUnlocked(token) && getTokenContent(token) !== undefined);
 }
 export function getTokenContent(token) {
     if (TokenContentSymbol in token)
@@ -35,17 +34,24 @@ export function getTokenContent(token) {
     const plaintext = getHiddenContent(token);
     if (!plaintext)
         return undefined;
-    // Parse the content as a token content
-    const details = JSON.parse(plaintext);
-    // Throw an error if the token content is invalid
+    // Parse the content as a token content. safeParse (not JSON.parse) so malformed content
+    // returns undefined instead of throwing out of a getter.
+    const details = safeParse(plaintext);
+    // Shape guard BEFORE any property read: safeParse("null") yields null and `null.mint` throws a
+    // TypeError, which would just swap one throw for another.
+    if (!details || typeof details !== "object")
+        return undefined;
+    // Content missing its required fields is unusable. Returning undefined (rather than throwing)
+    // keeps this consistent with the locked and unparseable cases above, and the rejection is
+    // deliberately not cached — a token stays readable if correct content is decrypted in later.
     if (!details.mint)
-        throw new Error("Token missing mint");
+        return undefined;
     if (!details.proofs)
-        throw new Error("Token missing proofs");
+        return undefined;
     if (!details.del)
         details.del = [];
-    // Set the cached value
-    Reflect.set(token, TokenContentSymbol, details);
+    // Set the cached value (identity memo, non-enumerable so a spread drops it)
+    setCachedValue(token, TokenContentSymbol, details);
     return details;
 }
 /** Decrypts a k:7375 token event */

package/dist/helpers/wallet.js

@@ -1,4 +1,4 @@
-import { getHiddenTags, hasHiddenTags, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, relaySet, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, hasHiddenTags, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, relaySet, setCachedValue, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 import { hexToBytes } from "applesauce-core/helpers/event";
 export const WALLET_KIND = 17375;
 export const WALLET_BACKUP_KIND = 375;
@@ -27,8 +27,8 @@ export function getWalletMints(wallet) {
         return undefined;
     // Get mints
     const mints = tags.filter((t) => t[0] === "mint").map((t) => t[1]);
-    // Set the cached value
-    Reflect.set(wallet, WalletMintsSymbol, mints);
+    // Set the cached value (identity memo, non-enumerable so a spread drops it)
+    setCachedValue(wallet, WalletMintsSymbol, mints);
     return mints;
 }
 export function getWalletPrivateKey(wallet) {
@@ -41,8 +41,11 @@ export function getWalletPrivateKey(wallet) {
     // Parse private key
     const privkey = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
     const key = privkey ? hexToBytes(privkey) : null;
-    // Set the cached value
-    Reflect.set(wallet, WalletPrivateKeySymbol, key);
+    // Set the cached value (identity memo, non-enumerable so a spread drops it). This is a V8
+    // improvement: the decrypted private key no longer rides along on an unrelated plain-object
+    // spread of the wallet event. The key itself is still held in memory for this wallet
+    // instance's lifetime -- no lock primitive is added here, that stays out of this phase's scope.
+    setCachedValue(wallet, WalletPrivateKeySymbol, key);
     return key;
 }
 export function getWalletRelays(wallet) {
@@ -56,8 +59,8 @@ export function getWalletRelays(wallet) {
     // Get relays
     const urls = tags.filter((t) => t[0] === "relay" && t[1]).map((t) => t[1]);
     const relays = relaySet(urls);
-    // Set the cached value
-    Reflect.set(wallet, WalletRelaysSymbol, relays);
+    // Set the cached value (identity memo, non-enumerable so a spread drops it)
+    setCachedValue(wallet, WalletRelaysSymbol, relays);
     return relays;
 }
 /** Unlocks a wallet and returns the hidden tags */
@@ -86,5 +89,6 @@ export async function unlockWallet(wallet, signer) {
 export function lockWallet(wallet) {
     Reflect.deleteProperty(wallet, WalletPrivateKeySymbol);
     Reflect.deleteProperty(wallet, WalletMintsSymbol);
+    Reflect.deleteProperty(wallet, WalletRelaysSymbol);
     lockHiddenTags(wallet);
 }

package/dist/wallet/loading.d.ts

@@ -1,6 +1,5 @@
-import type { EventStore } from "applesauce-core";
+import type { Debugger, EventStore } from "applesauce-core";
 import { RelayPool } from "applesauce-relay";
-import type { Debugger } from "debug";
 import { Observable } from "rxjs";
 /** A status update emitted while loading a wallet's events */
 export type WalletLoaderStatus = {

package/dist/wallet/nut-wallet.d.ts

@@ -1,14 +1,13 @@
 import { type MeltProofsResponse, type MeltQuoteBaseResponse, Mint, type MintQuoteBolt11Response, type Proof, Token, Wallet as CashuWallet } from "@cashu/cashu-ts";
 import { ActionRunner } from "applesauce-actions";
-import { ChainableObservable, EventStore } from "applesauce-core";
+import { ChainableObservable, EventStore, type Debugger } from "applesauce-core";
 import { User } from "applesauce-core/casts";
 import type { NostrEvent } from "applesauce-core/helpers";
 import { type EncryptedContentCache } from "applesauce-common/helpers";
 import type { RelayPool } from "applesauce-relay";
 import type { ISigner } from "applesauce-signers";
-import type { Debugger } from "debug";
 import { BehaviorSubject, Observable, Subscription } from "rxjs";
-import "../casts/__register__";
+import "../casts/__register__.js";
 import type { WalletHistory } from "../casts/wallet-history.js";
 import type { WalletToken } from "../casts/wallet-token.js";
 import type { Wallet } from "../casts/wallet.js";

package/dist/wallet/nut-wallet.js

@@ -1,13 +1,13 @@
-import { getDecodedToken, getEncodedToken, Mint, MintQuoteState, Wallet as CashuWallet, } from "@cashu/cashu-ts";
+import { getTokenMetadata, getEncodedToken, Mint, MintQuoteState, Wallet as CashuWallet, } from "@cashu/cashu-ts";
 import { ActionRunner } from "applesauce-actions";
-import { logger as baseLogger, chainable } from "applesauce-core";
+import { logger as baseLogger, chainable, } from "applesauce-core";
 import { castUser } from "applesauce-core/casts";
 import { addSeenRelay, canHaveEncryptedContent, getEncryptedContent, getOutboxes, getSeenRelays, isEncryptedContentUnlocked, kinds, normalizeURL, notifyEventUpdate, relaySet, setEncryptedContentCache, } from "applesauce-core/helpers";
 import { isEncryptedContentFromCache, markEncryptedContentFromCache, } from "applesauce-common/helpers";
 import { BehaviorSubject, combineLatest, isObservable, of } from "rxjs";
 import { distinctUntilChanged, map, shareReplay, startWith, switchMap } from "rxjs/operators";
 // Ensure the User.wallet$ is setup
-import "../casts/__register__";
+import "../casts/__register__.js";
 import { CleanupDeletedTokens, ConsolidateTokens, CreateWallet, MintTokens, ReceiveToken, ReceiveNutzaps, RecoverFromCouch, RolloverTokens, SetWalletMints, SetWalletRelays, TokensOperation, UnlockWallet, } from "../actions/index.js";
 import { lockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
 import { lockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
@@ -446,11 +446,12 @@ export class NutWallet {
     /** Receives a Cashu token (encoded string or decoded {@link Token}) into the wallet */
     async receiveToken(token) {
         await this.track("receive", async () => {
-            const decoded = typeof token === "string" ? getDecodedToken(token, []) : token;
-            if (!decoded)
-                throw new Error("Failed to decode token");
+            const metadata = typeof token === "string" ? getTokenMetadata(token) : token;
+            if (metadata.unit && metadata.unit !== "sat")
+                throw new Error("Only sat tokens are supported");
+            const wallet = await this.getCashuWallet(metadata.mint);
+            const decoded = typeof token === "string" ? wallet.decodeToken(token) : token;
             this.log("Receiving token from mint %s", decoded.mint);
-            const wallet = await this.getCashuWallet(decoded.mint);
             await this.actions.run(ReceiveToken, decoded, { couch: this.couch, wallet, getCashuWallet: this.getCashuWallet });
             await this.refreshCouch();
         });

package/dist/wallet/types.d.ts

@@ -1,9 +1,8 @@
 import type { MeltProofsResponse, MeltQuoteBolt11Response, MintQuoteBolt11Response } from "@cashu/cashu-ts";
-import type { EventStore } from "applesauce-core";
+import type { Debugger, EventStore } from "applesauce-core";
 import type { EncryptedContentCache } from "applesauce-common/helpers";
 import type { ISigner } from "applesauce-signers";
 import type { RelayPool } from "applesauce-relay";
-import type { Debugger } from "debug";
 import type { Observable } from "rxjs";
 import type { WalletToken } from "../casts/wallet-token.js";
 import type { Couch } from "../helpers/couch.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet",
-  "version": "6.2.0",
+  "version": "7.0.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -87,27 +87,25 @@
     }
   },
   "dependencies": {
-    "@cashu/cashu-ts": "^4.5.1",
+    "@cashu/cashu-ts": "^4.11.0",
     "@gandlaf21/bc-ur": "^1.1.12",
-    "applesauce-actions": "^6.2.0",
-    "applesauce-common": "^6.2.0",
-    "applesauce-core": "^6.2.0",
-    "applesauce-loaders": "^6.2.0",
-    "debug": "^4.4.3",
+    "applesauce-actions": "^7.0.0",
+    "applesauce-common": "^7.0.0",
+    "applesauce-core": "^7.0.0",
+    "applesauce-loaders": "^7.0.0",
     "rxjs": "^7.8.2"
   },
   "peerDependencies": {
-    "applesauce-relay": "^6.0.3",
-    "applesauce-signers": "^6.0.0"
+    "applesauce-relay": "^7.0.0",
+    "applesauce-signers": "^7.0.0"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
-    "@types/debug": "^4.1.13",
-    "applesauce-relay": "^6.2.0",
-    "applesauce-signers": "^6.2.0",
+    "applesauce-relay": "^7.0.0",
+    "applesauce-signers": "^7.0.0",
     "rimraf": "^6.1.3",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.8"
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
   },
   "funding": {
     "type": "lightning",