applesauce-wallet-connect 0.0.0-next-20250808173123

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/request.d.ts

@@ -0,0 +1,131 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+import { WalletConnectEncryptionMethod } from "./encryption.js";
+import { WalletMethod } from "./support.js";
+export declare const WALLET_REQUEST_KIND = 23194;
+/** A symbol used to cache the wallet request on the event */
+export declare const WalletRequestSymbol: unique symbol;
+/** TLV record for keysend payments */
+export interface TLVRecord {
+    /** TLV type */
+    type: number;
+    /** Hex encoded TLV value */
+    value: string;
+}
+/** Base request structure for all NIP-47 requests */
+export interface BaseWalletRequest<TMethod extends WalletMethod, TParams> {
+    /** The method to call */
+    method: TMethod;
+    /** Parameters for the method */
+    params: TParams;
+}
+/** Parameters for pay_invoice method */
+export interface PayInvoiceParams {
+    /** BOLT11 invoice */
+    invoice: string;
+    /** Invoice amount in msats, optional */
+    amount?: number;
+}
+export type PayInvoiceRequest = BaseWalletRequest<"pay_invoice", PayInvoiceParams>;
+/** Parameters for multi_pay_invoice method */
+export interface MultiPayInvoiceParams {
+    /** Array of invoices to pay */
+    invoices: Array<{
+        /** ID to identify this invoice in the response */
+        id?: string;
+        /** BOLT11 invoice */
+        invoice: string;
+        /** Invoice amount in msats, optional */
+        amount?: number;
+    }>;
+}
+export type MultiPayInvoiceRequest = BaseWalletRequest<"multi_pay_invoice", MultiPayInvoiceParams>;
+/** Parameters for pay_keysend method */
+export interface PayKeysendParams {
+    /** Amount in msats, required */
+    amount: number;
+    /** Payee pubkey, required */
+    pubkey: string;
+    /** Preimage of the payment, optional */
+    preimage?: string;
+    /** TLV records, optional */
+    tlv_records?: TLVRecord[];
+}
+export type PayKeysendRequest = BaseWalletRequest<"pay_keysend", PayKeysendParams>;
+/** Parameters for multi_pay_keysend method */
+export interface MultiPayKeysendParams {
+    /** Array of keysend payments */
+    keysends: Array<{
+        /** ID to identify this keysend in the response */
+        id?: string;
+        /** Payee pubkey, required */
+        pubkey: string;
+        /** Amount in msats, required */
+        amount: number;
+        /** Preimage of the payment, optional */
+        preimage?: string;
+        /** TLV records, optional */
+        tlv_records?: TLVRecord[];
+    }>;
+}
+export type MultiPayKeysendRequest = BaseWalletRequest<"multi_pay_keysend", MultiPayKeysendParams>;
+/** Parameters for make_invoice method */
+export interface MakeInvoiceParams {
+    /** Value in msats */
+    amount: number;
+    /** Invoice's description, optional */
+    description?: string;
+    /** Invoice's description hash, optional */
+    description_hash?: string;
+    /** Expiry in seconds from time invoice is created, optional */
+    expiry?: number;
+}
+export type MakeInvoiceRequest = BaseWalletRequest<"make_invoice", MakeInvoiceParams>;
+/** Parameters for lookup_invoice method */
+export interface LookupInvoiceParams {
+    /** Payment hash of the invoice, one of payment_hash or invoice is required */
+    payment_hash?: string;
+    /** Invoice to lookup */
+    invoice?: string;
+}
+export type LookupInvoiceRequest = BaseWalletRequest<"lookup_invoice", LookupInvoiceParams>;
+/** Parameters for list_transactions method */
+export interface ListTransactionsParams {
+    /** Starting timestamp in seconds since epoch (inclusive), optional */
+    from?: number;
+    /** Ending timestamp in seconds since epoch (inclusive), optional */
+    until?: number;
+    /** Maximum number of invoices to return, optional */
+    limit?: number;
+    /** Offset of the first invoice to return, optional */
+    offset?: number;
+    /** Include unpaid invoices, optional, default false */
+    unpaid?: boolean;
+    /** "incoming" for invoices, "outgoing" for payments, undefined for both */
+    type?: "incoming" | "outgoing";
+}
+export type ListTransactionsRequest = BaseWalletRequest<"list_transactions", ListTransactionsParams>;
+/** Parameters for get_balance method */
+export interface GetBalanceParams {
+}
+export type GetBalanceRequest = BaseWalletRequest<"get_balance", GetBalanceParams>;
+/** Parameters for get_info method */
+export interface GetInfoParams {
+}
+export type GetInfoRequest = BaseWalletRequest<"get_info", GetInfoParams>;
+/** Union type for all NIP-47 request types */
+export type WalletRequest = PayInvoiceRequest | MultiPayInvoiceRequest | PayKeysendRequest | MultiPayKeysendRequest | MakeInvoiceRequest | LookupInvoiceRequest | ListTransactionsRequest | GetBalanceRequest | GetInfoRequest;
+/** Checks if a kind 23194 event is locked */
+export declare function isWalletRequestLocked(request: NostrEvent): boolean;
+/** Unlocks a kind 23194 event */
+export declare function unlockWalletRequest(request: NostrEvent, signer: HiddenContentSigner): Promise<WalletRequest | undefined | null>;
+/** Gets the wallet request from a kind 23194 event */
+export declare function getWalletRequest(request: NostrEvent): WalletRequest | undefined | null;
+/** Returns the wallet service pubkey from a request */
+export declare function getWalletRequestServicePubkey(request: NostrEvent): string | undefined;
+/** Returns the expiration timestamp from a request */
+export declare function getWalletRequestExpiration(request: NostrEvent): number | undefined;
+/** Checks if a request has expired */
+export declare function isWalletRequestExpired(request: NostrEvent): boolean;
+/** Gets the encryption method used for a request */
+export declare function getWalletRequestEncryption(request: NostrEvent): WalletConnectEncryptionMethod;

package/dist/helpers/request.js

@@ -0,0 +1,51 @@
+import { getHiddenContent, getOrComputeCachedValue, getTagValue, isHiddenContentLocked, isNIP04Encrypted, setHiddenContentEncryptionMethod, unixNow, unlockHiddenContent, } from "applesauce-core/helpers";
+export const WALLET_REQUEST_KIND = 23194;
+// Set the encryption method to use for request kind
+setHiddenContentEncryptionMethod(WALLET_REQUEST_KIND, "nip44");
+/** A symbol used to cache the wallet request on the event */
+export const WalletRequestSymbol = Symbol("wallet-request");
+/** Checks if a kind 23194 event is locked */
+export function isWalletRequestLocked(request) {
+    return isHiddenContentLocked(request);
+}
+/** Unlocks a kind 23194 event */
+export async function unlockWalletRequest(request, signer) {
+    await unlockHiddenContent(request, signer);
+    return getWalletRequest(request);
+}
+/** Gets the wallet request from a kind 23194 event */
+export function getWalletRequest(request) {
+    if (isWalletRequestLocked(request))
+        return undefined;
+    return getOrComputeCachedValue(request, WalletRequestSymbol, () => {
+        const content = getHiddenContent(request);
+        if (!content)
+            return null;
+        return JSON.parse(content);
+    });
+}
+/** Returns the wallet service pubkey from a request */
+export function getWalletRequestServicePubkey(request) {
+    return getTagValue(request, "p");
+}
+/** Returns the expiration timestamp from a request */
+export function getWalletRequestExpiration(request) {
+    const expiration = getTagValue(request, "expiration");
+    return expiration ? parseInt(expiration, 10) : undefined;
+}
+/** Checks if a request has expired */
+export function isWalletRequestExpired(request) {
+    const expiration = getWalletRequestExpiration(request);
+    if (!expiration)
+        return false;
+    return unixNow() > expiration;
+}
+/** Gets the encryption method used for a request */
+export function getWalletRequestEncryption(request) {
+    const encryption = getTagValue(request, "encryption");
+    return encryption
+        ? encryption
+        : isNIP04Encrypted(request.content)
+            ? "nip04"
+            : "nip44_v2";
+}

package/dist/helpers/response.d.ts

@@ -0,0 +1,138 @@
+import { EncryptionMethod, HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+import { WalletErrorCode } from "./error.js";
+import { WalletMethod } from "./support.js";
+import { NotificationType } from "./notification.js";
+export declare const WALLET_RESPONSE_KIND = 23195;
+/** A symbol used to cache the wallet response on the event */
+export declare const WalletResponseSymbol: unique symbol;
+/** Error object for wallet responses */
+export interface WalletResponseError {
+    type: WalletErrorCode;
+    message: string;
+}
+/** Base response structure for all NIP-47 responses */
+export type BaseWalletResponse<TResultType extends WalletMethod, TResult> = {
+    /** Indicates the structure of the result field */
+    result_type: TResultType;
+    /** Error object, non-null in case of error */
+    error: WalletResponseError;
+    result: null;
+} | {
+    /** Indicates the structure of the result field */
+    result_type: TResultType;
+    error: null;
+    /** Result object, null in case of error */
+    result: TResult;
+};
+/** Transaction object used in multiple response types */
+export interface Transaction {
+    /** Type of transaction */
+    type: "incoming" | "outgoing";
+    /** State of the transaction */
+    state: "pending" | "settled" | "expired" | "failed";
+    /** Value in msats */
+    amount: number;
+    /** Value in msats */
+    fees_paid: number;
+    /** Invoice/payment creation unix timestamp */
+    created_at: number;
+    /** Encoded invoice, optional */
+    invoice?: string;
+    /** Invoice's description, optional */
+    description?: string;
+    /** Invoice's description hash, optional */
+    description_hash?: string;
+    /** Payment's preimage, optional if unpaid */
+    preimage?: string;
+    /** Payment hash for the payment, optional */
+    payment_hash?: string;
+    /** Invoice expiration unix timestamp, optional if not applicable */
+    expires_at?: number;
+    /** Invoice/payment settlement unix timestamp, optional if unpaid */
+    settled_at?: number;
+    /** Generic metadata that can be used to add things like zap/boostagram details */
+    metadata?: Record<string, any>;
+}
+/** Response for pay_invoice method */
+export interface PayInvoiceResult {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}
+export type PayInvoiceResponse = BaseWalletResponse<"pay_invoice", PayInvoiceResult>;
+/** Response for multi_pay_invoice method */
+export interface MultiPayInvoiceResult {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}
+export type MultiPayInvoiceResponse = BaseWalletResponse<"multi_pay_invoice", MultiPayInvoiceResult>;
+/** Response for pay_keysend method */
+export interface PayKeysendResult {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}
+export type PayKeysendResponse = BaseWalletResponse<"pay_keysend", PayKeysendResult>;
+/** Response for multi_pay_keysend method */
+export interface MultiPayKeysendResult {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}
+export type MultiPayKeysendResponse = BaseWalletResponse<"multi_pay_keysend", MultiPayKeysendResult>;
+/** Response for make_invoice method */
+export type MakeInvoiceResult = Transaction;
+export type MakeInvoiceResponse = BaseWalletResponse<"make_invoice", MakeInvoiceResult>;
+/** Response for lookup_invoice method */
+export type LookupInvoiceResult = Transaction;
+export type LookupInvoiceResponse = BaseWalletResponse<"lookup_invoice", LookupInvoiceResult>;
+/** Response for list_transactions method */
+export interface ListTransactionsResult {
+    /** Array of transactions */
+    transactions: Transaction[];
+}
+export type ListTransactionsResponse = BaseWalletResponse<"list_transactions", ListTransactionsResult>;
+/** Response for get_balance method */
+export interface GetBalanceResult {
+    /** User's balance in msats */
+    balance: number;
+}
+export type GetBalanceResponse = BaseWalletResponse<"get_balance", GetBalanceResult>;
+/** Response for get_info method */
+export interface GetInfoResult {
+    /** Node alias */
+    alias: string;
+    /** Node color as hex string */
+    color: string;
+    /** Node public key as hex string */
+    pubkey: string;
+    /** Network type */
+    network: "mainnet" | "testnet" | "signet" | "regtest";
+    /** Current block height */
+    block_height: number;
+    /** Current block hash as hex string */
+    block_hash: string;
+    /** List of supported methods for this connection */
+    methods: WalletMethod[];
+    /** List of supported notifications for this connection, optional */
+    notifications?: NotificationType[];
+}
+export type GetInfoResponse = BaseWalletResponse<"get_info", GetInfoResult>;
+/** Union type for all NIP-47 response types */
+export type WalletResponse = PayInvoiceResponse | MultiPayInvoiceResponse | PayKeysendResponse | MultiPayKeysendResponse | MakeInvoiceResponse | LookupInvoiceResponse | ListTransactionsResponse | GetBalanceResponse | GetInfoResponse;
+/** Checks if a kind 23195 event is locked */
+export declare function isWalletResponseLocked(response: NostrEvent): boolean;
+/** Unlocks a kind 23195 event */
+export declare function unlockWalletResponse(response: NostrEvent, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<WalletResponse | undefined | null>;
+/** Gets the wallet response from a kind 23195 event */
+export declare function getWalletResponse(response: NostrEvent): WalletResponse | undefined | null;
+/** Returns the client pubkey of client this response is for */
+export declare function getWalletResponseClientPubkey(response: NostrEvent): string | undefined;
+/** Returns the request id of the request this response is for */
+export declare function getWalletResponseRequestId(response: NostrEvent): string | undefined;

package/dist/helpers/response.js

@@ -0,0 +1,35 @@
+import { getHiddenContent, getOrComputeCachedValue, getTagValue, isHiddenContentLocked, isNIP04Encrypted, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+export const WALLET_RESPONSE_KIND = 23195;
+// Set the encryption method to use for response kind
+setHiddenContentEncryptionMethod(WALLET_RESPONSE_KIND, "nip04");
+/** A symbol used to cache the wallet response on the event */
+export const WalletResponseSymbol = Symbol("wallet-response");
+/** Checks if a kind 23195 event is locked */
+export function isWalletResponseLocked(response) {
+    return isHiddenContentLocked(response);
+}
+/** Unlocks a kind 23195 event */
+export async function unlockWalletResponse(response, signer, override) {
+    const encryption = override ?? (!isNIP04Encrypted(response.content) ? "nip44" : "nip04");
+    await unlockHiddenContent(response, signer, encryption);
+    return getWalletResponse(response);
+}
+/** Gets the wallet response from a kind 23195 event */
+export function getWalletResponse(response) {
+    if (isWalletResponseLocked(response))
+        return undefined;
+    return getOrComputeCachedValue(response, WalletResponseSymbol, () => {
+        const content = getHiddenContent(response);
+        if (!content)
+            return null;
+        return JSON.parse(content);
+    });
+}
+/** Returns the client pubkey of client this response is for */
+export function getWalletResponseClientPubkey(response) {
+    return getTagValue(response, "p");
+}
+/** Returns the request id of the request this response is for */
+export function getWalletResponseRequestId(response) {
+    return getTagValue(response, "e");
+}

package/dist/helpers/support.d.ts

@@ -0,0 +1,34 @@
+import { NostrEvent } from "nostr-tools";
+import { WalletConnectEncryptionMethod } from "./encryption.js";
+import { NotificationType as NotificationType } from "./notification.js";
+export declare const WALLET_INFO_KIND = 13194;
+/** A symbol used to cache the wallet info on the event */
+export declare const WalletInfoSymbol: unique symbol;
+export type WalletMethod = "pay_invoice" | "multi_pay_invoice" | "pay_keysend" | "multi_pay_keysend" | "make_invoice" | "lookup_invoice" | "list_transactions" | "get_balance" | "get_info";
+/** Wallet service capabilities and information */
+export interface WalletSupport {
+    /** List of supported methods for this wallet service */
+    methods: WalletMethod[];
+    /** List of supported encryption methods */
+    encryption: WalletConnectEncryptionMethod[];
+    /** List of supported notifications, optional */
+    notifications?: NotificationType[];
+}
+/** Gets the wallet info from a kind 13194 event */
+export declare function getWalletSupport(info: NostrEvent): WalletSupport | null;
+/** Gets the encryption methods from a wallet info event */
+export declare function getEncryptionMethods(info: NostrEvent | WalletSupport): WalletConnectEncryptionMethod[];
+/** Checks if the wallet service supports a specific encryption method */
+export declare function supportsEncryption(info: NostrEvent | WalletSupport, encryption: WalletConnectEncryptionMethod): boolean;
+/** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
+export declare function getPreferredEncryption(info: NostrEvent | WalletSupport): WalletConnectEncryptionMethod;
+/** Checks if the wallet service supports a specific method */
+export declare function supportsMethod(info: NostrEvent | WalletSupport, method: WalletMethod): boolean;
+/** Checks if the wallet service supports notifications */
+export declare function supportsNotifications(info: NostrEvent | WalletSupport): boolean;
+/** Checks if the wallet service supports a specific notification type */
+export declare function supportsNotificationType(info: NostrEvent | WalletSupport, notificationType: NotificationType): boolean;
+/** Gets all supported methods from the wallet info */
+export declare function getSupportedMethods(info: NostrEvent | WalletSupport): WalletMethod[];
+/** Gets all supported notifications from the wallet info */
+export declare function getSupportedNotifications(info: NostrEvent | WalletSupport): NotificationType[];

package/dist/helpers/support.js

@@ -0,0 +1,97 @@
+import { getOrComputeCachedValue, getTagValue, isEvent } from "applesauce-core/helpers";
+export const WALLET_INFO_KIND = 13194;
+/** A symbol used to cache the wallet info on the event */
+export const WalletInfoSymbol = Symbol("wallet-info");
+/** Gets the wallet info from a kind 13194 event */
+export function getWalletSupport(info) {
+    if (info.kind !== WALLET_INFO_KIND)
+        return null;
+    return getOrComputeCachedValue(info, WalletInfoSymbol, () => {
+        const content = info.content.trim();
+        if (!content)
+            return null;
+        // Parse methods from content (space-separated)
+        const contentParts = content.split(/\s+/);
+        const methods = contentParts
+            .filter((part) => [
+            "pay_invoice",
+            "multi_pay_invoice",
+            "pay_keysend",
+            "multi_pay_keysend",
+            "make_invoice",
+            "lookup_invoice",
+            "list_transactions",
+            "get_balance",
+            "get_info",
+            "notifications",
+        ].includes(part))
+            .filter((part) => part !== "notifications");
+        // Parse encryption methods from encryption tag
+        const encryptionTag = getTagValue(info, "encryption");
+        const encryption = encryptionTag
+            ? encryptionTag
+                .split(/\s+/)
+                .filter((method) => method === "nip44_v2" || method === "nip04")
+            : ["nip04"]; // Default to nip04 if no encryption tag is present
+        // Parse notifications from notifications tag
+        const notificationsTag = getTagValue(info, "notifications");
+        const notifications = notificationsTag
+            ? notificationsTag
+                .split(/\s+/)
+                .filter((notif) => notif === "payment_received" || notif === "payment_sent")
+            : undefined;
+        return {
+            methods,
+            encryption,
+            notifications,
+        };
+    });
+}
+/** Gets the encryption methods from a wallet info event */
+export function getEncryptionMethods(info) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return walletInfo?.encryption ?? [];
+}
+/** Checks if the wallet service supports a specific encryption method */
+export function supportsEncryption(info, encryption) {
+    const encryptionMethods = getEncryptionMethods(info);
+    return encryptionMethods.includes(encryption);
+}
+/** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
+export function getPreferredEncryption(info) {
+    const encryptionMethods = getEncryptionMethods(info);
+    if (encryptionMethods.length === 0)
+        return "nip04";
+    // Prefer nip44_v2 over nip04
+    if (encryptionMethods.includes("nip44_v2"))
+        return "nip44_v2";
+    if (encryptionMethods.includes("nip04"))
+        return "nip04";
+    // Absence of this tag implies that the wallet only supports nip04.
+    return "nip04";
+}
+/** Checks if the wallet service supports a specific method */
+export function supportsMethod(info, method) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return walletInfo?.methods.includes(method) ?? false;
+}
+/** Checks if the wallet service supports notifications */
+export function supportsNotifications(info) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return (walletInfo?.notifications?.length ?? 0) > 0;
+}
+/** Checks if the wallet service supports a specific notification type */
+export function supportsNotificationType(info, notificationType) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return walletInfo?.notifications?.includes(notificationType) ?? false;
+}
+/** Gets all supported methods from the wallet info */
+export function getSupportedMethods(info) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return walletInfo?.methods ?? [];
+}
+/** Gets all supported notifications from the wallet info */
+export function getSupportedNotifications(info) {
+    const walletInfo = isEvent(info) ? getWalletSupport(info) : info;
+    return walletInfo?.notifications ?? [];
+}

package/dist/helpers/tokens.d.ts

@@ -0,0 +1,58 @@
+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 type TokenContent = {
+    /** Cashu mint for the proofs */
+    mint: string;
+    /** Cashu proofs */
+    proofs: {
+        amount: number;
+        secret: string;
+        C: string;
+        id: string;
+    }[];
+    /** The cashu unit */
+    unit?: string;
+    /** tokens that were destroyed in the creation of this token (helps on wallet state transitions) */
+    del: string[];
+};
+export declare const TokenContentSymbol: unique symbol;
+/**
+ * Returns the decrypted and parsed details of a 7375 token event
+ * @throws
+ */
+export declare function getTokenContent(token: NostrEvent): TokenContent | undefined;
+/** Returns if token details are locked */
+export declare function isTokenContentLocked(token: NostrEvent): boolean;
+/** Decrypts a k:7375 token event */
+export declare function unlockTokenContent(token: NostrEvent, signer: HiddenContentSigner): Promise<TokenContent>;
+/** Removes the unencrypted hidden content */
+export declare function lockTokenContent(token: NostrEvent): void;
+/**
+ * Gets the totaled amount of proofs in a token event
+ * @param token The token event to calculate the total
+ */
+export declare function getTokenProofsTotal(token: NostrEvent): number | undefined;
+/**
+ * Selects oldest tokens and proofs that total up to more than the min amount
+ * @throws
+ */
+export declare function dumbTokenSelection(tokens: NostrEvent[], minAmount: number, mint?: string): {
+    events: NostrEvent[];
+    proofs: Proof[];
+};
+/**
+ * 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;