applesauce-wallet 5.0.0 → 6.0.0

package/dist/actions/mint-recomendation.js

@@ -1,8 +1,7 @@
 import { Wallet } from "@cashu/cashu-ts";
-import { MintRecommendationBlueprint } from "../blueprints/mint-recommendation.js";
+import { MintRecommendationFactory } from "../factories/mint-recommendation.js";
 import { getCashuMintPubkey, getCashuMintURL, isValidCashuMintInfo } from "../helpers/mint-info.js";
 import { MINT_RECOMMENDATION_KIND, getRecommendationMintPubkey, isValidMintRecommendation, } from "../helpers/mint-recommendation.js";
-import { setComment } from "../operations/mint-recommendation.js";
 // Helper function to fetch mint pubkey from URL
 async function fetchMintPubkey(mintUrl) {
     // Fetch mint info directly from the /v1/info endpoint
@@ -21,10 +20,12 @@ import "../casts/__register__.js";
  * Can accept a mint URL, Wallet instance, or MintInfo event.
  */
 export function RecommendMint(input, options) {
-    return async ({ factory, sign, publish }) => {
+    return async ({ signer, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         let mintPubkey;
         let url;
-        let addressPointer = undefined;
+        let mintInfoEvent = undefined;
         // Handle different input types
         if (typeof input === "string") {
             if (!URL.canParse(input))
@@ -43,18 +44,16 @@ export function RecommendMint(input, options) {
                 throw new Error("Invalid mint info event. Expected kind:38172 with required `d` and `u` tags.");
             mintPubkey = getCashuMintPubkey(input);
             url = getCashuMintURL(input);
-            // Use the event itself as address pointer (blueprint will convert it)
-            addressPointer = input;
+            // Use the event itself as address pointer (factory will convert it)
+            mintInfoEvent = input;
         }
         // Create the mint recommendation event
-        const recommendation = await factory
-            .create(MintRecommendationBlueprint, {
-            mintPubkey,
-            url,
-            addressPointer,
-            comment: options?.comment,
-        })
-            .then(sign);
+        let recommendationFactory = MintRecommendationFactory.create(url || "", mintPubkey);
+        if (mintInfoEvent)
+            recommendationFactory = recommendationFactory.mintInfo(mintInfoEvent);
+        if (options?.comment)
+            recommendationFactory = recommendationFactory.comment(options.comment);
+        const recommendation = await recommendationFactory.sign(signer);
         // Publish the event
         await publish(recommendation, options?.relays);
     };
@@ -64,7 +63,7 @@ export function RecommendMint(input, options) {
  * Can accept a mint pubkey (to find the recommendation) or the recommendation event directly.
  */
 export function UpdateMintRecommendation(input, comment, options) {
-    return async ({ events, factory, self, sign, publish }) => {
+    return async ({ events, signer, self, publish }) => {
         let recommendation;
         // Handle different input types
         if (typeof input === "string") {
@@ -89,7 +88,7 @@ export function UpdateMintRecommendation(input, comment, options) {
             recommendation = input;
         }
         // Update the comment
-        const updated = await factory.modify(recommendation, setComment(comment)).then(sign);
+        const updated = await MintRecommendationFactory.modify(recommendation).comment(comment).sign(signer);
         // Publish the updated event
         await publish(updated, options?.relays);
     };

package/dist/actions/nutzap-info.js

@@ -1,74 +1,70 @@
 import { getNutzapInfoRelays, NUTZAP_INFO_KIND } from "../helpers/nutzap-info.js";
-import { addNutzapInfoMint, addNutzapInfoRelay, removeNutzapInfoMint, removeNutzapInfoRelay, setNutzapInfoMints, setNutzapInfoPubkey, setNutzapInfoRelays, } from "../operations/nutzap-info.js";
+import { NutzapInfoFactory } from "../factories/nutzap-info.js";
 // Make sure the nutzap$ is registered on the user class
 import "../casts/__register__.js";
 /** An action to add a relay to the kind 10019 nutzap info event */
 export function AddNutzapInfoRelay(relay) {
-    return async ({ events, factory, self, sign, publish }) => {
+    return async ({ events, signer, self, publish }) => {
         if (typeof relay === "string")
             relay = [relay];
-        const operations = relay.map((r) => addNutzapInfoRelay(r));
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
-        const signed = nutzapInfo
-            ? await factory.modify(nutzapInfo, ...operations).then(sign)
-            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        let factory = nutzapInfo ? NutzapInfoFactory.modify(nutzapInfo) : NutzapInfoFactory.create();
+        for (const r of relay)
+            factory = factory.addRelay(r);
+        const signed = await factory.sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }
 /** An action to remove a relay from the kind 10019 nutzap info event */
 export function RemoveNutzapInfoRelay(relay) {
-    return async ({ events, factory, self, sign, publish }) => {
+    return async ({ events, signer, self, publish }) => {
         if (typeof relay === "string")
             relay = [relay];
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
         if (!nutzapInfo)
             return;
-        const operations = relay.map((r) => removeNutzapInfoRelay(r));
-        const signed = await factory.modify(nutzapInfo, ...operations).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        let factory = NutzapInfoFactory.modify(nutzapInfo);
+        for (const r of relay)
+            factory = factory.removeRelay(r);
+        const signed = await factory.sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }
 /** An action to add a mint to the kind 10019 nutzap info event */
 export function AddNutzapInfoMint(mint) {
-    return async ({ events, factory, self, sign, publish }) => {
+    return async ({ events, signer, self, publish }) => {
         const mints = Array.isArray(mint) ? mint : [mint];
-        const operations = mints.map((m) => addNutzapInfoMint(m));
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
-        const signed = nutzapInfo
-            ? await factory.modify(nutzapInfo, ...operations).then(sign)
-            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        let factory = nutzapInfo ? NutzapInfoFactory.modify(nutzapInfo) : NutzapInfoFactory.create();
+        for (const m of mints)
+            factory = factory.addMint(m);
+        const signed = await factory.sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }
 /** An action to remove a mint from the kind 10019 nutzap info event */
 export function RemoveNutzapInfoMint(mint) {
-    return async ({ events, factory, self, sign, publish }) => {
+    return async ({ events, signer, self, publish }) => {
         if (typeof mint === "string")
             mint = [mint];
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
         if (!nutzapInfo)
             return;
-        const operations = mint.map((m) => removeNutzapInfoMint(m));
-        const signed = await factory.modify(nutzapInfo, ...operations).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        let factory = NutzapInfoFactory.modify(nutzapInfo);
+        for (const m of mint)
+            factory = factory.removeMint(m);
+        const signed = await factory.sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }
 /** An action to update the entire nutzap info event */
 export function UpdateNutzapInfo(relays, mints) {
-    return async ({ events, factory, self, sign, publish }) => {
-        const operations = [setNutzapInfoRelays(relays), setNutzapInfoMints(mints)];
+    return async ({ events, signer, self, publish }) => {
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
-        const signed = nutzapInfo
-            ? await factory.modify(nutzapInfo, ...operations).then(sign)
-            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations).then(sign);
+        const signed = await (nutzapInfo ? NutzapInfoFactory.modify(nutzapInfo) : NutzapInfoFactory.create())
+            .setRelays(relays)
+            .setMints(mints)
+            .sign(signer);
         await publish(signed, relays);
     };
 }
@@ -77,14 +73,12 @@ export function UpdateNutzapInfo(relays, mints) {
  * @throws if the nutzap info does not exist
  */
 export function SetNutzapInfoMints(mints) {
-    return async ({ events, self, factory, sign, publish }) => {
+    return async ({ events, self, signer, publish }) => {
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
         if (!nutzapInfo)
             throw new Error("Nutzap info does not exist");
-        const signed = await factory.modify(nutzapInfo, setNutzapInfoMints(mints)).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        const signed = await NutzapInfoFactory.modify(nutzapInfo).setMints(mints).sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }
 /**
@@ -92,11 +86,11 @@ export function SetNutzapInfoMints(mints) {
  * @throws if the nutzap info does not exist
  */
 export function SetNutzapInfoRelays(relays) {
-    return async ({ events, self, factory, sign, publish }) => {
+    return async ({ events, self, signer, publish }) => {
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
         if (!nutzapInfo)
             throw new Error("Nutzap info does not exist");
-        const signed = await factory.modify(nutzapInfo, setNutzapInfoRelays(relays)).then(sign);
+        const signed = await NutzapInfoFactory.modify(nutzapInfo).setRelays(relays).sign(signer);
         await publish(signed, relays);
     };
 }
@@ -105,13 +99,11 @@ export function SetNutzapInfoRelays(relays) {
  * @throws if the nutzap info does not exist
  */
 export function SetNutzapInfoPubkey(privateKey) {
-    return async ({ events, self, factory, sign, publish }) => {
+    return async ({ events, self, signer, publish }) => {
         const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
         if (!nutzapInfo)
             throw new Error("Nutzap info does not exist");
-        const signed = await factory.modify(nutzapInfo, setNutzapInfoPubkey(privateKey)).then(sign);
-        // Use relays from the updated event
-        const relays = getNutzapInfoRelays(signed);
-        await publish(signed, relays);
+        const signed = await NutzapInfoFactory.modify(nutzapInfo).setPubkey(privateKey).sign(signer);
+        await publish(signed, getNutzapInfoRelays(signed));
     };
 }

package/dist/actions/nutzaps.js

@@ -1,9 +1,9 @@
 import { sumProofs, Wallet } from "@cashu/cashu-ts";
 import { castUser } from "applesauce-common/casts";
 import { bytesToHex } from "applesauce-core/helpers/event";
-import { WalletHistoryBlueprint } from "../blueprints/history.js";
-import { WalletTokenBlueprint } from "../blueprints/tokens.js";
-import { NutzapBlueprint, ProfileNutzapBlueprint } from "../blueprints/zaps.js";
+import { WalletHistoryFactory } from "../factories/history.js";
+import { WalletTokenFactory } from "../factories/tokens.js";
+import { NutzapFactory } from "../factories/nutzap.js";
 import { verifyProofsLocked } from "../helpers/nutzap-info.js";
 import { getNutzapMint, getNutzapProofs, isValidNutzap } from "../helpers/nutzap.js";
 import { getUnlockedWallet } from "./common.js";
@@ -11,7 +11,9 @@ import { getUnlockedWallet } from "./common.js";
 import "../casts/__register__.js";
 /** Creates a NIP-61 nutzap event for an event with a token */
 export function NutzapEvent(event, token, options) {
-    return async ({ events, factory, user, signer, sign, publish }) => {
+    return async ({ events, signer, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         const { comment, couch } = options ?? {};
         const clearStoredToken = await couch?.store(token);
         try {
@@ -25,7 +27,7 @@ export function NutzapEvent(event, token, options) {
             // Verify all tokens are p2pk locked
             verifyProofsLocked(token.proofs, info.event);
             // Create the nutzap event
-            const nutzap = await factory.create(NutzapBlueprint, event, token, comment || token.memo).then(sign);
+            const nutzap = await NutzapFactory.forEvent(event, token, comment || token.memo).sign(signer);
             // Publish the nutzap event
             await publish(nutzap, wallet.relays);
         }
@@ -35,7 +37,9 @@ export function NutzapEvent(event, token, options) {
 }
 /** Creates a NIP-61 nutzap event to a users profile */
 export function NutzapProfile(user, token, options) {
-    return async ({ events, factory, sign, publish }) => {
+    return async ({ events, signer, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         const { comment, couch } = options ?? {};
         const clearStoredToken = await couch?.store(token);
         try {
@@ -47,7 +51,7 @@ export function NutzapProfile(user, token, options) {
             // Verify all tokens are p2pk locked
             verifyProofsLocked(token.proofs, info.event);
             // Create the nutzap event
-            const nutzap = await factory.create(ProfileNutzapBlueprint, recipient, token, comment || token.memo).then(sign);
+            const nutzap = await NutzapFactory.forProfile(recipient, token, comment || token.memo).sign(signer);
             // Publish the nutzap event
             await publish(nutzap, info.relays);
         }
@@ -63,7 +67,7 @@ export function NutzapProfile(user, token, options) {
  * @param couch optional couch interface for temporarily storing tokens during the operation
  */
 export function ReceiveNutzaps(nutzaps, couch) {
-    return async ({ factory, user, signer, sign, publish }) => {
+    return async ({ signer, user, publish }) => {
         if (!signer)
             throw new Error("Missing signer");
         // Normalize to array
@@ -133,12 +137,17 @@ export function ReceiveNutzaps(nutzaps, couch) {
                 if (clearStoredToken) {
                     clearMethods.push(clearStoredToken);
                 }
-                const tokenEvent = await factory.create(WalletTokenBlueprint, receivedToken, []).then(sign);
+                const tokenEvent = await WalletTokenFactory.create(receivedToken, []).sign(signer);
                 // Create history event marking nutzap events as redeemed
                 const nutzapIds = mintNutzaps.map((n) => n.id);
-                const history = await factory
-                    .create(WalletHistoryBlueprint, { direction: "in", amount, mint, created: [tokenEvent.id] }, nutzapIds)
-                    .then(sign);
+                const history = await WalletHistoryFactory.create({
+                    direction: "in",
+                    amount,
+                    mint,
+                    created: [tokenEvent.id],
+                })
+                    .redeemed(nutzapIds)
+                    .sign(signer);
                 // Publish events
                 await publish(tokenEvent, wallet.relays);
                 await publish(history, wallet.relays);

package/dist/actions/tokens.js

@@ -1,7 +1,7 @@
 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 { DeleteFactory } from "applesauce-core/factories";
+import { WalletHistoryFactory } from "../factories/history.js";
+import { WalletTokenFactory } from "../factories/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";
@@ -14,16 +14,25 @@ import "../casts/__register__.js";
  */
 export function AddToken(token, options) {
     const { redeemed, fee, addHistory = true } = options ?? {};
-    return async ({ factory, user, publish, signer, sign }) => {
+    return async ({ signer, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         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);
+        const tokenEvent = await WalletTokenFactory.create(token).sign(signer);
         let history;
         if (addHistory || redeemed?.length) {
-            history = await factory
-                .create(WalletHistoryBlueprint, { direction: "in", amount, mint: token.mint, created: [tokenEvent.id], fee }, redeemed)
-                .then(sign);
+            let historyFactory = WalletHistoryFactory.create({
+                direction: "in",
+                amount,
+                mint: token.mint,
+                created: [tokenEvent.id],
+                fee,
+            });
+            if (redeemed?.length)
+                historyFactory = historyFactory.redeemed(redeemed);
+            history = await historyFactory.sign(signer);
         }
         // Publish the events
         await publish([tokenEvent, history].filter((e) => !!e), wallet.relays);
@@ -61,21 +70,23 @@ export function ReceiveToken(token, options) {
 }
 /** 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 ({ factory, user, publish, signer, sign }) => {
+    return async ({ signer, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         const wallet = await getUnlockedWallet(user, signer);
         // create a new token event
-        const tokenEvent = await factory
-            .create(WalletTokenBlueprint, token, tokens.map((e) => e.id))
-            .then(sign);
+        const tokenEvent = await WalletTokenFactory.create(token, tokens.map((e) => e.id)).sign(signer);
         // create a delete event for old tokens
-        const deleteDraft = await factory.create(DeleteBlueprint, tokens).then(sign);
+        const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
         // publish events
-        await publish([tokenEvent, deleteDraft], wallet.relays);
+        await publish([tokenEvent, deleteEvent], wallet.relays);
     };
 }
 /** An action that deletes old token events and adds a spend history item */
 export function CompleteSpend(spent, change, couch) {
-    return async ({ factory, user, publish, signer, sign }) => {
+    return async ({ signer, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         if (spent.length === 0)
             throw new Error("Cant complete spent with no token events");
         const unlocked = spent.filter(isTokenContentUnlocked);
@@ -91,20 +102,23 @@ export function CompleteSpend(spent, change, couch) {
         try {
             // create a new token event if needed
             const tokenEvent = changeAmount > 0
-                ? await factory
-                    .create(WalletTokenBlueprint, change, spent.map((e) => e.id))
-                    .then(sign)
+                ? await WalletTokenFactory.create(change, spent.map((e) => e.id)).sign(signer)
                 : 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);
+            const deleteEvent = await DeleteFactory.fromEvents(spent).sign(signer);
             // create a history entry
-            const history = await factory
-                .create(WalletHistoryBlueprint, { direction: "out", mint: change.mint, amount: diff, created: tokenEvent ? [tokenEvent.id] : [] }, [])
-                .then(sign);
+            const history = await WalletHistoryFactory.create({
+                direction: "out",
+                mint: change.mint,
+                amount: diff,
+                created: tokenEvent ? [tokenEvent.id] : [],
+            })
+                .redeemed([])
+                .sign(signer);
             // publish events
             await publish([tokenEvent, deleteEvent, history].filter((e) => !!e), wallet.relays);
             // Clear the stored token from the couch after successful completion
@@ -118,13 +132,13 @@ export function CompleteSpend(spent, change, couch) {
 }
 /** Combines all unlocked token events into a single event per mint */
 export function ConsolidateTokens(options) {
-    return async ({ events, factory, self, sign, user, signer, publish }) => {
+    return async ({ events, signer, self, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         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 {
@@ -154,7 +168,7 @@ export function ConsolidateTokens(options) {
                 .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);
+                const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
                 await publish(deleteEvent, wallet.relays);
                 continue;
             }
@@ -166,12 +180,10 @@ export function ConsolidateTokens(options) {
             const notSpent = proofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
             // 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)
+                ? await WalletTokenFactory.create({ mint, proofs: notSpent }, tokens.map((t) => t.id)).sign(signer)
                 : undefined;
             // create delete event
-            const deleteEvent = await factory.create(DeleteBlueprint, tokens).then(sign);
+            const deleteEvent = await DeleteFactory.fromEvents(tokens).sign(signer);
             // Publish events
             await publish([tokenEvent, deleteEvent].filter((e) => !!e), wallet.relays);
         }
@@ -183,7 +195,9 @@ export function ConsolidateTokens(options) {
  * @param couch the couch interface to recover tokens from
  */
 export function RecoverFromCouch(couch) {
-    return async ({ events, factory, self, sign, user, signer, publish }) => {
+    return async ({ events, signer, self, user, publish }) => {
+        if (!signer)
+            throw new Error("Missing signer");
         const wallet = await getUnlockedWallet(user, signer);
         // Get all tokens from the couch
         const couchTokens = await couch.getAll();
@@ -192,14 +206,12 @@ export function RecoverFromCouch(couch) {
         // 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 { }
+        for (const token of walletTokens) {
+            if (!isTokenContentUnlocked(token)) {
+                try {
+                    await unlockTokenContent(token, signer);
                 }
+                catch { }
             }
         }
         // Collect all proofs from wallet tokens
@@ -247,7 +259,7 @@ export function RecoverFromCouch(couch) {
                 proofs: unspentProofs,
                 unit: tokens[0]?.unit,
             };
-            const tokenEvent = await factory.create(WalletTokenBlueprint, recoveredToken).then(sign);
+            const tokenEvent = await WalletTokenFactory.create(recoveredToken).sign(signer);
             // Publish the token event
             await publish(tokenEvent, wallet.relays);
             // Clear the token from the couch

package/dist/actions/wallet.js

@@ -1,33 +1,31 @@
-import { WalletBackupBlueprint, WalletBlueprint } from "../blueprints/wallet.js";
+import { WalletBackupFactory, WalletFactory } from "../factories/wallet.js";
+import { NutzapInfoFactory } from "../factories/nutzap-info.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, relays, }) {
-    return async ({ events, factory, self, publish }) => {
+    return async ({ events, signer, 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");
         // Create new wallet event
-        const wallet = await factory.sign(await factory.create(WalletBlueprint, { mints, privateKey, relays }));
+        const wallet = await WalletFactory.create(mints, privateKey, relays).sign(signer);
         // 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 backup = await WalletBackupFactory.create(wallet).sign(signer);
             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);
+            const info = nutzapInfo
+                ? await NutzapInfoFactory.modify(nutzapInfo).setPubkey(privateKey).sign(signer)
+                : await NutzapInfoFactory.create().setPubkey(privateKey).sign(signer);
             // Publish all events at the same time
             await publish([wallet, backup, info], relays);
         }
@@ -42,30 +40,25 @@ export function CreateWallet({ mints, privateKey, relays, }) {
  * @throws if the wallet does not exist or cannot be unlocked
  */
 export function WalletAddPrivateKey(privateKey, override = false) {
-    return async ({ events, self, factory, user, signer, sign, publish }) => {
+    return async ({ events, self, signer, user, publish }) => {
         const wallet = await getUnlockedWallet(user, signer);
         if (wallet.privateKey && override !== true)
             throw new Error("Wallet already has a private key");
-        const signed = await factory
-            .create(WalletBlueprint, { mints: getWalletMints(wallet.event), privateKey })
-            .then(sign);
+        const signed = await WalletFactory.create(getWalletMints(wallet.event), privateKey).as(signer).sign();
         // create backup event for wallet
-        const backup = await factory.create(WalletBackupBlueprint, signed).then(sign);
+        const backup = await WalletBackupFactory.create(signed).sign(signer);
         // 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);
+            ? await NutzapInfoFactory.modify(nutzapInfo).setPubkey(privateKey).sign(signer)
+            : await NutzapInfoFactory.create().setPubkey(privateKey).sign(signer);
         // 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 ({ events, self, factory }) => {
-        const signer = factory.context.signer;
-        if (!signer)
-            throw new Error("Missing signer");
+    return async ({ events, self, signer }) => {
         const wallet = events.getReplaceable(WALLET_KIND, self);
         if (!wallet)
             throw new Error("Wallet does not exist");
@@ -87,9 +80,9 @@ export function UnlockWallet(unlock) {
  * @throws if the wallet does not exist or cannot be unlocked
  */
 export function SetWalletMints(mints) {
-    return async ({ user, signer, factory, sign, publish }) => {
+    return async ({ user, signer, publish }) => {
         const wallet = await getUnlockedWallet(user, signer);
-        const signed = await factory.modify(wallet.event, setMints(mints)).then(sign);
+        const signed = await WalletFactory.modify(wallet.event).mints(mints).sign(signer);
         await publish(signed, wallet.relays);
     };
 }
@@ -98,9 +91,9 @@ export function SetWalletMints(mints) {
  * @throws if the wallet does not exist or cannot be unlocked
  */
 export function SetWalletRelays(relays) {
-    return async ({ user, signer, factory, sign, publish }) => {
+    return async ({ user, signer, publish }) => {
         const wallet = await getUnlockedWallet(user, signer);
-        const signed = await factory.modify(wallet.event, setRelays(relays)).then(sign);
+        const signed = await WalletFactory.modify(wallet.event).relays(relays.map(String)).sign(signer);
         await publish(signed, relays.map(String));
     };
 }

package/dist/casts/__register__.d.ts

@@ -3,7 +3,7 @@ import { NutzapInfo } from "./nutzap-info.js";
 import { Nutzap } from "./nutzap.js";
 import { Wallet } from "./wallet.js";
 import { MintRecommendation } from "./mint-recommendation.js";
-declare module "applesauce-common/casts/user" {
+declare module "applesauce-core/casts" {
     interface User {
         readonly wallet$: ChainableObservable<Wallet | undefined>;
         readonly nutzap$: ChainableObservable<NutzapInfo | undefined>;

package/dist/casts/__register__.js

@@ -1,5 +1,5 @@
 import { Note, Stream } from "applesauce-common/casts";
-import { User } from "applesauce-common/casts/user";
+import { User } from "applesauce-core/casts";
 import { castEventStream, castTimelineStream } from "applesauce-common/observable";
 import { buildCommonEventRelationFilters } from "applesauce-core/helpers";
 import { switchMap } from "rxjs";

package/dist/casts/mint-info.d.ts

@@ -2,6 +2,7 @@ import { CastRefEventStore, EventCast } from "applesauce-common/casts";
 import { NostrEvent } from "applesauce-core/helpers/event";
 import { CashuMintInfoEvent } from "../helpers/mint-info.js";
 import { MintRecommendation } from "./mint-recommendation.js";
+/** A cast for a NIP-87 cashu mint info event */
 export declare class MintInfo extends EventCast<CashuMintInfoEvent> {
     constructor(event: NostrEvent, store: CastRefEventStore);
     /** The mint's pubkey (from the `d` tag) */

package/dist/casts/mint-info.js

@@ -3,10 +3,12 @@ import { castTimelineStream } from "applesauce-common/observable";
 import { getCashuMintMetadata, getCashuMintNetwork, getCashuMintNuts, getCashuMintPubkey, getCashuMintURL, isValidCashuMintInfo, } from "../helpers/mint-info.js";
 import { MINT_RECOMMENDATION_KIND } from "../helpers/mint-recommendation.js";
 import { MintRecommendation } from "./mint-recommendation.js";
+/** A cast for a NIP-87 cashu mint info event */
 export class MintInfo extends EventCast {
     constructor(event, store) {
-        if (!isValidCashuMintInfo(event))
+        if (!isValidCashuMintInfo(event)) {
             throw new Error("Invalid cashu mint info event");
+        }
         super(event, store);
     }
     /** The mint's pubkey (from the `d` tag) */