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

package/dist/actions/tokens.js

@@ -1,82 +1,143 @@
-import { CheckStateEnum, Wallet, Mint } from "@cashu/cashu-ts";
+import { CheckStateEnum, sumProofs, Wallet } from "@cashu/cashu-ts";
 import { DeleteBlueprint } from "applesauce-common/blueprints/delete";
 import { WalletHistoryBlueprint } from "../blueprints/history.js";
 import { WalletTokenBlueprint } from "../blueprints/tokens.js";
-import { getTokenContent, ignoreDuplicateProofs, isTokenContentUnlocked, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
+import { getProofUID, ignoreDuplicateProofs } from "../helpers/cashu.js";
+import { dumbTokenSelection, getTokenContent, isTokenContentUnlocked, unlockTokenContent, WALLET_TOKEN_KIND, } from "../helpers/tokens.js";
+import { getUnlockedWallet } from "./common.js";
+// Make sure the wallet$ is registered on the user class
+import "../casts/__register__.js";
 /**
- * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * Adds a cashu token to the wallet and creates a history event
  * @param token the cashu token to add
- * @param redeemed an array of nutzap event ids to mark as redeemed
+ * @param redeemed an array of event ids to mark as redeemed
  */
-export function ReceiveToken(token, redeemed, fee) {
-    return async function* ({ factory }) {
-        const amount = token.proofs.reduce((t, p) => t + p.amount, 0);
-        const tokenEvent = await factory.sign(await factory.create(WalletTokenBlueprint, token, []));
-        const history = await factory.sign(await factory.create(WalletHistoryBlueprint, { direction: "in", amount, mint: token.mint, created: [tokenEvent.id], fee }, redeemed ?? []));
-        yield tokenEvent;
-        yield history;
+export function AddToken(token, options) {
+    const { redeemed, fee, addHistory = true } = options ?? {};
+    return async ({ factory, user, publish, signer, sign }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        const amount = sumProofs(token.proofs);
+        // Create the token and history events
+        const tokenEvent = await factory.create(WalletTokenBlueprint, token).then(sign);
+        let history;
+        if (addHistory || redeemed?.length) {
+            history = await factory
+                .create(WalletHistoryBlueprint, { direction: "in", amount, mint: token.mint, created: [tokenEvent.id], fee }, redeemed)
+                .then(sign);
+        }
+        // Publish the events
+        await publish([tokenEvent, history].filter((e) => !!e), wallet.relays);
+    };
+}
+/** Similar to the AddToken action but swaps the tokens before receiving them */
+export function ReceiveToken(token, options) {
+    return async ({ run }) => {
+        const { couch, ...restOptions } = options ?? {};
+        // Get the cashu wallet
+        const cashuWallet = new Wallet(token.mint);
+        await cashuWallet.loadMint();
+        const amount = sumProofs(token.proofs);
+        // Swap cashu tokens
+        const receivedProofs = await cashuWallet.ops.receive(token).run();
+        const fee = amount - sumProofs(receivedProofs);
+        // Create a new token with the received proofs
+        const receivedToken = {
+            ...token,
+            proofs: receivedProofs,
+        };
+        // Store token in couch immediately after receiving it
+        const clearStoredToken = await couch?.store(receivedToken);
+        try {
+            // Run the add token action
+            await run(AddToken, receivedToken, { ...restOptions, fee });
+            // Clear the stored token from the couch after successful completion
+            await clearStoredToken?.();
+        }
+        catch (error) {
+            // If an error occurs, don't clear the couch (tokens remain for recovery)
+            throw error;
+        }
     };
 }
 /** An action that deletes old tokens and creates a new one but does not add a history event */
 export function RolloverTokens(tokens, token) {
-    return async function* ({ factory }) {
-        // create a delete event for old tokens
-        const deleteDraft = await factory.create(DeleteBlueprint, tokens);
+    return async ({ factory, user, publish, signer, sign }) => {
+        const wallet = await getUnlockedWallet(user, signer);
         // create a new token event
-        const tokenDraft = await factory.create(WalletTokenBlueprint, token, tokens.map((e) => e.id));
-        // sign events
-        const signedDelete = await factory.sign(deleteDraft);
-        const signedToken = await factory.sign(tokenDraft);
+        const tokenEvent = await factory
+            .create(WalletTokenBlueprint, token, tokens.map((e) => e.id))
+            .then(sign);
+        // create a delete event for old tokens
+        const deleteDraft = await factory.create(DeleteBlueprint, tokens).then(sign);
         // publish events
-        yield signedDelete;
-        yield signedToken;
+        await publish([tokenEvent, deleteDraft], wallet.relays);
     };
 }
 /** An action that deletes old token events and adds a spend history item */
-export function CompleteSpend(spent, change) {
-    return async function* ({ factory }) {
+export function CompleteSpend(spent, change, couch) {
+    return async ({ factory, user, publish, signer, sign }) => {
         if (spent.length === 0)
             throw new Error("Cant complete spent with no token events");
-        if (spent.some((s) => isTokenContentUnlocked(s)))
+        const unlocked = spent.filter(isTokenContentUnlocked);
+        if (unlocked.length !== spent.length)
             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);
-        const changeAmount = change.proofs.reduce((t, p) => t + p.amount, 0);
-        // create a new token event if needed
-        const changeDraft = changeAmount > 0
-            ? await factory.create(WalletTokenBlueprint, change, spent.map((e) => e.id))
-            : undefined;
-        const total = spent.reduce((total, token) => total + getTokenContent(token).proofs.reduce((t, p) => t + p.amount, 0), 0);
-        // calculate the amount that was spent
-        const diff = total - changeAmount;
-        // sign delete and token
-        const signedDelete = await factory.sign(deleteDraft);
-        const signedToken = changeDraft && (await factory.sign(changeDraft));
-        // create a history entry
-        const history = await factory.create(WalletHistoryBlueprint, { direction: "out", mint: change.mint, amount: diff, created: signedToken ? [signedToken.id] : [] }, []);
-        // sign history
-        const signedHistory = await factory.sign(history);
-        // publish events
-        yield signedDelete;
-        if (signedToken)
-            yield signedToken;
-        yield signedHistory;
+        const wallet = await getUnlockedWallet(user, signer);
+        const changeAmount = sumProofs(change.proofs);
+        // Store change token in couch before creating token event
+        let clearStoredToken;
+        if (couch && changeAmount > 0) {
+            clearStoredToken = await couch.store(change);
+        }
+        try {
+            // create a new token event if needed
+            const tokenEvent = changeAmount > 0
+                ? await factory
+                    .create(WalletTokenBlueprint, change, spent.map((e) => e.id))
+                    .then(sign)
+                : undefined;
+            // Get tokens total amount
+            const total = sumProofs(unlocked.map((s) => getTokenContent(s).proofs).flat());
+            // calculate the amount that was spent
+            const diff = total - changeAmount;
+            // sign delete and token
+            const deleteEvent = await factory.create(DeleteBlueprint, spent).then(sign);
+            // create a history entry
+            const history = await factory
+                .create(WalletHistoryBlueprint, { direction: "out", mint: change.mint, amount: diff, created: tokenEvent ? [tokenEvent.id] : [] }, [])
+                .then(sign);
+            // publish events
+            await publish([tokenEvent, deleteEvent, history].filter((e) => !!e), wallet.relays);
+            // Clear the stored token from the couch after successful completion
+            await clearStoredToken?.();
+        }
+        catch (error) {
+            // If an error occurs, don't clear the couch (tokens remain for recovery)
+            throw error;
+        }
     };
 }
 /** Combines all unlocked token events into a single event per mint */
-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 (isTokenContentUnlocked(token)) {
-                if (opts?.ignoreLocked)
-                    return false;
-                else
-                    throw new Error("Token is locked");
+export function ConsolidateTokens(options) {
+    return async ({ events, factory, self, sign, user, signer, publish }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
+        // Unlock tokens if requested
+        if (options?.unlockTokens) {
+            if (!signer)
+                throw new Error("Missing signer");
+            for (const token of tokens) {
+                if (!isTokenContentUnlocked(token)) {
+                    try {
+                        await unlockTokenContent(token, signer);
+                    }
+                    catch { }
+                }
             }
-            else
-                return true;
-        });
-        const byMint = tokens.reduce((map, token) => {
+        }
+        // Collect unlocked tokens
+        const unlockedTokens = tokens.filter(isTokenContentUnlocked);
+        // group tokens by mint
+        const byMint = unlockedTokens.reduce((map, token) => {
             const mint = getTokenContent(token).mint;
             if (!map.has(mint))
                 map.set(mint, []);
@@ -85,26 +146,228 @@ export function ConsolidateTokens(opts) {
         }, new Map());
         // loop over each mint and consolidate proofs
         for (const [mint, tokens] of byMint) {
-            const cashuMint = new Mint(mint);
-            const cashuWallet = new Wallet(cashuMint);
             // get all tokens proofs
             const proofs = tokens
-                .map((t) => getTokenContent(t).proofs)
+                .map((token) => getTokenContent(token).proofs)
                 .flat()
                 // filter out duplicate proofs
                 .filter(ignoreDuplicateProofs());
+            // If there are no proofs, just delete the old tokens without interacting with the mint
+            if (proofs.length === 0) {
+                const deleteEvent = await factory.create(DeleteBlueprint, tokens).then(sign);
+                await publish(deleteEvent, wallet.relays);
+                continue;
+            }
+            // Only interact with the mint if there are proofs to check
+            const cashuWallet = new Wallet(mint);
+            await cashuWallet.loadMint();
             // NOTE: this assumes that the states array is the same length and order as the proofs array
             const states = await cashuWallet.checkProofsStates(proofs);
             const notSpent = proofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
-            // create delete and token event
-            const deleteDraft = await factory.create(DeleteBlueprint, tokens);
-            const tokenDraft = await factory.create(WalletTokenBlueprint, { mint, proofs: notSpent }, tokens.map((t) => t.id));
-            // sign events
-            const signedToken = await factory.sign(tokenDraft);
-            const signedDelete = await factory.sign(deleteDraft);
-            // publish events for mint
-            yield signedToken;
-            yield signedDelete;
+            // Only create a token event if there are unspent proofs
+            const tokenEvent = notSpent.length > 0
+                ? await factory
+                    .create(WalletTokenBlueprint, { mint, proofs: notSpent }, tokens.map((t) => t.id))
+                    .then(sign)
+                : undefined;
+            // create delete event
+            const deleteEvent = await factory.create(DeleteBlueprint, tokens).then(sign);
+            // Publish events
+            await publish([tokenEvent, deleteEvent].filter((e) => !!e), wallet.relays);
+        }
+    };
+}
+/**
+ * Recovers tokens from a couch by checking if they exist in the wallet,
+ * verifying they are unspent, and creating token events for any recoverable tokens
+ * @param couch the couch interface to recover tokens from
+ */
+export function RecoverFromCouch(couch) {
+    return async ({ events, factory, self, sign, user, signer, publish }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        // Get all tokens from the couch
+        const couchTokens = await couch.getAll();
+        if (couchTokens.length === 0)
+            return; // No tokens to recover
+        // Get all token events from the wallet
+        const walletTokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
+        // Unlock wallet tokens if needed
+        if (signer) {
+            for (const token of walletTokens) {
+                if (!isTokenContentUnlocked(token)) {
+                    try {
+                        await unlockTokenContent(token, signer);
+                    }
+                    catch { }
+                }
+            }
+        }
+        // Collect all proofs from wallet tokens
+        const walletProofs = walletTokens
+            .filter(isTokenContentUnlocked)
+            .map((token) => getTokenContent(token).proofs)
+            .flat();
+        // Create a set of seen proof UIDs from wallet
+        const seenProofUIDs = new Set();
+        walletProofs.forEach((proof) => {
+            seenProofUIDs.add(getProofUID(proof));
+        });
+        // Group couch tokens by mint
+        const couchTokensByMint = new Map();
+        for (const token of couchTokens) {
+            if (!couchTokensByMint.has(token.mint)) {
+                couchTokensByMint.set(token.mint, []);
+            }
+            couchTokensByMint.get(token.mint).push(token);
+        }
+        // Process each mint group
+        for (const [mint, tokens] of couchTokensByMint) {
+            // Get all proofs from couch tokens for this mint
+            const couchProofs = tokens.flatMap((token) => token.proofs);
+            // Filter out proofs that are already in the wallet
+            const newProofs = couchProofs.filter((proof) => {
+                const uid = getProofUID(proof);
+                if (seenProofUIDs.has(uid))
+                    return false;
+                seenProofUIDs.add(uid);
+                return true;
+            });
+            if (newProofs.length === 0)
+                continue; // No new proofs to recover
+            // Check if proofs are unspent from the mint
+            const cashuWallet = new Wallet(mint);
+            await cashuWallet.loadMint();
+            const states = await cashuWallet.checkProofsStates(newProofs);
+            const unspentProofs = newProofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
+            if (unspentProofs.length === 0)
+                continue; // No unspent proofs to recover
+            // Create a token event with the recovered proofs
+            const recoveredToken = {
+                mint,
+                proofs: unspentProofs,
+                unit: tokens[0]?.unit,
+            };
+            const tokenEvent = await factory.create(WalletTokenBlueprint, recoveredToken).then(sign);
+            // Publish the token event
+            await publish(tokenEvent, wallet.relays);
+            // Clear the token from the couch
+            await couch.clear();
+        }
+    };
+}
+/**
+ * A generic action that safely selects tokens, performs an async operation, and handles change.
+ * This action requires a couch for safety - tokens are stored in the couch before the operation
+ * and can be recovered if something goes wrong.
+ *
+ * @param minAmount The minimum amount of tokens to select (in sats)
+ * @param operation An async function that receives selected proofs and performs the operation.
+ *                  Should return any change proofs. All selected proofs are considered used.
+ * @param options Configuration options including mint filter, required couch, and optional custom token selection
+ *
+ * @example
+ * // Use with NutzapProfile
+ * await run(TokensOperation, 100, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   const { keep, send } = await cashuWallet.ops.send(100, selectedProofs).asP2PK({ pubkey }).run();
+ *   await run(NutzapProfile, recipient, { mint, proofs: send, unit: "sat" });
+ *   return { change: keep };
+ * }, { couch });
+ *
+ * @example
+ * // Use with melt
+ * await run(TokensOperation, meltAmount + feeReserve, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   const meltQuote = await cashuWallet.createMeltQuoteBolt11(invoice);
+ *   const { keep, send } = await cashuWallet.send(meltAmount + meltQuote.fee_reserve, selectedProofs, { includeFees: true });
+ *   const meltResponse = await cashuWallet.meltProofs(meltQuote, send);
+ *   return { change: meltResponse.change };
+ * }, { couch });
+ *
+ * @example
+ * // Use with custom token selection
+ * await run(TokensOperation, 100, async ({ selectedProofs, mint, cashuWallet }) => {
+ *   // ... operation
+ * }, { couch, tokenSelection: myCustomSelectionFunction });
+ */
+export function TokensOperation(minAmount, operation, options) {
+    const { mint, couch, tokenSelection = dumbTokenSelection } = options;
+    return async ({ events, self, user, signer, run }) => {
+        if (!signer)
+            throw new Error("Missing signer");
+        if (!couch)
+            throw new Error("Couch is required for TokensOperation");
+        await getUnlockedWallet(user, signer);
+        // Get all unlocked token events
+        const allTokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] }));
+        // Unlock tokens if needed
+        for (const token of allTokens) {
+            if (!isTokenContentUnlocked(token)) {
+                try {
+                    await unlockTokenContent(token, signer);
+                }
+                catch { }
+            }
+        }
+        // Filter to unlocked tokens
+        const unlockedTokens = allTokens.filter(isTokenContentUnlocked);
+        if (unlockedTokens.length === 0)
+            throw new Error("No unlocked tokens available");
+        // Select tokens using the provided token selection function (defaults to dumbTokenSelection)
+        // The selection function will find a mint with sufficient balance if mint is undefined
+        // and ensures all selected tokens are from the same mint
+        const { events: selectedTokenEvents, proofs: selectedProofs } = tokenSelection(unlockedTokens, minAmount, mint);
+        if (selectedProofs.length === 0)
+            throw new Error("No proofs selected");
+        // Get the mint from the first selected token
+        // The token selection function guarantees all tokens are from the same mint
+        const firstTokenContent = getTokenContent(selectedTokenEvents[0]);
+        if (!firstTokenContent)
+            throw new Error("Unable to get content from selected token");
+        const selectedMint = firstTokenContent.mint;
+        if (!selectedMint)
+            throw new Error("Unable to determine mint from selected tokens");
+        // Safety check: Verify all selected tokens are from the same mint
+        // (The token selection function should have already ensured this, but verify for safety)
+        for (const tokenEvent of selectedTokenEvents) {
+            const tokenContent = getTokenContent(tokenEvent);
+            if (!tokenContent)
+                throw new Error("Unable to get content from selected token");
+            const tokenMint = tokenContent.mint;
+            if (tokenMint !== selectedMint)
+                throw new Error(`Selected tokens must be from the same mint. Found ${tokenMint} and ${selectedMint}`);
+        }
+        // Store selected tokens in couch for safety
+        const selectedToken = {
+            mint: selectedMint,
+            proofs: selectedProofs,
+            unit: "sat",
+        };
+        const clearStoredToken = await couch.store(selectedToken);
+        try {
+            // Create cashu wallet for the mint
+            const cashuWallet = new Wallet(selectedMint);
+            await cashuWallet.loadMint();
+            // Perform the async operation
+            // All selected proofs are considered used - the operation only needs to return change (if any)
+            const { change } = await operation({
+                selectedProofs,
+                mint: selectedMint,
+                cashuWallet,
+            });
+            // Create change token from the change proofs returned by the operation (if any)
+            const changeToken = {
+                mint: selectedMint,
+                proofs: change ? change.filter(ignoreDuplicateProofs()) : [],
+                unit: "sat",
+            };
+            // Complete the spend with change (if any)
+            // If there's no change, all selected proofs were spent
+            await run(CompleteSpend, selectedTokenEvents, changeToken, couch);
+            // Clear the stored token from the couch after successful completion
+            await clearStoredToken();
+        }
+        catch (error) {
+            // If an error occurs, don't clear the couch (tokens remain for recovery)
+            throw error;
         }
     };
 }

package/dist/actions/wallet.d.ts

@@ -1,13 +1,28 @@
 import { Action } from "applesauce-actions";
+import "../casts/__register__.js";
 /** An action that creates a new 17375 wallet event and 375 wallet backup */
-export declare function CreateWallet(mints: string[], privateKey?: Uint8Array): Action;
+export declare function CreateWallet({ mints, privateKey, relays, }: {
+    mints: string[];
+    privateKey?: Uint8Array;
+    relays?: string[];
+}): Action;
 /**
  * Adds a private key to a wallet event
- * @throws if the wallet does not exist or is locked
+ * @throws if the wallet does not exist or cannot be unlocked
  */
-export declare function WalletAddPrivateKey(privateKey: Uint8Array): Action;
+export declare function WalletAddPrivateKey(privateKey: Uint8Array, override?: boolean): Action;
 /** Unlocks the wallet event and optionally the tokens and history events */
 export declare function UnlockWallet(unlock?: {
     history?: boolean;
     tokens?: boolean;
 }): Action;
+/**
+ * Sets the mints on a wallet event
+ * @throws if the wallet does not exist or cannot be unlocked
+ */
+export declare function SetWalletMints(mints: string[]): Action;
+/**
+ * Sets the relays on a wallet event
+ * @throws if the wallet does not exist or cannot be unlocked
+ */
+export declare function SetWalletRelays(relays: (string | URL)[]): Action;

package/dist/actions/wallet.js

@@ -1,64 +1,106 @@
 import { WalletBackupBlueprint, WalletBlueprint } from "../blueprints/wallet.js";
-import { isHistoryContentUnlocked, unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
-import { isTokenContentUnlocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
-import { getWalletMints, getWalletPrivateKey, isWalletUnlocked, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
+import { unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
+import { NUTZAP_INFO_KIND } from "../helpers/nutzap-info.js";
+import { unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { getWalletMints, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
+import { setNutzapInfoPubkey } from "../operations/nutzap-info.js";
+import { setMints, setRelays } from "../operations/wallet.js";
+import { getUnlockedWallet } from "./common.js";
+// Make sure the wallet$ is registered on the user class
+import "../casts/__register__.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 }) {
+export function CreateWallet({ mints, privateKey, relays, }) {
+    return async ({ events, factory, self, publish }) => {
+        if (mints.length === 0)
+            throw new Error("At least one mint is required");
         const existing = events.getReplaceable(WALLET_KIND, self);
         if (existing)
             throw new Error("Wallet already exists");
-        const wallet = await factory.sign(await factory.create(WalletBlueprint, mints, privateKey));
-        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, wallet));
-        // publish the backup first
-        yield backup;
-        yield wallet;
+        // Create new wallet event
+        const wallet = await factory.sign(await factory.create(WalletBlueprint, { mints, privateKey, relays }));
+        // Setup nutzap info event
+        if (privateKey) {
+            // Create a backup event if a private key is provided
+            const backup = await factory.sign(await factory.create(WalletBackupBlueprint, wallet));
+            const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+            // Always set pubkey if private key is provided (create or update)
+            const nutzapInfoDraft = nutzapInfo
+                ? await factory.modify(nutzapInfo, setNutzapInfoPubkey(privateKey))
+                : await factory.build({ kind: NUTZAP_INFO_KIND }, setNutzapInfoPubkey(privateKey));
+            const info = await factory.sign(nutzapInfoDraft);
+            // Publish all events at the same time
+            await publish([wallet, backup, info], relays);
+        }
+        else {
+            // Just publish the wallet event
+            await publish(wallet, relays);
+        }
     };
 }
 /**
  * Adds a private key to a wallet event
- * @throws if the wallet does not exist or is locked
+ * @throws if the wallet does not exist or cannot be unlocked
  */
-export function WalletAddPrivateKey(privateKey) {
-    return async function* ({ events, self, factory }) {
-        const wallet = events.getReplaceable(WALLET_KIND, self);
-        if (!wallet)
-            throw new Error("Wallet does not exist");
-        if (isWalletUnlocked(wallet))
-            throw new Error("Wallet is locked");
-        if (getWalletPrivateKey(wallet))
+export function WalletAddPrivateKey(privateKey, override = false) {
+    return async ({ events, self, factory, user, signer, sign, publish }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        if (wallet.privateKey && override !== true)
             throw new Error("Wallet already has a private key");
-        const draft = await factory.create(WalletBlueprint, getWalletMints(wallet), privateKey);
-        const signed = await factory.sign(draft);
+        const signed = await factory
+            .create(WalletBlueprint, { mints: getWalletMints(wallet.event), privateKey })
+            .then(sign);
         // create backup event for wallet
-        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, signed));
-        // publish events
-        yield backup;
-        yield signed;
+        const backup = await factory.create(WalletBackupBlueprint, signed).then(sign);
+        // set nutzap info pubkey for receiving nutzaps
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const info = nutzapInfo
+            ? await factory.modify(nutzapInfo, setNutzapInfoPubkey(privateKey)).then(sign)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, setNutzapInfoPubkey(privateKey)).then(sign);
+        // publish all events at the same time
+        await publish([signed, backup, info], wallet.relays);
     };
 }
 /** Unlocks the wallet event and optionally the tokens and history events */
 export function UnlockWallet(unlock) {
-    return async function* ({ events, self, factory }) {
+    return async ({ events, self, factory }) => {
         const signer = factory.context.signer;
         if (!signer)
             throw new Error("Missing signer");
         const wallet = events.getReplaceable(WALLET_KIND, self);
         if (!wallet)
             throw new Error("Wallet does not exist");
-        if (isWalletUnlocked(wallet))
-            await unlockWallet(wallet, signer);
+        await unlockWallet(wallet, signer);
         if (unlock?.tokens) {
             const tokens = events.getTimeline({ kinds: [WALLET_TOKEN_KIND], authors: [self] });
             for (const token of tokens)
-                if (isTokenContentUnlocked(token))
-                    await unlockTokenContent(token, signer);
+                await unlockTokenContent(token, signer);
         }
         if (unlock?.history) {
             const history = events.getTimeline({ kinds: [WALLET_HISTORY_KIND], authors: [self] });
             for (const entry of history)
-                if (isHistoryContentUnlocked(entry))
-                    await unlockHistoryContent(entry, signer);
+                await unlockHistoryContent(entry, signer);
         }
     };
 }
+/**
+ * Sets the mints on a wallet event
+ * @throws if the wallet does not exist or cannot be unlocked
+ */
+export function SetWalletMints(mints) {
+    return async ({ user, signer, factory, sign, publish }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        const signed = await factory.modify(wallet.event, setMints(mints)).then(sign);
+        await publish(signed, wallet.relays);
+    };
+}
+/**
+ * Sets the relays on a wallet event
+ * @throws if the wallet does not exist or cannot be unlocked
+ */
+export function SetWalletRelays(relays) {
+    return async ({ user, signer, factory, sign, publish }) => {
+        const wallet = await getUnlockedWallet(user, signer);
+        const signed = await factory.modify(wallet.event, setRelays(relays)).then(sign);
+        await publish(signed, relays.map(String));
+    };
+}

package/dist/blueprints/history.d.ts

@@ -1,4 +1,4 @@
 import { EventPointer } from "applesauce-core/helpers/pointers";
 import { HistoryContent } from "../helpers/history.js";
 /** A blueprint that creates a wallet history event */
-export declare function WalletHistoryBlueprint(content: HistoryContent, redeemed: (string | EventPointer)[]): import("applesauce-core").EventBlueprint;
+export declare function WalletHistoryBlueprint(content: HistoryContent, redeemed?: (string | EventPointer)[]): import("applesauce-core").EventBlueprint;

package/dist/blueprints/history.js

@@ -7,5 +7,5 @@ export function WalletHistoryBlueprint(content, redeemed) {
     // set the encrypted tags on the event
     setHistoryContent(content), 
     // set the public redeemed tags
-    setHistoryRedeemed(redeemed));
+    redeemed ? setHistoryRedeemed(redeemed) : undefined);
 }

package/dist/blueprints/wallet.d.ts

@@ -1,5 +1,9 @@
 import { NostrEvent } from "applesauce-core/helpers/event";
 /** A blueprint to create a new 17375 wallet */
-export declare function WalletBlueprint(mints: string[], privateKey?: Uint8Array): import("applesauce-core").EventBlueprint;
+export declare function WalletBlueprint({ mints, privateKey, relays, }: {
+    mints: string[];
+    privateKey?: Uint8Array;
+    relays?: string[];
+}): import("applesauce-core").EventBlueprint;
 /** A blueprint that creates a new 375 wallet backup event */
 export declare function WalletBackupBlueprint(wallet: NostrEvent): import("applesauce-core").EventBlueprint;