applesauce-wallet-connect 0.0.0-next-20250808173123

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# applesauce-wallet-connect
+
+NIP-47 Nostr Wallet Connect implementation for both clients and services.
+
+## Features
+
+- **WalletConnect**: Client-side implementation for connecting to NIP-47 wallet services
+- **WalletService**: Service-side implementation for creating NIP-47 wallet services
+- Full support for all NIP-47 methods
+- TypeScript support with full type safety
+- RxJS-based reactive architecture
+- Support for both NIP-04 and NIP-44 encryption
+
+## Installation
+
+```bash
+npm install applesauce-wallet-connect
+```
+
+## WalletConnect (Client)
+
+Connect to a wallet service using a connection string:
+
+```typescript
+import { WalletConnect } from "applesauce-wallet-connect";
+
+const wallet = WalletConnect.fromConnectionString("nostr+walletconnect://relay.example.com?secret=...&pubkey=...");
+
+// Pay an invoice
+const result = await wallet.payInvoice("lnbc1...");
+console.log("Payment preimage:", result.preimage);
+
+// Get wallet balance
+const balance = await wallet.getBalance();
+console.log("Balance:", balance.balance, "msats");
+```
+
+## WalletService (Service)
+
+Create a wallet service that handles NIP-47 requests:
+
+```typescript
+import { WalletService } from "applesauce-wallet-connect";
+import { SimpleSigner } from "applesauce-signers";
+
+// Create a signer for the service
+const signer = new SimpleSigner();
+
+// Define method handlers
+const handlers = {
+  get_info: async () => ({
+    alias: "My Wallet",
+    color: "#ff0000",
+    pubkey: await signer.getPublicKey(),
+    network: "mainnet" as const,
+    block_height: 800000,
+    block_hash: "0000...0000",
+    methods: ["get_info", "get_balance", "pay_invoice"],
+  }),
+
+  get_balance: async () => ({
+    balance: 100000, // 100 sats in msats
+  }),
+
+  pay_invoice: async (params) => {
+    // Implement your payment logic here
+    console.log("Paying invoice:", params.invoice);
+    return {
+      preimage: "payment_preimage_here",
+      fees_paid: 1000,
+    };
+  },
+};
+
+// Create the service
+const service = new WalletService({
+  subscriptionMethod: mySubscriptionMethod,
+  publishMethod: myPublishMethod,
+  relays: ["wss://relay.example.com"],
+  signer,
+  handlers,
+  // Supported encryption methods will be set based on the signer
+});
+
+// Start the service
+await service.start();
+console.log("Wallet service started");
+
+// Get the connection string for the wallet service
+console.log(service.getConnectionString());
+
+// Stop the service when done
+// service.stop();
+```
+
+## Supported Methods
+
+Both WalletConnect and WalletService support all NIP-47 methods:
+
+- `get_info` - Get wallet information
+- `get_balance` - Get wallet balance
+- `pay_invoice` - Pay a Lightning invoice
+- `multi_pay_invoice` - Pay multiple invoices
+- `pay_keysend` - Send a keysend payment
+- `multi_pay_keysend` - Send multiple keysend payments
+- `make_invoice` - Create a new invoice
+- `lookup_invoice` - Look up an invoice
+- `list_transactions` - List transactions
+
+## Documentation
+
+For more detailed documentation, visit [the docs](https://hzrd149.github.io/applesauce/).

package/dist/actions/index.d.ts

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

package/dist/actions/index.js

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

package/dist/actions/tokens.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "@cashu/cashu-ts";
+import { Action } from "applesauce-actions";
+import { NostrEvent } from "nostr-tools";
+/**
+ * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * @param token the cashu token to add
+ * @param redeemed an array of nutzap event ids to mark as redeemed
+ */
+export declare function ReceiveToken(token: Token, redeemed?: string[], fee?: number): Action;
+/** An action that deletes old tokens and creates a new one but does not add a history event */
+export declare function RolloverTokens(tokens: NostrEvent[], token: Token): Action;
+/** An action that deletes old token events and adds a spend history item */
+export declare function CompleteSpend(spent: NostrEvent[], change: Token): Action;
+/** Combines all unlocked token events into a single event per mint */
+export declare function ConsolidateTokens(opts?: {
+    ignoreLocked?: boolean;
+}): Action;

package/dist/actions/tokens.js

@@ -0,0 +1,110 @@
+import { CashuMint, CashuWallet, CheckStateEnum } from "@cashu/cashu-ts";
+import { DeleteBlueprint } from "applesauce-factory/blueprints";
+import { getTokenContent, ignoreDuplicateProofs, isTokenContentLocked, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { WalletTokenBlueprint } from "../blueprints/tokens.js";
+import { WalletHistoryBlueprint } from "../blueprints/history.js";
+/**
+ * Adds a cashu token to the wallet and marks a list of nutzaps as redeemed
+ * @param token the cashu token to add
+ * @param redeemed an array of nutzap event ids to mark as redeemed
+ */
+export function ReceiveToken(token, redeemed, fee) {
+    return async function* ({ factory }) {
+        const amount = token.proofs.reduce((t, p) => t + p.amount, 0);
+        const tokenEvent = await factory.sign(await factory.create(WalletTokenBlueprint, token, []));
+        const history = await factory.sign(await factory.create(WalletHistoryBlueprint, { direction: "in", amount, mint: token.mint, created: [tokenEvent.id], fee }, redeemed ?? []));
+        yield tokenEvent;
+        yield history;
+    };
+}
+/** An action that deletes old tokens and creates a new one but does not add a history event */
+export function RolloverTokens(tokens, token) {
+    return async function* ({ factory }) {
+        // create a delete event for old tokens
+        const deleteDraft = await factory.create(DeleteBlueprint, tokens);
+        // create a new token event
+        const tokenDraft = await factory.create(WalletTokenBlueprint, token, tokens.map((e) => e.id));
+        // sign events
+        const signedDelete = await factory.sign(deleteDraft);
+        const signedToken = await factory.sign(tokenDraft);
+        // publish events
+        yield signedDelete;
+        yield signedToken;
+    };
+}
+/** An action that deletes old token events and adds a spend history item */
+export function CompleteSpend(spent, change) {
+    return async function* ({ factory }) {
+        if (spent.length === 0)
+            throw new Error("Cant complete spent with no token events");
+        if (spent.some((s) => isTokenContentLocked(s)))
+            throw new Error("Cant complete spend with locked tokens");
+        // create the nip-09 delete event for previous events
+        const deleteDraft = await factory.create(DeleteBlueprint, spent);
+        const changeAmount = change.proofs.reduce((t, p) => t + p.amount, 0);
+        // create a new token event if needed
+        const changeDraft = changeAmount > 0
+            ? await factory.create(WalletTokenBlueprint, change, spent.map((e) => e.id))
+            : undefined;
+        const total = spent.reduce((total, token) => total + getTokenContent(token).proofs.reduce((t, p) => t + p.amount, 0), 0);
+        // calculate the amount that was spent
+        const diff = total - changeAmount;
+        // sign delete and token
+        const signedDelete = await factory.sign(deleteDraft);
+        const signedToken = changeDraft && (await factory.sign(changeDraft));
+        // create a history entry
+        const history = await factory.create(WalletHistoryBlueprint, { direction: "out", mint: change.mint, amount: diff, created: signedToken ? [signedToken.id] : [] }, []);
+        // sign history
+        const signedHistory = await factory.sign(history);
+        // publish events
+        yield signedDelete;
+        if (signedToken)
+            yield signedToken;
+        yield signedHistory;
+    };
+}
+/** Combines all unlocked token events into a single event per mint */
+export function ConsolidateTokens(opts) {
+    return async function* ({ events, factory, self }) {
+        const tokens = Array.from(events.getByFilters({ kinds: [WALLET_TOKEN_KIND], authors: [self] })).filter((token) => {
+            if (isTokenContentLocked(token)) {
+                if (opts?.ignoreLocked)
+                    return false;
+                else
+                    throw new Error("Token is locked");
+            }
+            else
+                return true;
+        });
+        const byMint = tokens.reduce((map, token) => {
+            const mint = getTokenContent(token).mint;
+            if (!map.has(mint))
+                map.set(mint, []);
+            map.get(mint).push(token);
+            return map;
+        }, new Map());
+        // loop over each mint and consolidate proofs
+        for (const [mint, tokens] of byMint) {
+            const cashuMint = new CashuMint(mint);
+            const cashuWallet = new CashuWallet(cashuMint);
+            // get all tokens proofs
+            const proofs = tokens
+                .map((t) => getTokenContent(t).proofs)
+                .flat()
+                // filter out duplicate proofs
+                .filter(ignoreDuplicateProofs());
+            // NOTE: this assumes that the states array is the same length and order as the proofs array
+            const states = await cashuWallet.checkProofsStates(proofs);
+            const notSpent = proofs.filter((_, i) => states[i].state !== CheckStateEnum.SPENT);
+            // create delete and token event
+            const deleteDraft = await factory.create(DeleteBlueprint, tokens);
+            const tokenDraft = await factory.create(WalletTokenBlueprint, { mint, proofs: notSpent }, tokens.map((t) => t.id));
+            // sign events
+            const signedToken = await factory.sign(tokenDraft);
+            const signedDelete = await factory.sign(deleteDraft);
+            // publish events for mint
+            yield signedToken;
+            yield signedDelete;
+        }
+    };
+}

package/dist/actions/wallet.d.ts

@@ -0,0 +1,13 @@
+import { Action } from "applesauce-actions";
+/** An action that creates a new 17375 wallet event and 375 wallet backup */
+export declare function CreateWallet(mints: string[], privateKey?: Uint8Array): Action;
+/**
+ * Adds a private key to a wallet event
+ * @throws if the wallet does not exist or is locked
+ */
+export declare function WalletAddPrivateKey(privateKey: Uint8Array): Action;
+/** Unlocks the wallet event and optionally the tokens and history events */
+export declare function UnlockWallet(unlock?: {
+    history?: boolean;
+    tokens?: boolean;
+}): Action;

package/dist/actions/wallet.js

@@ -0,0 +1,64 @@
+import { getWalletMints, getWalletPrivateKey, isWalletLocked, unlockWallet, WALLET_KIND } from "../helpers/wallet.js";
+import { WalletBackupBlueprint, WalletBlueprint } from "../blueprints/wallet.js";
+import { isTokenContentLocked, unlockTokenContent, WALLET_TOKEN_KIND } from "../helpers/tokens.js";
+import { isHistoryContentLocked, unlockHistoryContent, WALLET_HISTORY_KIND } from "../helpers/history.js";
+/** An action that creates a new 17375 wallet event and 375 wallet backup */
+export function CreateWallet(mints, privateKey) {
+    return async function* ({ events, factory, self }) {
+        const existing = events.getReplaceable(WALLET_KIND, self);
+        if (existing)
+            throw new Error("Wallet already exists");
+        const wallet = await factory.sign(await factory.create(WalletBlueprint, mints, privateKey));
+        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, wallet));
+        // publish the backup first
+        yield backup;
+        yield wallet;
+    };
+}
+/**
+ * Adds a private key to a wallet event
+ * @throws if the wallet does not exist or is locked
+ */
+export function WalletAddPrivateKey(privateKey) {
+    return async function* ({ events, self, factory }) {
+        const wallet = events.getReplaceable(WALLET_KIND, self);
+        if (!wallet)
+            throw new Error("Wallet does not exist");
+        if (isWalletLocked(wallet))
+            throw new Error("Wallet is locked");
+        if (getWalletPrivateKey(wallet))
+            throw new Error("Wallet already has a private key");
+        const draft = await factory.create(WalletBlueprint, getWalletMints(wallet), privateKey);
+        const signed = await factory.sign(draft);
+        // create backup event for wallet
+        const backup = await factory.sign(await factory.create(WalletBackupBlueprint, signed));
+        // publish events
+        yield backup;
+        yield signed;
+    };
+}
+/** Unlocks the wallet event and optionally the tokens and history events */
+export function UnlockWallet(unlock) {
+    return async function* ({ events, self, factory }) {
+        const signer = factory.context.signer;
+        if (!signer)
+            throw new Error("Missing signer");
+        const wallet = events.getReplaceable(WALLET_KIND, self);
+        if (!wallet)
+            throw new Error("Wallet does not exist");
+        if (isWalletLocked(wallet))
+            await unlockWallet(wallet, signer);
+        if (unlock?.tokens) {
+            const tokens = events.getTimeline({ kinds: [WALLET_TOKEN_KIND], authors: [self] });
+            for (const token of tokens)
+                if (isTokenContentLocked(token))
+                    await unlockTokenContent(token, signer);
+        }
+        if (unlock?.history) {
+            const history = events.getTimeline({ kinds: [WALLET_HISTORY_KIND], authors: [self] });
+            for (const entry of history)
+                if (isHistoryContentLocked(entry))
+                    await unlockHistoryContent(entry, signer);
+        }
+    };
+}

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

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

package/dist/blueprints/history.js

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

package/dist/blueprints/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./support.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./notification.js";

package/dist/blueprints/index.js

@@ -0,0 +1,4 @@
+export * from "./support.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./notification.js";

package/dist/blueprints/info.d.ts

@@ -0,0 +1,4 @@
+import { EventBlueprint } from "applesauce-factory";
+import { WalletSupport } from "../helpers/support.js";
+/** Creates a wallet info event */
+export declare function WalletInfoBlueprint(info: WalletSupport): EventBlueprint;

package/dist/blueprints/info.js

@@ -0,0 +1,8 @@
+import { blueprint } from "applesauce-factory";
+import { setContent } from "applesauce-factory/operations/content";
+import { includeSingletonTag } from "applesauce-factory/operations";
+import { WALLET_INFO_KIND } from "../helpers/support.js";
+/** Creates a wallet info event */
+export function WalletInfoBlueprint(info) {
+    return blueprint(WALLET_INFO_KIND, setContent(info.methods.join(" ")), info.encryption ? includeSingletonTag(["encryption", info.encryption.join(" ")]) : undefined, info.notifications ? includeSingletonTag(["notifications", info.notifications.join(" ")]) : undefined);
+}

package/dist/blueprints/notification.d.ts

@@ -0,0 +1,15 @@
+import { EventBlueprint } from "applesauce-factory";
+import { WalletNotification } from "../helpers/notification.js";
+/**
+ * Creates a wallet notification event (kind 23197)
+ * @param client - The service pubkey
+ * @param notification - The notification to create an event for
+ * @param encryption - The encryption method to use (defaults to nip44_v2)
+ */
+export declare function WalletNotificationBlueprint(client: string, notification: WalletNotification): EventBlueprint;
+/**
+ * Creates a legacy wallet notification event (kind 23196)
+ * @param client - The service pubkey
+ * @param notification - The notification to create an event for
+ */
+export declare function WalletLegacyNotificationBlueprint(client: string, notification: WalletNotification): EventBlueprint;

package/dist/blueprints/notification.js

@@ -0,0 +1,21 @@
+import { blueprint } from "applesauce-factory";
+import { includeSingletonTag } from "applesauce-factory/operations";
+import { setEncryptedContent } from "applesauce-factory/operations/content";
+import { WALLET_NOTIFICATION_KIND, WALLET_LEGACY_NOTIFICATION_KIND, } from "../helpers/notification.js";
+/**
+ * Creates a wallet notification event (kind 23197)
+ * @param client - The service pubkey
+ * @param notification - The notification to create an event for
+ * @param encryption - The encryption method to use (defaults to nip44_v2)
+ */
+export function WalletNotificationBlueprint(client, notification) {
+    return blueprint(WALLET_NOTIFICATION_KIND, setEncryptedContent(client, JSON.stringify(notification)), includeSingletonTag(["p", client]));
+}
+/**
+ * Creates a legacy wallet notification event (kind 23196)
+ * @param client - The service pubkey
+ * @param notification - The notification to create an event for
+ */
+export function WalletLegacyNotificationBlueprint(client, notification) {
+    return blueprint(WALLET_LEGACY_NOTIFICATION_KIND, setEncryptedContent(client, JSON.stringify(notification)), includeSingletonTag(["p", client]));
+}

package/dist/blueprints/request.d.ts

@@ -0,0 +1,9 @@
+import { EventBlueprint } from "applesauce-factory";
+import { WalletRequest } from "../helpers/request.js";
+import { WalletConnectEncryptionMethod } from "../helpers/encryption.js";
+/**
+ * Creates a walelt request event
+ * @param service - The service pubkey
+ * @param request - The request to create an event for
+ */
+export declare function WalletRequestBlueprint<TRequest extends WalletRequest>(service: string, request: TRequest, encryption?: WalletConnectEncryptionMethod): EventBlueprint;

package/dist/blueprints/request.js

@@ -0,0 +1,12 @@
+import { blueprint } from "applesauce-factory";
+import { includeSingletonTag } from "applesauce-factory/operations";
+import { setEncryptedContent } from "applesauce-factory/operations/content";
+import { WALLET_REQUEST_KIND } from "../helpers/request.js";
+/**
+ * Creates a walelt request event
+ * @param service - The service pubkey
+ * @param request - The request to create an event for
+ */
+export function WalletRequestBlueprint(service, request, encryption = "nip44_v2") {
+    return blueprint(WALLET_REQUEST_KIND, setEncryptedContent(service, JSON.stringify(request), encryption === "nip44_v2" ? "nip44" : "nip04"), includeSingletonTag(["p", service]), includeSingletonTag(["encryption", encryption]));
+}

package/dist/blueprints/response.d.ts

@@ -0,0 +1,5 @@
+import { EventBlueprint } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+import { WalletResponse } from "../helpers/response.js";
+/** Creates a wallet response event */
+export declare function WalletResponseBlueprint(request: NostrEvent, response: WalletResponse): EventBlueprint;

package/dist/blueprints/response.js

@@ -0,0 +1,10 @@
+import { blueprint } from "applesauce-factory";
+import { includeSingletonTag } from "applesauce-factory/operations";
+import { setEncryptedContent } from "applesauce-factory/operations/content";
+import { getWalletRequestEncryption } from "../helpers/request.js";
+import { WALLET_RESPONSE_KIND } from "../helpers/response.js";
+/** Creates a wallet response event */
+export function WalletResponseBlueprint(request, response) {
+    const encryption = getWalletRequestEncryption(request);
+    return blueprint(WALLET_RESPONSE_KIND, setEncryptedContent(request.pubkey, JSON.stringify(response), encryption === "nip44_v2" ? "nip44" : "nip04"), includeSingletonTag(["e", request.id]), includeSingletonTag(["p", request.pubkey]));
+}

package/dist/blueprints/support.d.ts

@@ -0,0 +1,4 @@
+import { EventBlueprint } from "applesauce-factory";
+import { WalletSupport } from "../helpers/support.js";
+/** Creates a wallet info event */
+export declare function WalletSupportBlueprint(info: WalletSupport): EventBlueprint;

package/dist/blueprints/support.js

@@ -0,0 +1,8 @@
+import { blueprint } from "applesauce-factory";
+import { setContent } from "applesauce-factory/operations/content";
+import { includeSingletonTag } from "applesauce-factory/operations";
+import { WALLET_INFO_KIND } from "../helpers/support.js";
+/** Creates a wallet info event */
+export function WalletSupportBlueprint(info) {
+    return blueprint(WALLET_INFO_KIND, setContent(info.methods.join(" ")), info.encryption ? includeSingletonTag(["encryption", info.encryption.join(" ")]) : undefined, info.notifications ? includeSingletonTag(["notifications", info.notifications.join(" ")]) : undefined);
+}

package/dist/blueprints/tokens.d.ts

@@ -0,0 +1,7 @@
+import { Token } from "@cashu/cashu-ts";
+/**
+ * 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[]): import("applesauce-factory").EventBlueprint;