applesauce-wallet 1.0.0 → 3.0.0

package/README.md

@@ -1,3 +1,3 @@
 # Applesauce Wallet
 
-The `applesauce-wallet` package is a package of helpers, queries, blueprints and other useful stuff for [NIP-60](https://github.com/nostr-protocol/nips/blob/master/60.md) wallets and [NIP-61](https://github.com/nostr-protocol/nips/blob/master/61.md) nutzaps
+The `applesauce-wallet` package is a package of helpers, models, blueprints and other useful stuff for [NIP-60](https://github.com/nostr-protocol/nips/blob/master/60.md) wallets and [NIP-61](https://github.com/nostr-protocol/nips/blob/master/61.md) nutzaps

package/dist/actions/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./wallet.js";
 export * from "./tokens.js";
+export * from "./zaps.js";
+export * from "./zap-info.js";

package/dist/actions/index.js

@@ -1,2 +1,4 @@
 export * from "./wallet.js";
 export * from "./tokens.js";
+export * from "./zaps.js";
+export * from "./zap-info.js";

package/dist/actions/tokens.js

@@ -66,7 +66,7 @@ export function CompleteSpend(spent, change) {
 /** 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.getAll({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
+        const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
             if (isTokenContentLocked(token)) {
                 if (opts?.ignoreLocked)
                     return false;

package/dist/actions/zap-info.d.ts

@@ -0,0 +1,22 @@
+import { Action } from "applesauce-actions";
+/** An action to add a relay to the kind 10019 nutzap info event */
+export declare function AddNutzapInfoRelay(relay: string | string[]): Action;
+/** An action to remove a relay from the kind 10019 nutzap info event */
+export declare function RemoveNutzapInfoRelay(relay: string | string[]): Action;
+/** An action to add a mint to the kind 10019 nutzap info event */
+export declare function AddNutzapInfoMint(mint: {
+    url: string;
+    units?: string[];
+} | Array<{
+    url: string;
+    units?: string[];
+}>): Action;
+/** An action to remove a mint from the kind 10019 nutzap info event */
+export declare function RemoveNutzapInfoMint(mint: string | string[]): Action;
+/** An action to set the pubkey for the kind 10019 nutzap info event */
+export declare function SetNutzapInfoPubkey(pubkey: string): Action;
+/** An action to update the entire nutzap info event */
+export declare function UpdateNutzapInfo(relays: string[], mints: Array<{
+    url: string;
+    units?: string[];
+}>, pubkey: string): Action;

package/dist/actions/zap-info.js

@@ -0,0 +1,83 @@
+import { modifyPublicTags } from "applesauce-factory/operations";
+import { addNameValueTag, removeNameValueTag, setSingletonTag } from "applesauce-factory/operations/tag";
+import { NUTZAP_INFO_KIND } from "../helpers/zap-info.js";
+import { setNutzapInfoMints, setNutzapInfoPubkey, setNutzapInfoRelays } from "../operations/zap-info.js";
+/** An action to add a relay to the kind 10019 nutzap info event */
+export function AddNutzapInfoRelay(relay) {
+    return async function* ({ events, factory, self }) {
+        if (typeof relay === "string")
+            relay = [relay];
+        const operations = relay.map((r) => addNameValueTag(["relay", r], false));
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const draft = nutzapInfo
+            ? await factory.modifyTags(nutzapInfo, ...operations)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, modifyPublicTags(...operations));
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}
+/** An action to remove a relay from the kind 10019 nutzap info event */
+export function RemoveNutzapInfoRelay(relay) {
+    return async function* ({ events, factory, self }) {
+        if (typeof relay === "string")
+            relay = [relay];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            return;
+        const draft = await factory.modifyTags(nutzapInfo, ...relay.map((r) => removeNameValueTag(["relay", r])));
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}
+/** An action to add a mint to the kind 10019 nutzap info event */
+export function AddNutzapInfoMint(mint) {
+    return async function* ({ events, factory, self }) {
+        const mints = Array.isArray(mint) ? mint : [mint];
+        const operations = mints.map((m) => {
+            const tag = m.units ? ["mint", m.url, ...m.units] : ["mint", m.url];
+            return addNameValueTag(tag, false);
+        });
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const draft = nutzapInfo
+            ? await factory.modifyTags(nutzapInfo, ...operations)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, modifyPublicTags(...operations));
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}
+/** An action to remove a mint from the kind 10019 nutzap info event */
+export function RemoveNutzapInfoMint(mint) {
+    return async function* ({ events, factory, self }) {
+        if (typeof mint === "string")
+            mint = [mint];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        if (!nutzapInfo)
+            return;
+        const draft = await factory.modifyTags(nutzapInfo, ...mint.map((m) => removeNameValueTag(["mint", m])));
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}
+/** An action to set the pubkey for the kind 10019 nutzap info event */
+export function SetNutzapInfoPubkey(pubkey) {
+    return async function* ({ events, factory, self }) {
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const draft = nutzapInfo
+            ? await factory.modifyTags(nutzapInfo, setSingletonTag(["pubkey", pubkey], true))
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, modifyPublicTags(setSingletonTag(["pubkey", pubkey], true)));
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}
+/** An action to update the entire nutzap info event */
+export function UpdateNutzapInfo(relays, mints, pubkey) {
+    return async function* ({ events, factory, self }) {
+        const operations = [setNutzapInfoRelays(relays), setNutzapInfoMints(mints), setNutzapInfoPubkey(pubkey)];
+        const nutzapInfo = events.getReplaceable(NUTZAP_INFO_KIND, self);
+        const draft = nutzapInfo
+            ? await factory.modify(nutzapInfo, ...operations)
+            : await factory.build({ kind: NUTZAP_INFO_KIND }, ...operations);
+        const signed = await factory.sign(draft);
+        yield signed;
+    };
+}

package/dist/actions/zaps.d.ts

@@ -0,0 +1,8 @@
+import { Token } from "@cashu/cashu-ts";
+import { Action } from "applesauce-actions";
+import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
+/** Creates a NIP-61 nutzap event for an event with a token */
+export declare function NutzapEvent(event: NostrEvent, token: Token, comment?: string): Action;
+/** Creates a NIP-61 nutzap event to a users profile */
+export declare function NutzapProfile(user: string | ProfilePointer, token: Token, comment?: string): Action;

package/dist/actions/zaps.js

@@ -0,0 +1,30 @@
+import { NutzapBlueprint, ProfileNutzapBlueprint } from "../blueprints/zaps.js";
+import { NUTZAP_INFO_KIND, verifyProofsLocked } from "../helpers/zap-info.js";
+/** Creates a NIP-61 nutzap event for an event with a token */
+export function NutzapEvent(event, token, comment) {
+    return async function* ({ events, factory }) {
+        const recipient = event.pubkey;
+        const info = events.getReplaceable(NUTZAP_INFO_KIND, recipient);
+        if (!info)
+            throw new Error("Nutzap info not found");
+        // Verify all tokens are p2pk locked
+        verifyProofsLocked(token.proofs, info);
+        // NOTE: Disabled because mints and units should be checked by the app before
+        // const mints = getNutzapInfoMints(info);
+        // if (!mints.some((m) => m.mint === token.mint)) throw new Error("Token mint not found in nutzap info");
+        const nutzap = await factory.sign(await factory.create(NutzapBlueprint, event, token, comment || token.memo));
+        yield nutzap;
+    };
+}
+/** Creates a NIP-61 nutzap event to a users profile */
+export function NutzapProfile(user, token, comment) {
+    return async function* ({ events, factory }) {
+        const info = events.getReplaceable(NUTZAP_INFO_KIND, typeof user === "string" ? user : user.pubkey);
+        if (!info)
+            throw new Error("Nutzap info not found");
+        // Verify all tokens are p2pk locked
+        verifyProofsLocked(token.proofs, info);
+        const nutzap = await factory.sign(await factory.create(ProfileNutzapBlueprint, user, token, comment || token.memo));
+        yield nutzap;
+    };
+}

package/dist/blueprints/history.d.ts

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

package/dist/blueprints/history.js

@@ -1,9 +1,9 @@
+import { blueprint } from "applesauce-factory";
 import { WALLET_HISTORY_KIND } from "../helpers/history.js";
-import { EventFactory } from "applesauce-factory";
-import { setHistoryContent, setHistoryRedeemed } from "../operations/event/history.js";
+import { setHistoryContent, setHistoryRedeemed } from "../operations/history.js";
 /** A blueprint that creates a wallet history event */
 export function WalletHistoryBlueprint(content, redeemed) {
-    return (ctx) => EventFactory.runProcess({ kind: WALLET_HISTORY_KIND }, ctx, 
+    return blueprint(WALLET_HISTORY_KIND, 
     // set the encrypted tags on the event
     setHistoryContent(content), 
     // set the public redeemed tags

package/dist/blueprints/index.d.ts

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

package/dist/blueprints/index.js

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

package/dist/blueprints/tokens.d.ts

@@ -1,8 +1,7 @@
 import { Token } from "@cashu/cashu-ts";
-import { EventBlueprint } from "applesauce-factory";
 /**
  * A blueprint for a wallet token event, takes a cashu token and previous deleted token event ids
  * @param token the cashu token to store
  * @param [del=[]] an array of previous token event ids that are deleted
  */
-export declare function WalletTokenBlueprint(token: Token, del?: string[]): EventBlueprint;
+export declare function WalletTokenBlueprint(token: Token, del?: string[]): import("applesauce-factory").EventBlueprint;

package/dist/blueprints/tokens.js

@@ -1,11 +1,11 @@
-import { EventFactory } from "applesauce-factory";
+import { blueprint } from "applesauce-factory";
 import { WALLET_TOKEN_KIND } from "../helpers/tokens.js";
-import { setTokenContent } from "../operations/event/tokens.js";
+import { setToken } from "../operations/tokens.js";
 /**
  * A blueprint for a wallet token event, takes a cashu token and previous deleted token event ids
  * @param token the cashu token to store
  * @param [del=[]] an array of previous token event ids that are deleted
  */
 export function WalletTokenBlueprint(token, del = []) {
-    return (ctx) => EventFactory.runProcess({ kind: WALLET_TOKEN_KIND }, ctx, setTokenContent(token, del));
+    return blueprint(WALLET_TOKEN_KIND, setToken(token, del));
 }

package/dist/blueprints/wallet.d.ts

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

package/dist/blueprints/wallet.js

@@ -1,13 +1,11 @@
-import { EventFactory } from "applesauce-factory";
-import { modifyHiddenTags } from "applesauce-factory/operations/event";
+import { blueprint } from "applesauce-factory";
 import { WALLET_BACKUP_KIND, WALLET_KIND } from "../helpers/wallet.js";
-import { setWalletBackupContent } from "../operations/event/wallet.js";
-import { setMintTags, setPrivateKeyTag } from "../operations/tag/wallet.js";
+import { setBackupContent, setMints, setPrivateKey } from "../operations/wallet.js";
 /** A blueprint to create a new 17375 wallet */
 export function WalletBlueprint(mints, privateKey) {
-    return (ctx) => EventFactory.runProcess({ kind: WALLET_KIND }, ctx, modifyHiddenTags(privateKey ? setPrivateKeyTag(privateKey) : undefined, setMintTags(mints)));
+    return blueprint(WALLET_KIND, setMints(mints), privateKey ? setPrivateKey(privateKey) : undefined);
 }
 /** A blueprint that creates a new 375 wallet backup event */
 export function WalletBackupBlueprint(wallet) {
-    return (ctx) => EventFactory.runProcess({ kind: WALLET_BACKUP_KIND }, ctx, setWalletBackupContent(wallet));
+    return blueprint(WALLET_BACKUP_KIND, setBackupContent(wallet));
 }

package/dist/blueprints/zaps.d.ts

@@ -0,0 +1,8 @@
+import { Token } from "@cashu/cashu-ts";
+import { EventBlueprint } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+import { ProfilePointer } from "nostr-tools/nip19";
+/** A blueprint to create a NIP-61 nutzap event for an event */
+export declare function NutzapBlueprint(event: NostrEvent, token: Token, comment?: string): EventBlueprint;
+/** A blueprint to create a NIP-61 nutzap event for a user instead of an event */
+export declare function ProfileNutzapBlueprint(user: string | ProfilePointer, token: Token, comment?: string): EventBlueprint;

package/dist/blueprints/zaps.js

@@ -0,0 +1,12 @@
+import { blueprint } from "applesauce-factory";
+import { skip } from "applesauce-factory/helpers";
+import { NUTZAP_KIND } from "../helpers/nutzap.js";
+import { setComment, setEvent, setMint, setProofs, setRecipient } from "../operations/nutzap.js";
+/** A blueprint to create a NIP-61 nutzap event for an event */
+export function NutzapBlueprint(event, token, comment) {
+    return blueprint(NUTZAP_KIND, setProofs(token.proofs), setMint(token.mint), setEvent(event), setRecipient(event.pubkey), comment ? setComment(comment) : skip());
+}
+/** A blueprint to create a NIP-61 nutzap event for a user instead of an event */
+export function ProfileNutzapBlueprint(user, token, comment) {
+    return blueprint(NUTZAP_KIND, setProofs(token.proofs), setMint(token.mint), setRecipient(user), comment ? setComment(comment) : skip());
+}

package/dist/helpers/history.js

@@ -1,5 +1,7 @@
-import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_HISTORY_KIND = 7376;
+// Enable hidden content for wallet history kind
+setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
 export const HistoryContentSymbol = Symbol.for("history-content");
 /** returns an array of redeemed event ids in a history event */
 export function getHistoryRedeemed(history) {

package/dist/helpers/index.d.ts

@@ -1,4 +1,6 @@
-export * from "./wallet.js";
-export * from "./tokens.js";
-export * from "./history.js";
 export * from "./animated-qr.js";
+export * from "./history.js";
+export * from "./tokens.js";
+export * from "./wallet.js";
+export * from "./zap-info.js";
+export * from "./nutzap.js";

package/dist/helpers/index.js

@@ -1,4 +1,6 @@
-export * from "./wallet.js";
-export * from "./tokens.js";
-export * from "./history.js";
 export * from "./animated-qr.js";
+export * from "./history.js";
+export * from "./tokens.js";
+export * from "./wallet.js";
+export * from "./zap-info.js";
+export * from "./nutzap.js";

package/dist/helpers/nutzap.d.ts

@@ -0,0 +1,27 @@
+import { Proof } from "@cashu/cashu-ts";
+import { NostrEvent } from "nostr-tools";
+import { AddressPointer, EventPointer } from "nostr-tools/nip19";
+export declare const NUTZAP_KIND = 9321;
+export declare const NutzapProofsSymbol: unique symbol;
+export declare const NutzapAmountSymbol: unique symbol;
+export declare const NutzapMintSymbol: unique symbol;
+/** Returns the cashu proofs from a kind:9321 nutzap event */
+export declare function getNutzapProofs(event: NostrEvent): Proof[];
+/** Returns the mint URL from a kind:9321 nutzap event */
+export declare function getNutzapMint(event: NostrEvent): string | undefined;
+/** Returns the recipient pubkey from a kind:9321 nutzap event */
+export declare function getNutzapRecipient(event: NostrEvent): string | undefined;
+/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
+export declare function getNutzapEventPointer(event: NostrEvent): EventPointer | undefined;
+/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
+export declare function getNutzapAddressPointer(event: NostrEvent): AddressPointer | undefined;
+/** Returns the EventPointer or AddressPointer from a kind:9321 nutzap event */
+export declare function getNutzapPointer(event: NostrEvent): EventPointer | AddressPointer | undefined;
+/** Returns the comment from a kind:9321 nutzap event */
+export declare function getNutzapComment(event: NostrEvent): string | undefined;
+/** Calculates the total amount of sats in a kind:9321 nutzap event */
+export declare function getNutzapAmount(event: NostrEvent): number;
+/** Checks if a nutzap is valid according to NIP-61 requirements */
+export declare function isValidNutzap(nutzap: NostrEvent): boolean;
+/** Checks if a nutzap event has already been redeemed based on kind:7376 wallet history events */
+export declare function isNutzapRedeemed(nutzapId: string, history: NostrEvent[]): boolean;

package/dist/helpers/nutzap.js

@@ -0,0 +1,66 @@
+import { getAddressPointerFromATag, getEventPointerFromETag, getOrComputeCachedValue, getTagValue, processTags, safeParse, } from "applesauce-core/helpers";
+import { getHistoryRedeemed } from "./history.js";
+export const NUTZAP_KIND = 9321;
+// Symbols for caching computed values
+export const NutzapProofsSymbol = Symbol.for("nutzap-proofs");
+export const NutzapAmountSymbol = Symbol.for("nutzap-amount");
+export const NutzapMintSymbol = Symbol.for("nutzap-mint");
+/** Returns the cashu proofs from a kind:9321 nutzap event */
+export function getNutzapProofs(event) {
+    return getOrComputeCachedValue(event, NutzapProofsSymbol, () => {
+        return processTags(event.tags, (tag) => (tag[0] === "proof" ? safeParse(tag[1]) : undefined));
+    });
+}
+/** Returns the mint URL from a kind:9321 nutzap event */
+export function getNutzapMint(event) {
+    return getOrComputeCachedValue(event, NutzapMintSymbol, () => {
+        const url = getTagValue(event, "u");
+        return url && URL.canParse(url) ? url : undefined;
+    });
+}
+/** Returns the recipient pubkey from a kind:9321 nutzap event */
+export function getNutzapRecipient(event) {
+    return getTagValue(event, "p");
+}
+/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
+export function getNutzapEventPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e");
+    if (!tag)
+        return;
+    return getEventPointerFromETag(tag);
+}
+/** Returns the event ID being nutzapped from a kind:9321 nutzap event */
+export function getNutzapAddressPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "a");
+    if (!tag)
+        return;
+    return getAddressPointerFromATag(tag);
+}
+/** Returns the EventPointer or AddressPointer from a kind:9321 nutzap event */
+export function getNutzapPointer(event) {
+    return getNutzapEventPointer(event) ?? getNutzapAddressPointer(event);
+}
+/** Returns the comment from a kind:9321 nutzap event */
+export function getNutzapComment(event) {
+    return event.content || undefined;
+}
+/** Calculates the total amount of sats in a kind:9321 nutzap event */
+export function getNutzapAmount(event) {
+    return getOrComputeCachedValue(event, NutzapAmountSymbol, () => {
+        const proofs = getNutzapProofs(event);
+        return proofs.reduce((total, proof) => total + (proof.amount || 0), 0);
+    });
+}
+/** Checks if a nutzap is valid according to NIP-61 requirements */
+export function isValidNutzap(nutzap) {
+    const mint = getNutzapMint(nutzap);
+    const recipient = getNutzapRecipient(nutzap);
+    const proofs = getNutzapProofs(nutzap);
+    if (!mint || !recipient || proofs.length === 0)
+        return false;
+    return true;
+}
+/** Checks if a nutzap event has already been redeemed based on kind:7376 wallet history events */
+export function isNutzapRedeemed(nutzapId, history) {
+    return history.some((entry) => getHistoryRedeemed(entry).includes(nutzapId));
+}

package/dist/helpers/tokens.d.ts

@@ -1,11 +1,11 @@
 import { Proof, Token } from "@cashu/cashu-ts";
 import { HiddenContentSigner } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
+export declare const WALLET_TOKEN_KIND = 7375;
 /** Internal method for creating a unique id for each proof */
 export declare function getProofUID(proof: Proof): string;
 /** Internal method to filter out duplicate proofs */
 export declare function ignoreDuplicateProofs(seen?: Set<string>): (proof: Proof) => boolean;
-export declare const WALLET_TOKEN_KIND = 7375;
 export type TokenContent = {
     /** Cashu mint for the proofs */
     mint: string;

package/dist/helpers/tokens.js

@@ -1,5 +1,8 @@
 import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
-import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, unlockHiddenContent, } from "applesauce-core/helpers";
+import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenContent, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+export const WALLET_TOKEN_KIND = 7375;
+// 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;
@@ -16,7 +19,6 @@ export function ignoreDuplicateProofs(seen = new Set()) {
         }
     };
 }
-export const WALLET_TOKEN_KIND = 7375;
 export const TokenContentSymbol = Symbol.for("token-content");
 /**
  * Returns the decrypted and parsed details of a 7375 token event

package/dist/helpers/wallet.js

@@ -1,7 +1,10 @@
 import { hexToBytes } from "@noble/hashes/utils";
-import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, getOrComputeCachedValue, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_KIND = 17375;
 export const WALLET_BACKUP_KIND = 375;
+// 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");
 /** Returns if a wallet is locked */

package/dist/helpers/zap-info.d.ts

@@ -0,0 +1,19 @@
+import { Proof } from "@cashu/cashu-ts";
+import { NostrEvent } from "nostr-tools";
+export declare const NUTZAP_INFO_KIND = 10019;
+export declare const NutzapMintsSymbol: unique symbol;
+export declare const NutzapRelaysSymbol: unique symbol;
+/** Returns the relay URLs from a kind:10019 nutzap info event */
+export declare function getNutzapInfoRelays(event: NostrEvent): string[];
+/** Returns the mint URLs from a kind:10019 nutzap info event */
+export declare function getNutzapInfoMints(event: NostrEvent): {
+    mint: string;
+    units?: string[];
+}[];
+/** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
+export declare function getNutzapInfoPubkey(event: NostrEvent): string | undefined;
+/**
+ * verfies if proofs are locked to nutzap info
+ * @throws {Error} if proofs are not locked to nutzap info
+ */
+export declare function verifyProofsLocked(proofs: Proof[], info: NostrEvent): void;

package/dist/helpers/zap-info.js

@@ -0,0 +1,42 @@
+import { getOrComputeCachedValue, mergeRelaySets, safeParse } from "applesauce-core/helpers";
+export const NUTZAP_INFO_KIND = 10019;
+// Symbols for caching computed values
+export const NutzapMintsSymbol = Symbol.for("nutzap-mints");
+export const NutzapRelaysSymbol = Symbol.for("nutzap-relays");
+/** Returns the relay URLs from a kind:10019 nutzap info event */
+export function getNutzapInfoRelays(event) {
+    return getOrComputeCachedValue(event, NutzapRelaysSymbol, () => {
+        return mergeRelaySets(event.tags.filter((t) => t[0] === "relay").map((t) => t[1]));
+    });
+}
+/** Returns the mint URLs from a kind:10019 nutzap info event */
+export function getNutzapInfoMints(event) {
+    return getOrComputeCachedValue(event, NutzapMintsSymbol, () => {
+        return event.tags.filter((t) => t[0] === "mint").map((t) => ({ mint: t[1], units: t.slice(2).filter(Boolean) }));
+    });
+}
+/** Returns the pubkey for P2PK-locking from a kind:10019 nutzap info event */
+export function getNutzapInfoPubkey(event) {
+    return event.tags.find((t) => t[0] === "pubkey")?.[1];
+}
+/**
+ * verfies if proofs are locked to nutzap info
+ * @throws {Error} if proofs are not locked to nutzap info
+ */
+export function verifyProofsLocked(proofs, info) {
+    const pubkey = getNutzapInfoPubkey(info);
+    if (!pubkey)
+        throw new Error("Nutzap info must have a pubkey");
+    const fullPubkey = pubkey.length === 64 ? `02${pubkey}` : pubkey;
+    for (const proof of proofs) {
+        const secret = safeParse(proof.secret);
+        if (!secret)
+            throw new Error(`Cashu token must have a spending condition`);
+        if (!Array.isArray(secret))
+            throw new Error("Invalid spending condition");
+        if (secret[0] !== "P2PK")
+            throw new Error("Token proofs must be P2PK locked");
+        if (secret[1].data !== fullPubkey)
+            throw new Error("Token proofs must be P2PK locked to the recipient's nutzap pubkey");
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/models/history.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+/** 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[]>;

package/dist/{queries → models}/history.js

@@ -1,15 +1,15 @@
 import { combineLatest, filter, map, scan, startWith } from "rxjs";
 import { getHistoryRedeemed, isHistoryContentLocked, WALLET_HISTORY_KIND } from "../helpers/history.js";
-/** Query that returns an array of redeemed event ids for a wallet */
-export function WalletRedeemedQuery(pubkey) {
+/** A model that returns an array of redeemed event ids for a wallet */
+export function WalletRedeemedModel(pubkey) {
     return (events) => events
         .filters({ kinds: [WALLET_HISTORY_KIND], authors: [pubkey] })
         .pipe(scan((ids, history) => [...ids, ...getHistoryRedeemed(history)], []));
 }
-/** A query that returns a timeline of wallet history events */
-export function WalletHistoryQuery(pubkey, locked) {
+/** A model that returns a timeline of wallet history events */
+export function WalletHistoryModel(pubkey, locked) {
     return (events) => {
-        const updates = events.updates.pipe(filter((e) => e.kind === WALLET_HISTORY_KIND && e.pubkey === pubkey), startWith(undefined));
+        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)

package/dist/{operations/event → models}/index.d.ts

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

package/dist/{operations/event → models}/index.js

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

package/dist/models/nutzap.d.ts

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

package/dist/models/nutzap.js

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

package/dist/models/tokens.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "applesauce-core";
+import { NostrEvent } from "nostr-tools";
+/** 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 returns the visible balance of a wallet for each mint */
+export declare function WalletBalanceModel(pubkey: string): Model<Record<string, number>>;