applesauce-wallet 3.1.0 → 4.0.0

package/dist/actions/tokens.js

@@ -1,6 +1,6 @@
 import { CashuMint, CashuWallet, CheckStateEnum } from "@cashu/cashu-ts";
 import { DeleteBlueprint } from "applesauce-factory/blueprints";
-import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentUnlocked, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
 import { WalletTokenBlueprint } from "../blueprints/tokens.js";
 import { WalletHistoryBlueprint } from "../blueprints/history.js";
 /**
@@ -37,7 +37,7 @@ export function CompleteSpend(spent, change) {
     return async function* ({ factory }) {
         if (spent.length === 0)
             throw new Error("Cant complete spent with no token events");
-        if (spent.some((s) => isTokenContentLocked(s)))
+        if (spent.some((s) => isTokenContentUnlocked(s)))
             throw new Error("Cant complete spend with locked tokens");
         // create the nip-09 delete event for previous events
         const deleteDraft = await factory.create(DeleteBlueprint, spent);
@@ -67,7 +67,7 @@ export function CompleteSpend(spent, change) {
 export function ConsolidateTokens(opts) {
     return async function* ({ events, factory, self }) {
         const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
-            if (isTokenContentLocked(token)) {
+            if (isTokenContentUnlocked(token)) {
                 if (opts?.ignoreLocked)
                     return false;
                 else

package/dist/actions/wallet.js

@@ -1,7 +1,7 @@
-import { getWalletMints, getWalletPrivateKey, isWalletLocked, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
+import { getWalletMints, getWalletPrivateKey, isWalletUnlocked, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
 import { WalletBackupBlueprint, WalletBlueprint } from "../blueprints/wallet.js";
-import { isTokenContentLocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
-import { isHistoryContentLocked, unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
+import { isTokenContentUnlocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { isHistoryContentUnlocked, unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
 /** An action that creates a new 17375 wallet event and 375 wallet backup */
 export function CreateWallet(mints, privateKey) {
     return async function* ({ events, factory, self }) {
@@ -24,7 +24,7 @@ export function WalletAddPrivateKey(privateKey) {
         const wallet = events.getReplaceable(WALLET_KIND, self);
         if (!wallet)
             throw new Error("Wallet does not exist");
-        if (isWalletLocked(wallet))
+        if (isWalletUnlocked(wallet))
             throw new Error("Wallet is locked");
         if (getWalletPrivateKey(wallet))
             throw new Error("Wallet already has a private key");
@@ -46,18 +46,18 @@ export function UnlockWallet(unlock) {
         const wallet = events.getReplaceable(WALLET_KIND, self);
         if (!wallet)
             throw new Error("Wallet does not exist");
-        if (isWalletLocked(wallet))
+        if (isWalletUnlocked(wallet))
             await unlockWallet(wallet, signer);
         if (unlock?.tokens) {
             const tokens = events.getTimeline({ kinds: [WALLET_TOKEN_KIND], authors: [self] });
             for (const token of tokens)
-                if (isTokenContentLocked(token))
+                if (isTokenContentUnlocked(token))
                     await unlockTokenContent(token, signer);
         }
         if (unlock?.history) {
             const history = events.getTimeline({ kinds: [WALLET_HISTORY_KIND], authors: [self] });
             for (const entry of history)
-                if (isHistoryContentLocked(entry))
+                if (isHistoryContentUnlocked(entry))
                     await unlockHistoryContent(entry, signer);
         }
     };

package/dist/helpers/history.d.ts

@@ -1,4 +1,4 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
+import { HiddenContentSigner, UnlockedHiddenTags } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 export declare const WALLET_HISTORY_KIND = 7376;
 export type HistoryDirection = "in" | "out";
@@ -15,12 +15,17 @@ export type HistoryContent = {
     fee?: number;
 };
 export declare const HistoryContentSymbol: unique symbol;
+/** Type for unlocked history events */
+export type UnlockedHistoryContent = UnlockedHiddenTags & {
+    [HistoryContentSymbol]: HistoryContent;
+};
 /** 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;
+export declare function isHistoryContentUnlocked<T extends NostrEvent>(history: T): history is T & UnlockedHistoryContent;
 /** Returns the parsed content of a 7376 history event */
-export declare function getHistoryContent(history: NostrEvent): HistoryContent | undefined;
+export declare function getHistoryContent<T extends UnlockedHiddenTags>(history: T): HistoryContent;
+export declare function getHistoryContent<T extends NostrEvent>(history: T): 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

@@ -1,4 +1,4 @@
-import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_HISTORY_KIND = 7376;
 // Enable hidden content for wallet history kind
 setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
@@ -8,38 +8,50 @@ 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);
+export function isHistoryContentUnlocked(history) {
+    return isHiddenTagsUnlocked(history) && Reflect.has(history, HistoryContentSymbol) === true;
 }
-/** 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 };
-    });
+    // Return cached value if it exists
+    if (isHistoryContentUnlocked(history))
+        return history[HistoryContentSymbol];
+    // Get hidden tags
+    const tags = getHiddenTags(history);
+    if (!tags)
+        return;
+    // Read tags
+    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]);
+    const content = { direction, amount, created, mint, fee };
+    // Set the cached value
+    Reflect.set(history, HistoryContentSymbol, content);
+    return content;
 }
 /** Decrypts a wallet history event */
 export async function unlockHistoryContent(history, signer) {
-    if (isHiddenContentLocked(history))
-        await unlockHiddenTags(history, signer);
-    return getHistoryContent(history);
+    // Return cached value if it exists
+    if (isHistoryContentUnlocked(history))
+        return history[HistoryContentSymbol];
+    // Unlock hidden tags if needed
+    await unlockHiddenTags(history, signer);
+    // Get the history content
+    const content = getHistoryContent(history);
+    if (!content)
+        throw new Error("Failed to unlock history content");
+    // Notify the event store
+    notifyEventUpdate(history);
+    return content;
 }
 export function lockHistoryContent(history) {
     Reflect.deleteProperty(history, HistoryContentSymbol);

package/dist/helpers/nutzap.d.ts

@@ -1,16 +1,21 @@
 import { Proof } from "@cashu/cashu-ts";
+import { KnownEvent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
-import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+import { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
 export declare const NUTZAP_KIND = 9321;
+/** Validated NIP-61 nutzap event */
+export type NutzapEvent = KnownEvent<typeof NUTZAP_KIND>;
 export declare const NutzapProofsSymbol: unique symbol;
 export declare const NutzapAmountSymbol: unique symbol;
 export declare const NutzapMintSymbol: unique symbol;
 /** Returns the cashu proofs from a kind:9321 nutzap event */
 export declare function getNutzapProofs(event: NostrEvent): Proof[];
 /** Returns the mint URL from a kind:9321 nutzap event */
+export declare function getNutzapMint(event: NutzapEvent): string;
 export declare function getNutzapMint(event: NostrEvent): string | undefined;
 /** Returns the recipient pubkey from a kind:9321 nutzap event */
-export declare function getNutzapRecipient(event: NostrEvent): string | undefined;
+export declare function getNutzapRecipient(event: NutzapEvent): ProfilePointer;
+export declare function getNutzapRecipient(event: NostrEvent): ProfilePointer | undefined;
 /** Returns the event ID being nutzapped from a kind:9321 nutzap event */
 export declare function getNutzapEventPointer(event: NostrEvent): EventPointer | undefined;
 /** Returns the event ID being nutzapped from a kind:9321 nutzap event */
@@ -20,8 +25,9 @@ export declare function getNutzapPointer(event: NostrEvent): EventPointer | Addr
 /** Returns the comment from a kind:9321 nutzap event */
 export declare function getNutzapComment(event: NostrEvent): string | undefined;
 /** Calculates the total amount of sats in a kind:9321 nutzap event */
-export declare function getNutzapAmount(event: NostrEvent): number;
+export declare function getNutzapAmount(event: NutzapEvent): number;
+export declare function getNutzapAmount(event: NostrEvent): number | undefined;
 /** Checks if a nutzap is valid according to NIP-61 requirements */
-export declare function isValidNutzap(nutzap: NostrEvent): boolean;
+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;

package/dist/helpers/nutzap.js

@@ -1,4 +1,4 @@
-import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getTagValue, processTags, safeParse, } from "applesauce-core/helpers";
+import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getProfilePointerFromPTag, getTagValue, isPTag, processTags, safeParse, } from "applesauce-core/helpers";
 import { getHistoryRedeemed } from "./history.js";
 export const NUTZAP_KIND = 9321;
 // Symbols for caching computed values
@@ -11,16 +11,15 @@ export function getNutzapProofs(event) {
         return processTags(event.tags, (tag) => (tag[0] === "proof" ? safeParse(tag[1]) : undefined));
     });
 }
-/** Returns the mint URL from a kind:9321 nutzap event */
 export function getNutzapMint(event) {
     return getOrComputeCachedValue(event, NutzapMintSymbol, () => {
         const url = getTagValue(event, "u");
         return url && URL.canParse(url) ? url : undefined;
     });
 }
-/** Returns the recipient pubkey from a kind:9321 nutzap event */
 export function getNutzapRecipient(event) {
-    return getTagValue(event, "p");
+    const tag = event.tags.find(isPTag);
+    return tag && getProfilePointerFromPTag(tag);
 }
 /** Returns the event ID being nutzapped from a kind:9321 nutzap event */
 export function getNutzapEventPointer(event) {
@@ -44,7 +43,6 @@ export function getNutzapPointer(event) {
 export function getNutzapComment(event) {
     return event.content || undefined;
 }
-/** Calculates the total amount of sats in a kind:9321 nutzap event */
 export function getNutzapAmount(event) {
     return getOrComputeCachedValue(event, NutzapAmountSymbol, () => {
         const proofs = getNutzapProofs(event);
@@ -53,10 +51,16 @@ export function getNutzapAmount(event) {
 }
 /** Checks if a nutzap is valid according to NIP-61 requirements */
 export function isValidNutzap(nutzap) {
-    const mint = getNutzapMint(nutzap);
-    const recipient = getNutzapRecipient(nutzap);
-    const proofs = getNutzapProofs(nutzap);
-    if (!mint || !recipient || proofs.length === 0)
+    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)
+        return false;
+    if (getNutzapProofs(nutzap).length === 0)
         return false;
     return true;
 }

package/dist/helpers/tokens.d.ts

@@ -1,5 +1,5 @@
 import { Proof, Token } from "@cashu/cashu-ts";
-import { HiddenContentSigner } from "applesauce-core/helpers";
+import { HiddenContentSigner, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 export declare const WALLET_TOKEN_KIND = 7375;
 /** Internal method for creating a unique id for each proof */
@@ -21,14 +21,20 @@ export type TokenContent = {
     /** tokens that were destroyed in the creation of this token (helps on wallet state transitions) */
     del: string[];
 };
+/** Symbol for caching token content */
 export declare const TokenContentSymbol: unique symbol;
+/** Type for token events with unlocked content */
+export type UnlockedTokenContent = UnlockedHiddenContent & {
+    [TokenContentSymbol]: TokenContent;
+};
 /**
  * Returns the decrypted and parsed details of a 7375 token event
- * @throws
+ * @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 isTokenContentLocked(token: NostrEvent): boolean;
+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 */
@@ -37,10 +43,11 @@ 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: UnlockedTokenContent): number;
 export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
 /**
  * Selects oldest tokens and proofs that total up to more than the min amount
- * @throws
+ * @throws {Error} If there are insufficient funds
  */
 export declare function dumbTokenSelection(tokens: NostrEvent[], minAmount: number, mint?: string): {
     events: NostrEvent[];

package/dist/helpers/tokens.js

@@ -1,5 +1,5 @@
 import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
-import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, notifyEventUpdate, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
 export const WALLET_TOKEN_KIND = 7375;
 // Enable hidden content for wallet token kind
 setHiddenContentEncryptionMethod(WALLET_TOKEN_KIND, "nip44");
@@ -19,61 +19,65 @@ export function ignoreDuplicateProofs(seen = new Set()) {
         }
     };
 }
+/** Symbol for caching token content */
 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))
+    if (isTokenContentUnlocked(token))
+        return token[TokenContentSymbol];
+    // Get the hidden content
+    const plaintext = getHiddenContent(token);
+    if (!plaintext)
         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;
-    });
+    // Parse the content as a token content
+    const details = JSON.parse(plaintext);
+    // Throw an error if the token content is invalid
+    if (!details.mint)
+        throw new Error("Token missing mint");
+    if (!details.proofs)
+        throw new Error("Token missing proofs");
+    if (!details.del)
+        details.del = [];
+    // Set the cached value
+    Reflect.set(token, TokenContentSymbol, details);
+    return details;
 }
 /** Returns if token details are locked */
-export function isTokenContentLocked(token) {
-    return isHiddenContentLocked(token);
+export function isTokenContentUnlocked(token) {
+    return isHiddenContentUnlocked(token) && Reflect.has(token, TokenContentSymbol) === true;
 }
 /** Decrypts a k:7375 token event */
 export async function unlockTokenContent(token, signer) {
-    if (isHiddenContentLocked(token))
-        await unlockHiddenContent(token, signer);
-    return getTokenContent(token);
+    if (isTokenContentUnlocked(token))
+        return token[TokenContentSymbol];
+    // Unlock the hidden content
+    await unlockHiddenContent(token, signer);
+    // Parse the content as a token content
+    const parsed = getTokenContent(token);
+    if (!parsed)
+        throw new Error("Failed to unlock token content");
+    // Trigger update for event
+    notifyEventUpdate(token);
+    return parsed;
 }
 /** 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);
+    if (!content)
+        return undefined;
     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
+ * @throws {Error} If there are insufficient funds
  */
 export function dumbTokenSelection(tokens, minAmount, mint) {
     // sort newest to oldest
     const sorted = tokens
-        .filter((token) => !isTokenContentLocked(token) && (mint ? getTokenContent(token).mint === mint : true))
+        .filter((token) => (mint ? getTokenContent(token)?.mint === mint : true))
         .sort((a, b) => b.created_at - a.created_at);
     let amount = 0;
     const seen = new Set();
@@ -83,7 +87,12 @@ export function dumbTokenSelection(tokens, minAmount, mint) {
         const token = sorted.pop();
         if (!token)
             throw new Error("Insufficient funds");
-        const proofs = getTokenContent(token).proofs.filter(ignoreDuplicateProofs(seen));
+        const content = getTokenContent(token);
+        // Skip locked tokens
+        if (!content)
+            continue;
+        // Get proofs and total
+        const proofs = content.proofs.filter(ignoreDuplicateProofs(seen));
         const total = proofs.reduce((t, p) => t + p.amount, 0);
         selectedTokens.push(token);
         selectedProofs.push(...proofs);

package/dist/helpers/wallet.d.ts

@@ -1,15 +1,26 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
+import { HiddenContentSigner, UnlockedHiddenTags } 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;
+/** Type for unlocked wallet events */
+export type UnlockedWallet = UnlockedHiddenTags & {
+    [WalletPrivateKeySymbol]: Uint8Array;
+    [WalletMintsSymbol]: string[];
+};
+/** Returns if a wallet is unlocked */
+export declare function isWalletUnlocked<T extends NostrEvent>(wallet: T): wallet is T & UnlockedWallet;
 /** Returns the wallets mints */
+export declare function getWalletMints(wallet: UnlockedWallet): string[];
 export declare function getWalletMints(wallet: NostrEvent): string[];
 /** Returns the wallets private key as a string */
+export declare function getWalletPrivateKey(wallet: UnlockedWallet): Uint8Array;
 export declare function getWalletPrivateKey(wallet: NostrEvent): Uint8Array | undefined;
+/** Unlocks a wallet and returns the hidden tags */
+export declare function unlockWallet(wallet: NostrEvent, signer: HiddenContentSigner): Promise<{
+    mints: string[];
+    privateKey?: Uint8Array;
+}>;
+/** Locks a wallet event */
+export declare function lockWallet(wallet: NostrEvent): void;

package/dist/helpers/wallet.js

@@ -1,5 +1,5 @@
 import { hexToBytes } from "@noble/hashes/utils";
-import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_KIND = 17375;
 export const WALLET_BACKUP_KIND = 375;
 // Enable hidden content for wallet kinds
@@ -7,35 +7,58 @@ setHiddenTagsEncryptionMethod(WALLET_KIND, "nip44");
 setHiddenTagsEncryptionMethod(WALLET_BACKUP_KIND, "nip44");
 export const WalletPrivateKeySymbol = Symbol.for("wallet-private-key");
 export const WalletMintsSymbol = Symbol.for("wallet-mints");
-/** Returns if a wallet is locked */
-export function isWalletLocked(wallet) {
-    return isHiddenTagsLocked(wallet);
+/** Returns if a wallet is unlocked */
+export function isWalletUnlocked(wallet) {
+    return (isHiddenTagsUnlocked(wallet) &&
+        Reflect.has(wallet, WalletPrivateKeySymbol) &&
+        Reflect.has(wallet, WalletMintsSymbol));
+}
+export function getWalletMints(wallet) {
+    // Return cached value if it exists
+    if (Reflect.has(wallet, WalletMintsSymbol))
+        return Reflect.get(wallet, WalletMintsSymbol);
+    // Get hidden tags
+    const tags = getHiddenTags(wallet);
+    if (!tags)
+        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);
+    return mints;
+}
+export function getWalletPrivateKey(wallet) {
+    if (Reflect.has(wallet, WalletPrivateKeySymbol))
+        return Reflect.get(wallet, WalletPrivateKeySymbol);
+    // Get hidden tags
+    const tags = getHiddenTags(wallet);
+    if (!tags)
+        return undefined;
+    // Parse private key
+    const privkey = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
+    const key = privkey ? hexToBytes(privkey) : undefined;
+    // Set the cached value
+    Reflect.set(wallet, WalletPrivateKeySymbol, key);
+    return key;
 }
 /** Unlocks a wallet and returns the hidden tags */
 export async function unlockWallet(wallet, signer) {
-    return await unlockHiddenTags(wallet, signer);
+    if (isWalletUnlocked(wallet))
+        return { mints: getWalletMints(wallet), privateKey: getWalletPrivateKey(wallet) };
+    // Unlock hidden tags if needed
+    await unlockHiddenTags(wallet, signer);
+    // Read the wallet mints and private key
+    const mints = getWalletMints(wallet);
+    if (!mints)
+        throw new Error("Failed to unlock wallet mints");
+    const key = getWalletPrivateKey(wallet);
+    // Notify the event store
+    notifyEventUpdate(wallet);
+    return { mints, privateKey: key };
 }
+/** Locks a wallet event */
 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, () => {
-        const tags = getHiddenTags(wallet);
-        if (!tags)
-            throw new Error("Wallet is locked");
-        return tags.filter((t) => t[0] === "mint").map((t) => t[1]);
-    });
-}
-/** Returns the wallets private key as a string */
-export function getWalletPrivateKey(wallet) {
-    return getOrComputeCachedValue(wallet, WalletPrivateKeySymbol, () => {
-        const tags = getHiddenTags(wallet);
-        if (!tags)
-            throw new Error("Wallet is locked");
-        const key = tags.find((t) => t[0] === "privkey" && t[1])?.[1];
-        return key ? hexToBytes(key) : undefined;
-    });
-}

package/dist/models/history.js

@@ -1,5 +1,5 @@
 import { combineLatest, filter, map, scan, startWith } from "rxjs";
-import { getHistoryRedeemed, isHistoryContentLocked, WALLET_HISTORY_KIND } from "../helpers/history.js";
+import { getHistoryRedeemed, isHistoryContentUnlocked, WALLET_HISTORY_KIND } from "../helpers/history.js";
 /** A model that returns an array of redeemed event ids for a wallet */
 export function WalletRedeemedModel(pubkey) {
     return (events) => events
@@ -15,7 +15,7 @@ export function WalletHistoryModel(pubkey, locked) {
             if (locked === undefined)
                 return history;
             else
-                return history.filter((entry) => isHistoryContentLocked(entry) === locked);
+                return history.filter((entry) => isHistoryContentUnlocked(entry) === locked);
         }));
     };
 }

package/dist/models/nutzap.d.ts

@@ -1,6 +1,8 @@
 import { Model } from "applesauce-core";
+import { KnownEvent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
+import { NUTZAP_KIND } from "../helpers/nutzap.js";
 /** A model that returns all nutzap events for an event */
-export declare function EventNutZapzModel(event: NostrEvent): Model<NostrEvent[]>;
+export declare function EventNutZapzModel(event: NostrEvent): Model<KnownEvent<typeof NUTZAP_KIND>[]>;
 /** A model that returns all nutzaps for a users profile */
-export declare function ProfileNutZapzModel(pubkey: string): Model<NostrEvent[]>;
+export declare function ProfileNutZapzModel(pubkey: string): Model<KnownEvent<typeof NUTZAP_KIND>[]>;

package/dist/models/nutzap.js

@@ -1,16 +1,19 @@
 import { getReplaceableAddress, isReplaceable } from "applesauce-core/helpers";
 import { map } from "rxjs";
-import { getNutzapPointer, NUTZAP_KIND } from "../helpers/nutzap.js";
+import { getNutzapPointer, isValidNutzap, NUTZAP_KIND } from "../helpers/nutzap.js";
 /** A model that returns all nutzap events for an event */
 export function EventNutZapzModel(event) {
-    return (events) => isReplaceable(event.kind)
+    return (events) => (isReplaceable(event.kind)
         ? events.timeline({ kinds: [NUTZAP_KIND], "#e": [event.id] })
-        : events.timeline({ kinds: [NUTZAP_KIND], "#a": [getReplaceableAddress(event)] });
+        : events.timeline({ kinds: [NUTZAP_KIND], "#a": [getReplaceableAddress(event)] })).pipe(map((events) => 
+    // Validate nutzap events
+    events.filter(isValidNutzap)));
 }
 /** A model that returns all nutzaps for a users profile */
 export function ProfileNutZapzModel(pubkey) {
-    return (events) => events
-        .timeline({ kinds: [NUTZAP_KIND], "#p": [pubkey] })
-        // filter out nutzaps that are for events
-        .pipe(map((zaps) => zaps.filter((zap) => getNutzapPointer(zap) === undefined)));
+    return (events) => events.timeline({ kinds: [NUTZAP_KIND], "#p": [pubkey] }).pipe(
+    // Validate nutzap events
+    map((zaps) => zaps.filter(isValidNutzap)), 
+    // filter out nutzaps that are for events
+    map((zaps) => zaps.filter((zap) => getNutzapPointer(zap) === undefined)));
 }

package/dist/models/tokens.js

@@ -1,5 +1,5 @@
 import { combineLatest, filter, map, startWith } from "rxjs";
-import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentUnlocked, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
 /** removes deleted events from sorted array */
 function filterDeleted(tokens) {
     const deleted = new Set();
@@ -10,7 +10,7 @@ function filterDeleted(tokens) {
         if (deleted.has(token.id))
             return false;
         // add ids to deleted array
-        if (!isTokenContentLocked(token)) {
+        if (!isTokenContentUnlocked(token)) {
             const details = getTokenContent(token);
             for (const id of details.del)
                 deleted.add(id);
@@ -30,7 +30,7 @@ export function WalletTokensModel(pubkey, locked) {
             if (locked === undefined)
                 return tokens;
             else
-                return tokens.filter((t) => isTokenContentLocked(t) === locked);
+                return tokens.filter((t) => isTokenContentUnlocked(t) === locked);
         }), 
         // remove deleted events
         map(filterDeleted));
@@ -41,7 +41,7 @@ export function WalletBalanceModel(pubkey) {
     return (events) => {
         const updates = events.update$.pipe(filter((e) => e.kind === WALLET_TOKEN_KIND && e.pubkey === pubkey), startWith(undefined));
         const timeline = events.timeline({ kinds: [WALLET_TOKEN_KIND], authors: [pubkey] });
-        return combineLatest([updates, timeline]).pipe(map(([_, tokens]) => tokens.filter((t) => !isTokenContentLocked(t))), 
+        return combineLatest([updates, timeline]).pipe(map(([_, tokens]) => tokens.filter((t) => !isTokenContentUnlocked(t))), 
         // filter out deleted tokens
         map(filterDeleted), 
         // map tokens to totals

package/dist/models/wallet.js

@@ -1,5 +1,5 @@
 import { filter, map, merge } from "rxjs";
-import { getWalletMints, getWalletPrivateKey, isWalletLocked, WALLET_KIND } from "../helpers/wallet.js";
+import { getWalletMints, getWalletPrivateKey, isWalletUnlocked, WALLET_KIND } from "../helpers/wallet.js";
 /** A model to get the state of a NIP-60 wallet */
 export function WalletModel(pubkey) {
     return (events) => merge(
@@ -9,10 +9,13 @@ export function WalletModel(pubkey) {
     events.update$.pipe(filter((e) => e.kind === WALLET_KIND && e.pubkey === pubkey))).pipe(map((wallet) => {
         if (!wallet)
             return;
-        if (isWalletLocked(wallet))
+        if (isWalletUnlocked(wallet)) {
+            const mints = getWalletMints(wallet);
+            const privateKey = getWalletPrivateKey(wallet);
+            return { locked: false, mints, privateKey, event: wallet };
+        }
+        else {
             return { locked: true, event: wallet };
-        const mints = getWalletMints(wallet);
-        const privateKey = getWalletPrivateKey(wallet);
-        return { locked: false, mints, privateKey, event: wallet };
+        }
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -72,27 +72,29 @@
     }
   },
   "dependencies": {
-    "@cashu/cashu-ts": "2.0.0-rc1",
+    "@cashu/cashu-ts": "^2.7.2",
     "@gandlaf21/bc-ur": "^1.1.12",
     "@noble/hashes": "^1.7.1",
-    "applesauce-actions": "^3.1.0",
-    "applesauce-core": "^3.1.0",
-    "applesauce-factory": "^3.1.0",
-    "nostr-tools": "~2.15",
+    "applesauce-actions": "^4.0.0",
+    "applesauce-core": "^4.0.0",
+    "applesauce-factory": "^4.0.0",
+    "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
-    "applesauce-signers": "^3.1.0",
+    "applesauce-signers": "^4.0.0",
+    "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "funding": {
     "type": "lightning",
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",