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

package/dist/blueprints/wallet.js

@@ -1,9 +1,12 @@
 import { blueprint } from "applesauce-core";
+import { modifyHiddenTags } from "applesauce-core/operations";
 import { WALLET_BACKUP_KIND, WALLET_KIND } from "../helpers/wallet.js";
-import { setBackupContent, setMints, setPrivateKey } from "../operations/wallet.js";
+import { setBackupContent, setMintTags, setPrivateKeyTag, setRelayTags } from "../operations/wallet.js";
 /** A blueprint to create a new 17375 wallet */
-export function WalletBlueprint(mints, privateKey) {
-    return blueprint(WALLET_KIND, setMints(mints), privateKey ? setPrivateKey(privateKey) : undefined);
+export function WalletBlueprint({ mints, privateKey, relays, }) {
+    return blueprint(WALLET_KIND, 
+    // Use top level modifyHiddenTags to avoid multiple encryption operations
+    modifyHiddenTags(setMintTags(mints), privateKey ? setPrivateKeyTag(privateKey) : undefined, relays ? setRelayTags(relays) : undefined));
 }
 /** A blueprint that creates a new 375 wallet backup event */
 export function WalletBackupBlueprint(wallet) {

package/dist/casts/__register__.d.ts

@@ -0,0 +1,20 @@
+import { ChainableObservable } from "applesauce-common/observable";
+import { NutzapInfo } from "./nutzap-info.js";
+import { Nutzap } from "./nutzap.js";
+import { Wallet } from "./wallet.js";
+declare module "applesauce-common/casts/user" {
+    interface User {
+        readonly wallet$: ChainableObservable<Wallet | undefined>;
+        readonly nutzap$: ChainableObservable<NutzapInfo | undefined>;
+    }
+}
+declare module "applesauce-common/casts/stream" {
+    interface Stream {
+        readonly nutzaps$: ChainableObservable<Nutzap[]>;
+    }
+}
+declare module "applesauce-common/casts/note" {
+    interface Note {
+        nutzaps$(): ChainableObservable<Nutzap[]>;
+    }
+}

package/dist/casts/__register__.js

@@ -0,0 +1,41 @@
+import { Note, Stream } from "applesauce-common/casts";
+import { User } from "applesauce-common/casts/user";
+import { castEventStream, castTimelineStream } from "applesauce-common/observable";
+import { buildCommonEventRelationFilters } from "applesauce-core/helpers";
+import { switchMap } from "rxjs";
+import { NUTZAP_KIND } from "../helpers/nutzap.js";
+import { WALLET_KIND } from "../helpers/wallet.js";
+import { NUTZAP_INFO_KIND } from "../helpers/nutzap-info.js";
+import { NutzapInfo } from "./nutzap-info.js";
+import { Nutzap } from "./nutzap.js";
+import { Wallet } from "./wallet.js";
+Object.defineProperty(User.prototype, "wallet$", {
+    get: function () {
+        return this.$$ref("wallet$", (store) => this.outboxes$.pipe(switchMap((outboxes) => store
+            .replaceable({ kind: WALLET_KIND, pubkey: this.pubkey, relays: outboxes })
+            .pipe(castEventStream(Wallet, store)))));
+    },
+    enumerable: true,
+    configurable: false,
+});
+Object.defineProperty(User.prototype, "nutzap$", {
+    get: function () {
+        return this.$$ref("nutzap$", (store) => store.replaceable(NUTZAP_INFO_KIND, this.pubkey).pipe(castEventStream(NutzapInfo, store)));
+    },
+    enumerable: true,
+    configurable: false,
+});
+Note.prototype.nutzaps$ = function () {
+    return this.$$ref("nutzaps$", (store) => store
+        .timeline(buildCommonEventRelationFilters({ kinds: [NUTZAP_KIND] }, this.event))
+        .pipe(castTimelineStream(Nutzap, store)));
+};
+Object.defineProperty(Stream.prototype, "nutzaps$", {
+    get: function () {
+        return this.$$ref("nutzaps$", (store) => store
+            .timeline(buildCommonEventRelationFilters({ kinds: [NUTZAP_KIND] }, this.event))
+            .pipe(castTimelineStream(Nutzap, store)));
+    },
+    enumerable: true,
+    configurable: false,
+});

package/dist/casts/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./nutzap-info.js";
+export * from "./nutzap.js";
+export * from "./wallet-history.js";
+export * from "./wallet-token.js";
+export * from "./wallet.js";
+import "./__register__.js";

package/dist/casts/index.js

@@ -0,0 +1,6 @@
+export * from "./nutzap-info.js";
+export * from "./nutzap.js";
+export * from "./wallet-history.js";
+export * from "./wallet-token.js";
+export * from "./wallet.js";
+import "./__register__.js";

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

@@ -0,0 +1,14 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { NutzapInfoEvent } from "../helpers/nutzap-info.js";
+export declare class NutzapInfo extends EventCast<NutzapInfoEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get relays(): string[];
+    get mints(): {
+        mint: string;
+        units?: string[];
+    }[];
+    /** The p2pk public key to use when zapping */
+    get publicKey(): string | undefined;
+    get p2pk(): string | undefined;
+}

package/dist/casts/nutzap-info.js

@@ -0,0 +1,22 @@
+import { EventCast } from "applesauce-common/casts";
+import { getNutzapInfoMints, getNutzapInfoPubkey, getNutzapInfoRelays, isValidNutzapInfo, } from "../helpers/nutzap-info.js";
+export class NutzapInfo extends EventCast {
+    constructor(event, store) {
+        if (!isValidNutzapInfo(event))
+            throw new Error("Invalid nutzap info");
+        super(event, store);
+    }
+    get relays() {
+        return getNutzapInfoRelays(this.event);
+    }
+    get mints() {
+        return getNutzapInfoMints(this.event);
+    }
+    /** The p2pk public key to use when zapping */
+    get publicKey() {
+        return getNutzapInfoPubkey(this.event);
+    }
+    get p2pk() {
+        return this.publicKey;
+    }
+}

package/dist/casts/nutzap.d.ts

@@ -0,0 +1,16 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { NutzapEvent } from "../helpers/nutzap.js";
+export declare class Nutzap extends EventCast<NutzapEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get proofs(): import("@cashu/cashu-ts").Proof[];
+    get mint(): string;
+    get amount(): number;
+    get recipient(): import("applesauce-common/casts").User;
+    get sender(): import("applesauce-common/casts").User;
+    get comment(): string | undefined;
+    /** The pointer to the event that was zapped */
+    get pointer(): import("nostr-tools/nip19").EventPointer | import("nostr-tools/nip19").AddressPointer | undefined;
+    /** The event that was zapped */
+    get zapped$(): import("applesauce-common/observable").ChainableObservable<import("nostr-tools").Event | undefined>;
+}

package/dist/casts/nutzap.js

@@ -0,0 +1,37 @@
+import { EventCast } from "applesauce-common/casts";
+import { castUser } from "applesauce-common/casts/user";
+import { of } from "rxjs";
+import { getNutzapAddressPointer, getNutzapAmount, getNutzapComment, getNutzapEventPointer, getNutzapMint, getNutzapProofs, getNutzapRecipient, isValidNutzap, } from "../helpers/nutzap.js";
+export class Nutzap extends EventCast {
+    constructor(event, store) {
+        if (!isValidNutzap(event))
+            throw new Error("Invalid nutzap");
+        super(event, store);
+    }
+    get proofs() {
+        return getNutzapProofs(this.event);
+    }
+    get mint() {
+        return getNutzapMint(this.event);
+    }
+    get amount() {
+        return getNutzapAmount(this.event);
+    }
+    get recipient() {
+        return castUser(getNutzapRecipient(this.event), this.store);
+    }
+    get sender() {
+        return this.author;
+    }
+    get comment() {
+        return getNutzapComment(this.event);
+    }
+    /** The pointer to the event that was zapped */
+    get pointer() {
+        return getNutzapAddressPointer(this.event) ?? getNutzapEventPointer(this.event);
+    }
+    /** The event that was zapped */
+    get zapped$() {
+        return this.$$ref("zapped$", (store) => (this.pointer ? store.event(this.pointer) : of(undefined)));
+    }
+}

package/dist/casts/wallet-history.d.ts

@@ -0,0 +1,16 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { WalletHistoryEvent } from "../helpers/history.js";
+export declare class WalletHistory extends EventCast<WalletHistoryEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** The embedded history metadata */
+    get meta(): import("../helpers/history.js").HistoryContent | undefined;
+    get direction(): import("../helpers/history.js").HistoryDirection | undefined;
+    get amount(): number | undefined;
+    get redeemed(): string[];
+    get unlocked(): boolean;
+    unlock(signer: HiddenContentSigner): Promise<import("../helpers/history.js").HistoryContent>;
+    get meta$(): import("applesauce-common/observable").ChainableObservable<import("../helpers/history.js").HistoryContent | undefined>;
+    get amount$(): import("applesauce-common/observable").ChainableObservable<number | undefined>;
+}

package/dist/casts/wallet-history.js

@@ -0,0 +1,40 @@
+import { EventCast } from "applesauce-common/casts";
+import { watchEventUpdates } from "applesauce-core/observable";
+import { of } from "rxjs";
+import { map } from "rxjs/operators";
+import { getHistoryContent, getHistoryRedeemed, isHistoryContentUnlocked, isValidWalletHistory, unlockHistoryContent, } from "../helpers/history.js";
+export class WalletHistory extends EventCast {
+    constructor(event, store) {
+        if (!isValidWalletHistory(event))
+            throw new Error("Invalid wallet history");
+        super(event, store);
+    }
+    /** The embedded history metadata */
+    get meta() {
+        return getHistoryContent(this.event);
+    }
+    // Direct getters (return undefined if locked)
+    get direction() {
+        return this.meta?.direction;
+    }
+    get amount() {
+        return this.meta?.amount;
+    }
+    get redeemed() {
+        return getHistoryRedeemed(this.event);
+    }
+    // Unlocking pattern
+    get unlocked() {
+        return isHistoryContentUnlocked(this.event);
+    }
+    async unlock(signer) {
+        return unlockHistoryContent(this.event, signer);
+    }
+    // Observable that emits when history is unlocked
+    get meta$() {
+        return this.$$ref("meta$", (store) => of(this.event).pipe(watchEventUpdates(store), map((event) => event && getHistoryContent(event))));
+    }
+    get amount$() {
+        return this.$$ref("amount$", () => this.meta$.pipe(map((meta) => meta?.amount)));
+    }
+}

package/dist/casts/wallet-token.d.ts

@@ -0,0 +1,29 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { WalletTokenEvent } from "../helpers/tokens.js";
+export declare class WalletToken extends EventCast<WalletTokenEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get meta(): import("../helpers/tokens.js").TokenContent | undefined;
+    get proofs(): {
+        amount: number;
+        secret: string;
+        C: string;
+        id: string;
+    }[] | undefined;
+    get mint(): string | undefined;
+    get amount(): number | undefined;
+    get deleted(): string[] | undefined;
+    get unlocked(): boolean;
+    unlock(signer: HiddenContentSigner): Promise<import("../helpers/tokens.js").TokenContent>;
+    get meta$(): import("applesauce-common/observable").ChainableObservable<import("../helpers/tokens.js").TokenContent>;
+    get mint$(): import("applesauce-common/observable").ChainableObservable<string>;
+    get proofs$(): import("applesauce-common/observable").ChainableObservable<{
+        amount: number;
+        secret: string;
+        C: string;
+        id: string;
+    }[]>;
+    get amount$(): import("applesauce-common/observable").ChainableObservable<number>;
+    get deleted$(): import("applesauce-common/observable").ChainableObservable<string[]>;
+}

package/dist/casts/wallet-token.js

@@ -0,0 +1,52 @@
+import { sumProofs } from "@cashu/cashu-ts";
+import { EventCast } from "applesauce-common/casts";
+import { defined, watchEventUpdates } from "applesauce-core/observable";
+import { of } from "rxjs";
+import { map } from "rxjs/operators";
+import { getTokenContent, isTokenContentUnlocked, isValidWalletToken, unlockTokenContent, } from "../helpers/tokens.js";
+export class WalletToken extends EventCast {
+    constructor(event, store) {
+        if (!isValidWalletToken(event))
+            throw new Error("Invalid wallet token");
+        super(event, store);
+    }
+    get meta() {
+        return getTokenContent(this.event);
+    }
+    // Direct getters (return undefined if locked)
+    get proofs() {
+        return this.meta?.proofs;
+    }
+    get mint() {
+        return this.meta?.mint;
+    }
+    get amount() {
+        return this.proofs && sumProofs(this.proofs);
+    }
+    get deleted() {
+        return this.meta?.del;
+    }
+    // Unlocking pattern
+    get unlocked() {
+        return isTokenContentUnlocked(this.event);
+    }
+    async unlock(signer) {
+        return unlockTokenContent(this.event, signer);
+    }
+    // Observable that emits when token is unlocked
+    get meta$() {
+        return this.$$ref("meta$", (store) => of(this.event).pipe(watchEventUpdates(store), map((event) => event && getTokenContent(event)), defined()));
+    }
+    get mint$() {
+        return this.$$ref("mint$", () => this.meta$.pipe(map((meta) => meta?.mint)));
+    }
+    get proofs$() {
+        return this.$$ref("proofs$", () => this.meta$.pipe(map((meta) => meta?.proofs)));
+    }
+    get amount$() {
+        return this.$$ref("amount$", () => this.proofs$.pipe(map(sumProofs)));
+    }
+    get deleted$() {
+        return this.$$ref("deleted$", () => this.meta$.pipe(map((meta) => meta?.del)));
+    }
+}

package/dist/casts/wallet.d.ts

@@ -0,0 +1,27 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { WalletEvent } from "../helpers/wallet.js";
+import { WalletHistory } from "./wallet-history.js";
+import { WalletToken } from "./wallet-token.js";
+export declare class Wallet extends EventCast<WalletEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    get mints(): string[];
+    get relays(): string[] | undefined;
+    get privateKey(): Uint8Array<ArrayBufferLike> | null | undefined;
+    get unlocked(): boolean;
+    unlock(signer: HiddenContentSigner): Promise<{
+        mints: string[];
+        privateKey: Uint8Array | null;
+        relays: string[];
+    }>;
+    get mints$(): import("applesauce-common/observable").ChainableObservable<string[] | undefined>;
+    get relays$(): import("applesauce-common/observable").ChainableObservable<string[] | undefined>;
+    get balance$(): import("applesauce-common/observable").ChainableObservable<Record<string, number>>;
+    /** The p2pk locking private key for this wallet */
+    get privateKey$(): import("applesauce-common/observable").ChainableObservable<Uint8Array<ArrayBufferLike> | null | undefined>;
+    get tokens$(): import("applesauce-common/observable").ChainableObservable<WalletToken[]>;
+    get history$(): import("applesauce-common/observable").ChainableObservable<WalletHistory[]>;
+    get backups$(): import("applesauce-common/observable").ChainableObservable<import("nostr-tools").Event[]>;
+    get received$(): import("applesauce-common/observable").ChainableObservable<string[]>;
+}

package/dist/casts/wallet.js

@@ -0,0 +1,62 @@
+import { EventCast } from "applesauce-common/casts";
+import { castTimelineStream } from "applesauce-common/observable";
+import { watchEventUpdates } from "applesauce-core/observable";
+import { of } from "rxjs";
+import { map } from "rxjs/operators";
+import { getWalletMints, getWalletPrivateKey, getWalletRelays, isValidWallet, isWalletUnlocked, unlockWallet, WALLET_BACKUP_KIND, } from "../helpers/wallet.js";
+import { WalletHistoryModel } from "../models/history.js";
+import { WalletBalanceModel, WalletTokensModel } from "../models/tokens.js";
+import { WalletHistory } from "./wallet-history.js";
+import { WalletToken } from "./wallet-token.js";
+import { ReceivedNutzapsModel } from "../models/nutzap.js";
+export class Wallet extends EventCast {
+    constructor(event, store) {
+        if (!isValidWallet(event))
+            throw new Error("Invalid wallet event");
+        super(event, store);
+    }
+    // Direct getters (return undefined if locked)
+    get mints() {
+        return getWalletMints(this.event);
+    }
+    get relays() {
+        return getWalletRelays(this.event);
+    }
+    get privateKey() {
+        return getWalletPrivateKey(this.event);
+    }
+    // Unlocking pattern
+    get unlocked() {
+        return isWalletUnlocked(this.event);
+    }
+    async unlock(signer) {
+        return unlockWallet(this.event, signer);
+    }
+    // Observable that emits when wallet is unlocked
+    get mints$() {
+        return this.$$ref("mints$", (store) => of(this.event).pipe(watchEventUpdates(store), map((event) => event && getWalletMints(event))));
+    }
+    get relays$() {
+        return this.$$ref("relays$", (store) => of(this.event).pipe(watchEventUpdates(store), map((event) => event && getWalletRelays(event))));
+    }
+    get balance$() {
+        return this.$$ref("balance$", (store) => store.model(WalletBalanceModel, this.event.pubkey));
+    }
+    /** The p2pk locking private key for this wallet */
+    get privateKey$() {
+        return this.$$ref("privateKey$", (store) => of(this.event).pipe(watchEventUpdates(store), map((event) => event && getWalletPrivateKey(event))));
+    }
+    // Observables for related events
+    get tokens$() {
+        return this.$$ref("tokens$", (store) => store.model(WalletTokensModel, this.event.pubkey).pipe(castTimelineStream(WalletToken, store)));
+    }
+    get history$() {
+        return this.$$ref("history$", (store) => store.model(WalletHistoryModel, this.event.pubkey).pipe(castTimelineStream(WalletHistory, store)));
+    }
+    get backups$() {
+        return this.$$ref("backups$", (store) => store.timeline({ kinds: [WALLET_BACKUP_KIND], authors: [this.event.pubkey] }));
+    }
+    get received$() {
+        return this.$$ref("received$", (store) => store.model(ReceivedNutzapsModel, this.event.pubkey));
+    }
+}

package/dist/helpers/cashu.d.ts

@@ -0,0 +1,21 @@
+import { Proof, Token } from "@cashu/cashu-ts";
+/** Internal method for creating a unique id for each proof */
+export declare function getProofUID(proof: Proof): string;
+/**
+ * Extracts the P2PK locking pubkey from a proof's secret
+ * @param proof the cashu proof to extract the pubkey from
+ * @returns the pubkey, or undefined if not P2PK locked
+ */
+export declare function getProofP2PKPubkey(proof: Proof): string | undefined;
+/** Internal method to filter out duplicate proofs */
+export declare function ignoreDuplicateProofs(seen?: Set<string>): (proof: Proof) => boolean;
+/**
+ * Returns a decoded cashu token inside an unicode emoji
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
+ */
+export declare function decodeTokenFromEmojiString(str: string): Token | undefined;
+/**
+ * Encodes a token into an emoji char
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
+ */
+export declare function encodeTokenToEmoji(token: Token | string, emoji?: string): string;

package/dist/helpers/cashu.js

@@ -0,0 +1,105 @@
+import { getDecodedToken, getEncodedToken } from "@cashu/cashu-ts";
+import { safeParse } from "applesauce-core/helpers";
+/** Internal method for creating a unique id for each proof */
+export function getProofUID(proof) {
+    return proof.id + proof.amount + proof.C + proof.secret;
+}
+/**
+ * Extracts the P2PK locking pubkey from a proof's secret
+ * @param proof the cashu proof to extract the pubkey from
+ * @returns the pubkey, or undefined if not P2PK locked
+ */
+export function getProofP2PKPubkey(proof) {
+    const secret = safeParse(proof.secret);
+    if (!secret)
+        return;
+    if (!Array.isArray(secret))
+        return;
+    if (secret[0] !== "P2PK")
+        return;
+    const proofPubkey = secret[1]?.data;
+    if (!proofPubkey || typeof proofPubkey !== "string")
+        return;
+    return proofPubkey;
+}
+/** Internal method to filter out duplicate proofs */
+export function ignoreDuplicateProofs(seen = new Set()) {
+    return (proof) => {
+        const id = getProofUID(proof);
+        if (seen.has(id))
+            return false;
+        else {
+            seen.add(id);
+            return true;
+        }
+    };
+}
+/**
+ * Returns a decoded cashu token inside an unicode emoji
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/ReceiveTokenDialog.vue#L387
+ */
+export function decodeTokenFromEmojiString(str) {
+    try {
+        let decoded = [];
+        const chars = Array.from(str);
+        if (!chars.length)
+            return undefined;
+        const fromVariationSelector = function (char) {
+            const codePoint = char.codePointAt(0);
+            if (codePoint === undefined)
+                return null;
+            // Handle Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (codePoint >= 0xfe00 && codePoint <= 0xfe0f) {
+                // Maps FE00->0, FE01->1, ..., FE0F->15
+                const byteValue = codePoint - 0xfe00;
+                return String.fromCharCode(byteValue);
+            }
+            // Handle Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (codePoint >= 0xe0100 && codePoint <= 0xe01ef) {
+                // Maps E0100->16, E0101->17, ..., E01EF->255
+                const byteValue = codePoint - 0xe0100 + 16;
+                return String.fromCharCode(byteValue);
+            }
+            // No Variation Selector
+            return null;
+        };
+        // Check all input chars for peanut data
+        for (const char of chars) {
+            let byte = fromVariationSelector(char);
+            if (byte === null && decoded.length > 0) {
+                break;
+            }
+            else if (byte === null) {
+                continue;
+            }
+            decoded.push(byte); // got some
+        }
+        // Switch out token if we found peanut data
+        let decodedString = decoded.join("");
+        return getDecodedToken(decodedString);
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+/**
+ * Encodes a token into an emoji char
+ * @see https://github.com/cashubtc/cashu.me/blob/1194a7b9ee2f43305e38304de7bef8839601ff4d/src/components/SendTokenDialog.vue#L710
+ */
+export function encodeTokenToEmoji(token, emoji = "🥜") {
+    return (emoji +
+        Array.from(typeof token === "string" ? token : getEncodedToken(token))
+            .map((char) => {
+            const byteValue = char.charCodeAt(0);
+            // For byte values 0-15, use Variation Selectors (VS1-VS16): U+FE00 to U+FE0F
+            if (byteValue >= 0 && byteValue <= 15) {
+                return String.fromCodePoint(0xfe00 + byteValue);
+            }
+            // For byte values 16-255, use Variation Selectors Supplement (VS17-VS256): U+E0100 to U+E01EF
+            if (byteValue >= 16 && byteValue <= 255) {
+                return String.fromCodePoint(0xe0100 + (byteValue - 16));
+            }
+            return "";
+        })
+            .join(""));
+}

package/dist/helpers/couch.d.ts

@@ -0,0 +1,11 @@
+import { Token } from "@cashu/cashu-ts";
+type ClearMethod = () => void | Promise<void>;
+export interface Couch {
+    /** Store a token in the couch */
+    store(token: Token): ClearMethod | Promise<ClearMethod>;
+    /** Clear all tokens from the couch */
+    clear(): void | Promise<void>;
+    /** Get all tokens currently stored in the couch */
+    getAll(): Token[] | Promise<Token[]>;
+}
+export {};

package/dist/helpers/couch.js

@@ -0,0 +1 @@
+export {};

package/dist/helpers/history.d.ts

@@ -1,6 +1,10 @@
 import { HiddenContentSigner, UnlockedHiddenTags } from "applesauce-core/helpers";
-import { NostrEvent } from "applesauce-core/helpers/event";
+import { KnownEvent, NostrEvent } from "applesauce-core/helpers/event";
 export declare const WALLET_HISTORY_KIND = 7376;
+/** Validated wallet history event */
+export type WalletHistoryEvent = KnownEvent<typeof WALLET_HISTORY_KIND>;
+/** Checks if an event is a valid wallet history event */
+export declare function isValidWalletHistory(event: NostrEvent): event is WalletHistoryEvent;
 export type HistoryDirection = "in" | "out";
 export type HistoryContent = {
     /** The direction of the transaction, in = received, out = sent */

package/dist/helpers/history.js

@@ -1,5 +1,9 @@
-import { getHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+import { getHiddenTags, hasHiddenTags, isETag, isHiddenTagsUnlocked, lockHiddenTags, notifyEventUpdate, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
 export const WALLET_HISTORY_KIND = 7376;
+/** Checks if an event is a valid wallet history event */
+export function isValidWalletHistory(event) {
+    return event.kind === WALLET_HISTORY_KIND && hasHiddenTags(event);
+}
 // Enable hidden content for wallet history kind
 setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
 export const HistoryContentSymbol = Symbol.for("history-content");
@@ -9,11 +13,16 @@ export function getHistoryRedeemed(history) {
 }
 /** Checks if the history contents are locked */
 export function isHistoryContentUnlocked(history) {
-    return isHiddenTagsUnlocked(history) && Reflect.has(history, HistoryContentSymbol) === true;
+    // Wrap in try catch to avoid throwing validation errors
+    try {
+        return (HistoryContentSymbol in history || (isHiddenTagsUnlocked(history) && getHistoryContent(history) !== undefined));
+    }
+    catch { }
+    return false;
 }
 export function getHistoryContent(history) {
     // Return cached value if it exists
-    if (isHistoryContentUnlocked(history))
+    if (HistoryContentSymbol in history)
         return history[HistoryContentSymbol];
     // Get hidden tags
     const tags = getHiddenTags(history);
@@ -41,7 +50,7 @@ export function getHistoryContent(history) {
 /** Decrypts a wallet history event */
 export async function unlockHistoryContent(history, signer) {
     // Return cached value if it exists
-    if (isHistoryContentUnlocked(history))
+    if (HistoryContentSymbol in history)
         return history[HistoryContentSymbol];
     // Unlock hidden tags if needed
     await unlockHiddenTags(history, signer);

package/dist/helpers/index.d.ts

@@ -2,5 +2,9 @@ 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-info.js";
 export * from "./nutzap.js";
+export * from "./cashu.js";
+export * from "./couch.js";
+export * from "./local-storage-couch.js";
+export * from "./indexed-db-couch.js";

package/dist/helpers/index.js

@@ -2,5 +2,9 @@ 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-info.js";
 export * from "./nutzap.js";
+export * from "./cashu.js";
+export * from "./couch.js";
+export * from "./local-storage-couch.js";
+export * from "./indexed-db-couch.js";