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

package/dist/helpers/mint-recommendation.js

@@ -0,0 +1,54 @@
+import { getAddressPointerFromATag, getOrComputeCachedValue, getTagValue, isATag, isHex, } from "applesauce-core/helpers";
+import { getReplaceableIdentifier } from "applesauce-core/helpers/event";
+import { CASHU_MINT_INFO_KIND } from "./mint-info.js";
+// NIP-87 Recommendation Event Kind
+export const MINT_RECOMMENDATION_KIND = 38000;
+// Symbols for caching computed values
+export const RecommendationKindSymbol = Symbol.for("mint-recommendation-kind");
+export const RecommendationURLSymbol = Symbol.for("mint-recommendation-url");
+export const RecommendationAddressPointerSymbol = Symbol.for("mint-recommendation-address-pointer");
+export function getRecommendationKind(event) {
+    return getOrComputeCachedValue(event, RecommendationKindSymbol, () => {
+        const kindStr = getTagValue(event, "k");
+        if (!kindStr)
+            return undefined;
+        const kind = parseInt(kindStr, 10);
+        return isNaN(kind) ? undefined : kind;
+    });
+}
+/**
+ * Returns the d-identifier from a kind:38000 recommendation event
+ * This is the kind:38172 event identifier this event is recommending
+ */
+export function getRecommendationMintPubkey(event) {
+    const identifier = getReplaceableIdentifier(event);
+    if (!isHex(identifier))
+        return undefined;
+    return identifier || undefined;
+}
+export function getRecommendationURL(event) {
+    return getOrComputeCachedValue(event, RecommendationURLSymbol, () => {
+        return getTagValue(event, "u");
+    });
+}
+export function getRecommendationAddressPointer(event) {
+    return getOrComputeCachedValue(event, RecommendationAddressPointerSymbol, () => {
+        const tag = event.tags.find(isATag);
+        return tag ? (getAddressPointerFromATag(tag) ?? undefined) : 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 function isValidMintRecommendation(event) {
+    if (!event)
+        return false;
+    if (event.kind !== MINT_RECOMMENDATION_KIND)
+        return false;
+    const kind = getRecommendationKind(event);
+    // Only cashu mints (kind 38172) are supported
+    return kind === CASHU_MINT_INFO_KIND;
+}

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");
@@ -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;

package/dist/helpers/tokens.js

@@ -1,28 +1,25 @@
-import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
 import { getHiddenContent, isHiddenContentUnlocked, lockHiddenContent, notifyEventUpdate, 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 */
+export function isValidWalletToken(event) {
+    return event.kind === WALLET_TOKEN_KIND;
+}
 // Enable hidden content for wallet token kind
 setHiddenContentEncryptionMethod(WALLET_TOKEN_KIND, "nip44");
-/** Internal method for creating a unique id for each proof */
-export function getProofUID(proof) {
-    return proof.id + proof.amount + proof.C + proof.secret;
-}
-/** Internal method to filter out duplicate proofs */
-export function ignoreDuplicateProofs(seen = new Set()) {
-    return (proof) => {
-        const id = getProofUID(proof);
-        if (seen.has(id))
-            return false;
-        else {
-            seen.add(id);
-            return true;
-        }
-    };
-}
 /** Symbol for caching token content */
 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;
+}
 export function getTokenContent(token) {
-    if (isTokenContentUnlocked(token))
+    if (TokenContentSymbol in token)
         return token[TokenContentSymbol];
     // Get the hidden content
     const plaintext = getHiddenContent(token);
@@ -41,13 +38,9 @@ export function getTokenContent(token) {
     Reflect.set(token, TokenContentSymbol, details);
     return details;
 }
-/** Returns if token details are locked */
-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 (isTokenContentUnlocked(token))
+    if (TokenContentSymbol in token)
         return token[TokenContentSymbol];
     // Unlock the hidden content
     await unlockHiddenContent(token, signer);
@@ -72,12 +65,54 @@ export function getTokenProofsTotal(token) {
 }
 /**
  * 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 function dumbTokenSelection(tokens, minAmount, mint) {
-    // sort newest to oldest
+    // If mint is not specified, find a mint with sufficient balance
+    let targetMint = mint;
+    if (!targetMint) {
+        // Group tokens by mint and calculate total balance per mint
+        const tokensByMint = new Map();
+        for (const token of tokens) {
+            const content = getTokenContent(token);
+            if (!content)
+                continue; // Skip locked tokens
+            const tokenMint = content.mint;
+            if (!tokenMint)
+                continue;
+            if (!tokensByMint.has(tokenMint)) {
+                tokensByMint.set(tokenMint, []);
+            }
+            tokensByMint.get(tokenMint).push(token);
+        }
+        // Find a mint with sufficient balance
+        let foundMint;
+        for (const [mintKey, mintTokens] of tokensByMint) {
+            const seen = new Set();
+            let total = 0;
+            for (const token of mintTokens) {
+                const content = getTokenContent(token);
+                if (!content)
+                    continue;
+                const proofs = content.proofs.filter(ignoreDuplicateProofs(seen));
+                total += proofs.reduce((t, p) => t + p.amount, 0);
+            }
+            if (total >= minAmount) {
+                foundMint = mintKey;
+                break;
+            }
+        }
+        if (!foundMint)
+            throw new Error("Insufficient funds in any mint");
+        targetMint = foundMint;
+    }
+    // Filter tokens by the target mint and sort newest to oldest
     const sorted = tokens
-        .filter((token) => (mint ? getTokenContent(token)?.mint === mint : true))
+        .filter((token) => {
+        const content = getTokenContent(token);
+        return content?.mint === targetMint;
+    })
         .sort((a, b) => b.created_at - a.created_at);
     let amount = 0;
     const seen = new Set();
@@ -91,6 +126,10 @@ export function dumbTokenSelection(tokens, minAmount, mint) {
         // Skip locked tokens
         if (!content)
             continue;
+        // Verify mint matches (should always match due to filter, but double-check for safety)
+        if (content.mint !== targetMint) {
+            throw new Error(`Token mint mismatch: expected ${targetMint}, got ${content.mint}`);
+        }
         // Get proofs and total
         const proofs = content.proofs.filter(ignoreDuplicateProofs(seen));
         const total = proofs.reduce((t, p) => t + p.amount, 0);
@@ -100,72 +139,3 @@ export function dumbTokenSelection(tokens, minAmount, mint) {
     }
     return { events: selectedTokens, proofs: selectedProofs };
 }
-/**
- * Returns a decoded cashu token inside an unicode emoji
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
- */
-export function decodeTokenFromEmojiString(str) {
-    try {
-        let decoded = [];
-        const chars = Array.from(str);
-        if (!chars.length)
-            return undefined;
-        const fromVariationSelector = function (char) {
-            const codePoint = char.codePointAt(0);
-            if (codePoint === undefined)
-                return null;
-            // Handle Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
-            if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) {
-                // Maps FE00->0, FE01->1, ..., FE0F->15
-                const byteValue = codePoint - 0xfe00;
-                return String.fromCharCode(byteValue);
-            }
-            // Handle Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
-            if (codePoint >= 0xe0100 && codePoint <= 0xe01ef) {
-                // Maps E0100->16, E0101->17, ..., E01EF->255
-                const byteValue = codePoint - 0xe0100 + 16;
-                return String.fromCharCode(byteValue);
-            }
-            // No Variation Selector
-            return null;
-        };
-        // Check all input chars for peanut data
-        for (const char of chars) {
-            let byte = fromVariationSelector(char);
-            if (byte === null && decoded.length > 0) {
-                break;
-            }
-            else if (byte === null) {
-                continue;
-            }
-            decoded.push(byte); // got some
-        }
-        // Switch out token if we found peanut data
-        let decodedString = decoded.join("");
-        return getDecodedToken(decodedString);
-    }
-    catch (error) {
-        return undefined;
-    }
-}
-/**
- * Encodes a token into an emoji char
- * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
- */
-export function encodeTokenToEmoji(token, emoji = "🥜") {
-    return (emoji +
-        Array.from(typeof token === "string" ? token : getEncodedToken(token))
-            .map((char) => {
-            const byteValue = char.charCodeAt(0);
-            // For byte values 0-15, use Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
-            if (byteValue >= 0 && byteValue <= 15) {
-                return String.fromCodePoint(0xfe00 + byteValue);
-            }
-            // For byte values 16-255, use Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
-            if (byteValue >= 16 && byteValue <= 255) {
-                return String.fromCodePoint(0xe0100 + (byteValue - 16));
-            }
-            return "";
-        })
-            .join(""));
-}

package/dist/helpers/wallet.d.ts

@@ -1,13 +1,19 @@
 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_KIND = 17375;
 export declare const WALLET_BACKUP_KIND = 375;
+/** Validated wallet event */
+export type WalletEvent = KnownEvent<typeof WALLET_KIND>;
+/** Checks if an event is a valid wallet event */
+export declare function isValidWallet(event: NostrEvent): event is WalletEvent;
 export declare const WalletPrivateKeySymbol: unique symbol;
 export declare const WalletMintsSymbol: unique symbol;
+export declare const WalletRelaysSymbol: unique symbol;
 /** Type for unlocked wallet events */
 export type UnlockedWallet = UnlockedHiddenTags & {
-    [WalletPrivateKeySymbol]: Uint8Array;
-    [WalletMintsSymbol]: string[];
+    [WalletPrivateKeySymbol]?: Uint8Array | null;
+    [WalletMintsSymbol]?: string[];
+    [WalletRelaysSymbol]?: string[];
 };
 /** Returns if a wallet is unlocked */
 export declare function isWalletUnlocked<T extends NostrEvent>(wallet: T): wallet is T & UnlockedWallet;
@@ -15,12 +21,16 @@ export declare function isWalletUnlocked<T extends NostrEvent>(wallet: T): walle
 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;
+export declare function getWalletPrivateKey(wallet: UnlockedWallet): Uint8Array | null;
+export declare function getWalletPrivateKey(wallet: NostrEvent): Uint8Array | undefined | null;
+/** Returns the wallets relays */
+export declare function getWalletRelays(wallet: UnlockedWallet): string[];
+export declare function getWalletRelays(wallet: NostrEvent): string[] | undefined;
 /** Unlocks a wallet and returns the hidden tags */
 export declare function unlockWallet(wallet: NostrEvent, signer: HiddenContentSigner): Promise<{
     mints: string[];
-    privateKey?: Uint8Array;
+    privateKey: Uint8Array | null;
+    relays: string[];
 }>;
 /** Locks a wallet event */
 export declare function lockWallet(wallet: NostrEvent): void;

package/dist/helpers/wallet.js

@@ -1,22 +1,26 @@
-import { hexToBytes } from "@noble/hashes/utils";
-import { getHiddenTags, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, hasHiddenTags, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, relaySet, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { hexToBytes } from "applesauce-core/helpers/event";
 export const WALLET_KIND = 17375;
 export const WALLET_BACKUP_KIND = 375;
+/** Checks if an event is a valid wallet event */
+export function isValidWallet(event) {
+    return event.kind === WALLET_KIND && hasHiddenTags(event);
+}
 // Enable hidden content for wallet kinds
 setHiddenTagsEncryptionMethod(WALLET_KIND, "nip44");
 setHiddenTagsEncryptionMethod(WALLET_BACKUP_KIND, "nip44");
 export const WalletPrivateKeySymbol = Symbol.for("wallet-private-key");
 export const WalletMintsSymbol = Symbol.for("wallet-mints");
+export const WalletRelaysSymbol = Symbol.for("wallet-relays");
 /** Returns if a wallet is unlocked */
 export function isWalletUnlocked(wallet) {
-    return (isHiddenTagsUnlocked(wallet) &&
-        Reflect.has(wallet, WalletPrivateKeySymbol) &&
-        Reflect.has(wallet, WalletMintsSymbol));
+    // No need for try catch or proactivly parsing here since it only depends on hidden tags
+    return isHiddenTagsUnlocked(wallet);
 }
 export function getWalletMints(wallet) {
     // Return cached value if it exists
-    if (Reflect.has(wallet, WalletMintsSymbol))
-        return Reflect.get(wallet, WalletMintsSymbol);
+    if (WalletMintsSymbol in wallet)
+        return wallet[WalletMintsSymbol];
     // Get hidden tags
     const tags = getHiddenTags(wallet);
     if (!tags)
@@ -28,33 +32,55 @@ export function getWalletMints(wallet) {
     return mints;
 }
 export function getWalletPrivateKey(wallet) {
-    if (Reflect.has(wallet, WalletPrivateKeySymbol))
-        return Reflect.get(wallet, WalletPrivateKeySymbol);
+    if (WalletPrivateKeySymbol in wallet)
+        return 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;
+    const key = privkey ? hexToBytes(privkey) : null;
     // Set the cached value
     Reflect.set(wallet, WalletPrivateKeySymbol, key);
     return key;
 }
+export function getWalletRelays(wallet) {
+    // Return cached value if it exists
+    if (WalletRelaysSymbol in wallet)
+        return wallet[WalletRelaysSymbol];
+    // Get hidden tags
+    const tags = getHiddenTags(wallet);
+    if (!tags)
+        return undefined;
+    // 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);
+    return relays;
+}
 /** Unlocks a wallet and returns the hidden tags */
 export async function unlockWallet(wallet, signer) {
-    if (isWalletUnlocked(wallet))
-        return { mints: getWalletMints(wallet), privateKey: getWalletPrivateKey(wallet) };
+    if (WalletPrivateKeySymbol in wallet && WalletMintsSymbol in wallet && WalletRelaysSymbol in wallet)
+        return {
+            mints: wallet[WalletMintsSymbol],
+            privateKey: wallet[WalletPrivateKeySymbol],
+            relays: wallet[WalletRelaysSymbol],
+        };
     // 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);
+    const relays = getWalletRelays(wallet);
+    if (!relays)
+        throw new Error("Failed to unlock wallet relays");
+    const key = getWalletPrivateKey(wallet) ?? null;
     // Notify the event store
     notifyEventUpdate(wallet);
-    return { mints, privateKey: key };
+    return { mints, privateKey: key, relays };
 }
 /** Locks a wallet event */
 export function lockWallet(wallet) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * as Actions from "./actions/index.js";
 export * as Blueprints from "./blueprints/index.js";
+export * as Casts from "./casts/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * as Actions from "./actions/index.js";
 export * as Blueprints from "./blueprints/index.js";
+export * as Casts from "./casts/index.js";
 export * as Helpers from "./helpers/index.js";
 export * as Models from "./models/index.js";
 export * as Operations from "./operations/index.js";

package/dist/models/history.d.ts

@@ -3,4 +3,4 @@ import { NostrEvent } from "applesauce-core/helpers/event";
 /** A model that returns an array of redeemed event ids for a wallet */
 export declare function WalletRedeemedModel(pubkey: string): Model<string[]>;
 /** A model that returns a timeline of wallet history events */
-export declare function WalletHistoryModel(pubkey: string, locked?: boolean | undefined): Model<NostrEvent[]>;
+export declare function WalletHistoryModel(pubkey: string, unlocked?: boolean | undefined): Model<NostrEvent[]>;