applesauce-wallet 0.0.0-next-20251209200210 → 0.0.0-next-20251220152312

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[]>;

package/dist/models/history.js

@@ -1,4 +1,4 @@
-import { combineLatest, filter, map, scan, startWith } from "rxjs";
+import { identity, map, scan } from "rxjs";
 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) {
@@ -7,15 +7,12 @@ export function WalletRedeemedModel(pubkey) {
         .pipe(scan((ids, history) => [...ids, ...getHistoryRedeemed(history)], []));
 }
 /** A model that returns a timeline of wallet history events */
-export function WalletHistoryModel(pubkey, locked) {
+export function WalletHistoryModel(pubkey, unlocked) {
     return (events) => {
-        const updates = events.update$.pipe(filter((e) => e.kind === WALLET_HISTORY_KIND && e.pubkey === pubkey), startWith(undefined));
-        const timeline = events.timeline({ kinds: [WALLET_HISTORY_KIND], authors: [pubkey] });
-        return combineLatest([updates, timeline]).pipe(map(([_, history]) => {
-            if (locked === undefined)
-                return history;
-            else
-                return history.filter((entry) => isHistoryContentUnlocked(entry) === locked);
-        }));
+        return events
+            .timeline({ kinds: [WALLET_HISTORY_KIND], authors: [pubkey] })
+            .pipe(unlocked !== undefined
+            ? map((events) => events.filter((e) => isHistoryContentUnlocked(e) === unlocked))
+            : identity);
     };
 }

package/dist/models/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./history.js";
 export * from "./tokens.js";
-export * from "./wallet.js";
 export * from "./nutzap.js";

package/dist/models/index.js

@@ -1,4 +1,3 @@
 export * from "./history.js";
 export * from "./tokens.js";
-export * from "./wallet.js";
 export * from "./nutzap.js";

package/dist/models/nutzap.d.ts

@@ -6,3 +6,5 @@ import { NUTZAP_KIND } from "../helpers/nutzap.js";
 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<KnownEvent<typeof NUTZAP_KIND>[]>;
+/** A model that returns all nutzap event ids received by a user */
+export declare function ReceivedNutzapsModel(pubkey: string): Model<string[]>;

package/dist/models/nutzap.js

@@ -1,6 +1,8 @@
 import { map } from "rxjs";
 import { buildCommonEventRelationFilters } from "applesauce-core/helpers/model";
+import { getHistoryRedeemed } from "../helpers/history.js";
 import { getNutzapPointer, isValidNutzap, NUTZAP_KIND } from "../helpers/nutzap.js";
+import { WalletHistoryModel } from "./history.js";
 /** A model that returns all nutzap events for an event */
 export function EventNutZapzModel(event) {
     return (events) => events.timeline(buildCommonEventRelationFilters({ kinds: [NUTZAP_KIND] }, event)).pipe(map((events) => 
@@ -15,3 +17,9 @@ export function ProfileNutZapzModel(pubkey) {
     // filter out nutzaps that are for events
     map((zaps) => zaps.filter((zap) => getNutzapPointer(zap) === undefined)));
 }
+/** A model that returns all nutzap event ids received by a user */
+export function ReceivedNutzapsModel(pubkey) {
+    return (events) => events
+        .model(WalletHistoryModel, pubkey, true)
+        .pipe(map((entries) => Array.from(new Set(entries.flatMap(getHistoryRedeemed)))));
+}

package/dist/models/tokens.d.ts

@@ -1,6 +1,6 @@
 import { Model } from "applesauce-core";
 import { NostrEvent } from "applesauce-core/helpers/event";
-/** A model that subscribes to all token events for a wallet, passing locked will filter by token locked status */
-export declare function WalletTokensModel(pubkey: string, locked?: boolean | undefined): Model<NostrEvent[]>;
+/** A model that subscribes to all token events for a wallet, passing unlocked will filter by token unlocked status */
+export declare function WalletTokensModel(pubkey: string, unlocked?: boolean | undefined): Model<NostrEvent[]>;
 /** A model that returns the visible balance of a wallet for each mint */
 export declare function WalletBalanceModel(pubkey: string): Model<Record<string, number>>;

package/dist/models/tokens.js

@@ -1,5 +1,7 @@
-import { combineLatest, filter, map, startWith } from "rxjs";
-import { getTokenContent, ignoreDuplicateProofs, isTokenContentUnlocked, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
+import { watchEventsUpdates } from "applesauce-core";
+import { identity, map } from "rxjs";
+import { ignoreDuplicateProofs } from "../helpers/cashu.js";
+import { getTokenContent, isTokenContentUnlocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
 /** removes deleted events from sorted array */
 function filterDeleted(tokens) {
     const deleted = new Set();
@@ -10,7 +12,7 @@ function filterDeleted(tokens) {
         if (deleted.has(token.id))
             return false;
         // add ids to deleted array
-        if (!isTokenContentUnlocked(token)) {
+        if (isTokenContentUnlocked(token)) {
             const details = getTokenContent(token);
             for (const id of details.del)
                 deleted.add(id);
@@ -19,19 +21,12 @@ function filterDeleted(tokens) {
     })
         .reverse();
 }
-/** A model that subscribes to all token events for a wallet, passing locked will filter by token locked status */
-export function WalletTokensModel(pubkey, locked) {
+/** A model that subscribes to all token events for a wallet, passing unlocked will filter by token unlocked status */
+export function WalletTokensModel(pubkey, unlocked) {
     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(
+        return events.timeline({ kinds: [WALLET_TOKEN_KIND], authors: [pubkey] }).pipe(
         // filter out locked tokens
-        map(([_, tokens]) => {
-            if (locked === undefined)
-                return tokens;
-            else
-                return tokens.filter((t) => isTokenContentUnlocked(t) === locked);
-        }), 
+        unlocked !== undefined ? map((tokens) => tokens.filter((t) => isTokenContentUnlocked(t) === unlocked)) : identity, 
         // remove deleted events
         map(filterDeleted));
     };
@@ -39,9 +34,11 @@ export function WalletTokensModel(pubkey, locked) {
 /** A model that returns the visible balance of a wallet for each mint */
 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) => !isTokenContentUnlocked(t))), 
+        return events.timeline({ kinds: [WALLET_TOKEN_KIND], authors: [pubkey] }).pipe(
+        // Watch for updates to the tokens
+        watchEventsUpdates(events), 
+        // Ignore locked tokens
+        map((tokens) => tokens.filter((t) => isTokenContentUnlocked(t))), 
         // filter out deleted tokens
         map(filterDeleted), 
         // map tokens to totals

package/dist/operations/history.js

@@ -17,7 +17,7 @@ export function setHistoryContent(content) {
         setSingletonTag(["amount", String(content.amount)], true),
         includeHistoryCreatedTags(content.created),
     ];
-    if (content.fee !== undefined)
+    if (content.fee !== undefined && content.fee > 0)
         operations.push(setSingletonTag(["fee", String(content.fee)], true));
     if (content.mint !== undefined)
         operations.push(setSingletonTag(["mint", content.mint], true));

package/dist/operations/index.d.ts

@@ -1,5 +1,5 @@
 export * as History from "./history.js";
 export * as Tokens from "./tokens.js";
 export * as Wallet from "./wallet.js";
-export * as ZapInfo from "./zap-info.js";
+export * as ZapInfo from "./nutzap-info.js";
 export * as NutZap from "./nutzap.js";

package/dist/operations/index.js

@@ -1,5 +1,5 @@
 export * as History from "./history.js";
 export * as Tokens from "./tokens.js";
 export * as Wallet from "./wallet.js";
-export * as ZapInfo from "./zap-info.js";
+export * as ZapInfo from "./nutzap-info.js";
 export * as NutZap from "./nutzap.js";

package/dist/operations/nutzap-info.d.ts

@@ -0,0 +1,21 @@
+import { EventOperation } from "applesauce-core";
+/** Sets the relays for a nutzap info event, replacing all existing relay tags */
+export declare function setNutzapInfoRelays(relays: string[]): EventOperation;
+/** Sets the mints for a nutzap info event, replacing all existing mint tags */
+export declare function setNutzapInfoMints(mints: Array<{
+    url: string;
+    units?: string[];
+}>): EventOperation;
+/** Adds a relay tag to a nutzap info event */
+export declare function addNutzapInfoRelay(url: string | URL): EventOperation;
+/** Removes a relay tag from a nutzap info event */
+export declare function removeNutzapInfoRelay(url: string | URL): EventOperation;
+/** Adds a mint tag to a nutzap info event */
+export declare function addNutzapInfoMint(mint: {
+    url: string;
+    units?: string[];
+}): EventOperation;
+/** Removes a mint tag from a nutzap info event */
+export declare function removeNutzapInfoMint(url: string): EventOperation;
+/** Sets the pubkey for a nutzap info event */
+export declare function setNutzapInfoPubkey(key: Uint8Array): EventOperation;

package/dist/operations/nutzap-info.js

@@ -0,0 +1,71 @@
+import { modifyPublicTags } from "applesauce-core/operations";
+import { removeNameValueTag, setSingletonTag } from "applesauce-core/operations/tag/common";
+import { addRelayTag, removeRelayTag } from "applesauce-core/operations/tag/relay";
+import { normalizeURL } from "applesauce-core/helpers/url";
+import { createNutzapInfoPubkeyTag } from "../helpers/nutzap-info.js";
+/** Sets the relays for a nutzap info event, replacing all existing relay tags */
+export function setNutzapInfoRelays(relays) {
+    return modifyPublicTags((tags) => [
+        // remove all existing relay tags
+        ...tags.filter((t) => t[0] !== "relay"),
+        // add new relay tags
+        ...relays.map((relay) => ["relay", relay]),
+    ]);
+}
+/** Sets the mints for a nutzap info event, replacing all existing mint tags */
+export function setNutzapInfoMints(mints) {
+    return modifyPublicTags((tags) => [
+        // remove all existing mint tags
+        ...tags.filter((t) => t[0] !== "mint"),
+        // add new mint tags
+        ...mints.map((mint) => {
+            return mint.units ? ["mint", mint.url, ...mint.units] : ["mint", mint.url];
+        }),
+    ]);
+}
+/** Adds a relay tag to a nutzap info event */
+export function addNutzapInfoRelay(url) {
+    url = normalizeURL(url).toString();
+    return modifyPublicTags(addRelayTag(url, "relay", false));
+}
+/** Removes a relay tag from a nutzap info event */
+export function removeNutzapInfoRelay(url) {
+    url = normalizeURL(url).toString();
+    return modifyPublicTags(removeRelayTag(url, "relay"));
+}
+/** Adds a mint tag to a nutzap info event */
+export function addNutzapInfoMint(mint) {
+    return modifyPublicTags((tags) => {
+        // Find existing mint tag with the same URL
+        const existingIndex = tags.findIndex((t) => t[0] === "mint" && t[1] === mint.url);
+        if (existingIndex !== -1) {
+            // Merge units if mint tag already exists
+            const existingTag = tags[existingIndex];
+            const existingUnits = existingTag.slice(2); // Get units from existing tag (everything after ["mint", url])
+            const newUnits = mint.units || [];
+            // Merge units, removing duplicates while preserving order
+            const mergedUnits = [...existingUnits];
+            for (const unit of newUnits) {
+                if (!mergedUnits.includes(unit)) {
+                    mergedUnits.push(unit);
+                }
+            }
+            // Replace existing tag with merged tag
+            const mergedTag = mergedUnits.length > 0 ? ["mint", mint.url, ...mergedUnits] : ["mint", mint.url];
+            return tags.map((t, i) => (i === existingIndex ? mergedTag : t));
+        }
+        else {
+            // Add new tag if it doesn't exist
+            const tag = mint.units ? ["mint", mint.url, ...mint.units] : ["mint", mint.url];
+            return [...tags, tag];
+        }
+    });
+}
+/** Removes a mint tag from a nutzap info event */
+export function removeNutzapInfoMint(url) {
+    return modifyPublicTags(removeNameValueTag(["mint", url]));
+}
+/** Sets the pubkey for a nutzap info event */
+export function setNutzapInfoPubkey(key) {
+    return modifyPublicTags(setSingletonTag(createNutzapInfoPubkeyTag(key), true));
+}

package/dist/operations/wallet.d.ts

@@ -1,8 +1,17 @@
-import { EventOperation } from "applesauce-core/event-factory";
+import { EventOperation, TagOperation } from "applesauce-core/event-factory";
 import { NostrEvent } from "applesauce-core/helpers/event";
 /** Sets the content of a kind 375 wallet backup event */
 export declare function setBackupContent(wallet: NostrEvent): EventOperation;
 /** Sets the "mint" tags in a wallet event */
+export declare function setMintTags(mints: string[]): TagOperation;
 export declare function setMints(mints: string[]): EventOperation;
 /** Sets the "privkey" tag on a wallet event */
+export declare function setPrivateKeyTag(privateKey: Uint8Array): TagOperation;
 export declare function setPrivateKey(privateKey: Uint8Array): EventOperation;
+/** Adds a relay tag to a wallet event */
+export declare function addWalletRelay(url: string | URL): EventOperation;
+/** Removes a relay tag from a wallet event */
+export declare function removeWalletRelay(url: string | URL): EventOperation;
+/** Sets the relay tags on a wallet event, replacing all existing relay tags */
+export declare function setRelayTags(relays: (string | URL)[]): TagOperation;
+export declare function setRelays(relays: (string | URL)[]): EventOperation;