applesauce-wallet 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/dist/blueprints/mint-recommendation.d.ts

@@ -0,0 +1,16 @@
+import { EventBlueprint } from "applesauce-core/event-factory";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { AddressPointer } from "applesauce-core/helpers/pointers";
+/** Options for creating a mint recommendation */
+export type MintRecommendationOptions = {
+    /** The mint's pubkey (from the kind:38172 event's `d` tag) - required */
+    mintPubkey: string;
+    /** Optional URL to connect to the cashu mint */
+    url?: string;
+    /** Optional address pointer to the kind:38172 event */
+    addressPointer?: AddressPointer | NostrEvent | string;
+    /** Optional review/comment content */
+    comment?: string;
+};
+/** A blueprint to create a kind:38000 mint recommendation event */
+export declare function MintRecommendationBlueprint(options: MintRecommendationOptions): EventBlueprint;

package/dist/blueprints/mint-recommendation.js

@@ -0,0 +1,11 @@
+import { blueprint } from "applesauce-core/event-factory";
+import { skip } from "applesauce-core/helpers";
+import { MINT_RECOMMENDATION_KIND } from "../helpers/mint-recommendation.js";
+import { CASHU_MINT_INFO_KIND } from "../helpers/mint-info.js";
+import { setAddressPointer, setComment, setKind, setMintPubkey, setURL } from "../operations/mint-recommendation.js";
+/** A blueprint to create a kind:38000 mint recommendation event */
+export function MintRecommendationBlueprint(options) {
+    const { mintPubkey, url, addressPointer, comment } = options;
+    return blueprint(MINT_RECOMMENDATION_KIND, setKind(CASHU_MINT_INFO_KIND), // Always 38172 for cashu mints
+    setMintPubkey(mintPubkey), url ? setURL(url) : skip(), addressPointer ? setAddressPointer(addressPointer) : skip(), comment ? setComment(comment) : skip());
+}

package/dist/blueprints/wallet.d.ts

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

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,22 @@
+import { ChainableObservable } from "applesauce-common/observable";
+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" {
+    interface User {
+        readonly wallet$: ChainableObservable<Wallet | undefined>;
+        readonly nutzap$: ChainableObservable<NutzapInfo | undefined>;
+        readonly mintRecommendation$: ChainableObservable<MintRecommendation | 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,52 @@
+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";
+import { MintRecommendation } from "./mint-recommendation.js";
+import { MINT_RECOMMENDATION_KIND } from "../helpers/mint-recommendation.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,
+});
+Object.defineProperty(User.prototype, "mintRecommendation$", {
+    get: function () {
+        return this.$$ref("mintRecommendation$", (store) => store
+            .timeline({ kinds: [MINT_RECOMMENDATION_KIND], authors: [this.pubkey] })
+            .pipe(castTimelineStream(MintRecommendation, 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,8 @@
+export * from "./mint-info.js";
+export * from "./mint-recommendation.js";
+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,8 @@
+export * from "./mint-info.js";
+export * from "./mint-recommendation.js";
+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/mint-info.d.ts

@@ -0,0 +1,18 @@
+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";
+export declare class MintInfo extends EventCast<CashuMintInfoEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** The mint's pubkey (from the `d` tag) */
+    get mintPubkey(): string | undefined;
+    /** The URL to the cashu mint (from the `u` tag) */
+    get url(): string;
+    /** The supported nuts (comma-separated list of nut numbers) */
+    get nuts(): number[];
+    /** The network type (mainnet, testnet, signet, or regtest) */
+    get network(): import("../helpers/mint-info.js").NetworkType | undefined;
+    /** Optional metadata content (kind:0-style JSON object) */
+    get metadata(): Record<string, any> | undefined;
+    get recomendations$(): import("applesauce-common/observable").ChainableObservable<MintRecommendation[]>;
+}

package/dist/casts/mint-info.js

@@ -0,0 +1,42 @@
+import { EventCast } from "applesauce-common/casts";
+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";
+export class MintInfo extends EventCast {
+    constructor(event, store) {
+        if (!isValidCashuMintInfo(event))
+            throw new Error("Invalid cashu mint info event");
+        super(event, store);
+    }
+    /** The mint's pubkey (from the `d` tag) */
+    get mintPubkey() {
+        return getCashuMintPubkey(this.event);
+    }
+    /** The URL to the cashu mint (from the `u` tag) */
+    get url() {
+        return getCashuMintURL(this.event);
+    }
+    /** The supported nuts (comma-separated list of nut numbers) */
+    get nuts() {
+        return getCashuMintNuts(this.event);
+    }
+    /** The network type (mainnet, testnet, signet, or regtest) */
+    get network() {
+        return getCashuMintNetwork(this.event);
+    }
+    /** Optional metadata content (kind:0-style JSON object) */
+    get metadata() {
+        return getCashuMintMetadata(this.event);
+    }
+    get recomendations$() {
+        return this.$$ref("recomendations$", (store) => store
+            .timeline([
+            // Based on the mint URL
+            { kinds: [MINT_RECOMMENDATION_KIND], "#u": [this.url] },
+            // Based on the mint pubkey
+            this.mintPubkey ? { kinds: [MINT_RECOMMENDATION_KIND], "#d": [this.mintPubkey] } : undefined,
+        ].filter((f) => !!f))
+            .pipe(castTimelineStream(MintRecommendation, store)));
+    }
+}

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

@@ -0,0 +1,16 @@
+import { CastRefEventStore, EventCast } from "applesauce-common/casts";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { MintRecommendationEvent } from "../helpers/mint-recommendation.js";
+export declare class MintRecommendation extends EventCast<MintRecommendationEvent> {
+    constructor(event: NostrEvent, store: CastRefEventStore);
+    /** The recommended event kind (should be 38172 for cashu mints) */
+    get kind(): number;
+    /** The mint's pubkey (from the `d` tag) */
+    get mintPubkey(): string | undefined;
+    /** Optional URL to connect to the cashu mint (from the `u` tag) */
+    get url(): string | undefined;
+    /** Optional address pointer to the kind:38172 event (from the `a` tag) */
+    get addressPointer(): import("nostr-tools/nip19").AddressPointer | undefined;
+    /** Optional review content */
+    get comment(): string;
+}

package/dist/casts/mint-recommendation.js

@@ -0,0 +1,29 @@
+import { EventCast } from "applesauce-common/casts";
+import { getRecommendationAddressPointer, getRecommendationMintPubkey, getRecommendationKind, getRecommendationURL, isValidMintRecommendation, } from "../helpers/mint-recommendation.js";
+export class MintRecommendation extends EventCast {
+    constructor(event, store) {
+        if (!isValidMintRecommendation(event))
+            throw new Error("Invalid mint recommendation event");
+        super(event, store);
+    }
+    /** The recommended event kind (should be 38172 for cashu mints) */
+    get kind() {
+        return getRecommendationKind(this.event);
+    }
+    /** The mint's pubkey (from the `d` tag) */
+    get mintPubkey() {
+        return getRecommendationMintPubkey(this.event);
+    }
+    /** Optional URL to connect to the cashu mint (from the `u` tag) */
+    get url() {
+        return getRecommendationURL(this.event);
+    }
+    /** Optional address pointer to the kind:38172 event (from the `a` tag) */
+    get addressPointer() {
+        return getRecommendationAddressPointer(this.event);
+    }
+    /** Optional review content */
+    get comment() {
+        return this.event.content;
+    }
+}

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;