applesauce-wallet-connect 0.0.0-next-20250808173123

package/dist/blueprints/tokens.js

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

package/dist/blueprints/wallet.d.ts

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

package/dist/blueprints/wallet.js

@@ -0,0 +1,11 @@
+import { blueprint } from "applesauce-factory";
+import { WALLET_BACKUP_KIND, WALLET_KIND } from "../helpers/wallet.js";
+import { setBackupContent, setMints, setPrivateKey } 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);
+}
+/** A blueprint that creates a new 375 wallet backup event */
+export function WalletBackupBlueprint(wallet) {
+    return blueprint(WALLET_BACKUP_KIND, setBackupContent(wallet));
+}

package/dist/blueprints/zaps.d.ts

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

package/dist/blueprints/zaps.js

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

package/dist/helpers/animated-qr.d.ts

@@ -0,0 +1,30 @@
+import { Token } from "@cashu/cashu-ts";
+import { Observable } from "rxjs";
+/** Preset speeds for the animated qr code */
+export declare const ANIMATED_QR_INTERVAL: {
+    SLOW: number;
+    MEDIUM: number;
+    FAST: number;
+};
+/** Presets for fragment length for animated qr code */
+export declare const ANIMATED_QR_FRAGMENTS: {
+    SHORT: number;
+    MEDIUM: number;
+    LONG: number;
+};
+export type SendAnimatedOptions = {
+    /**
+     * The interval between the parts ( 150 - 500 )
+     * @default 150
+     */
+    interval?: number;
+    /**
+     * max fragment length ( 50 - 200 )
+     * @default 100
+     */
+    fragmentLength?: number;
+};
+/** Creates an observable that iterates through a multi-part animated qr code */
+export declare function sendAnimated(token: Token | string, options?: SendAnimatedOptions): Observable<string>;
+/** Creates an observable that completes with decoded token */
+export declare function receiveAnimated(input: Observable<string>): Observable<string | number>;

package/dist/helpers/animated-qr.js

@@ -0,0 +1,71 @@
+import { getEncodedTokenV4 } from "@cashu/cashu-ts";
+import { UR, URDecoder, UREncoder } from "@gandlaf21/bc-ur/dist/lib/es6/index.js";
+import { defer, filter, interval, map, Observable, shareReplay } from "rxjs";
+/** Preset speeds for the animated qr code */
+export const ANIMATED_QR_INTERVAL = {
+    SLOW: 500,
+    MEDIUM: 250,
+    FAST: 150,
+};
+/** Presets for fragment length for animated qr code */
+export const ANIMATED_QR_FRAGMENTS = {
+    SHORT: 50,
+    MEDIUM: 100,
+    LONG: 150,
+};
+/** Creates an observable that iterates through a multi-part animated qr code */
+export function sendAnimated(token, options) {
+    // start the stream as soon as there is subscriber
+    return defer(() => {
+        let str = typeof token === "string" ? token : getEncodedTokenV4(token);
+        let utf8 = new TextEncoder();
+        let buffer = utf8.encode(str);
+        let ur = UR.from(buffer);
+        let encoder = new UREncoder(ur, options?.fragmentLength ?? 100, 0);
+        return interval(options?.interval ?? ANIMATED_QR_INTERVAL.FAST).pipe(map(() => encoder.nextPart()));
+    });
+}
+/** An operator that decodes UR, emits progress percent and completes with final result or error */
+function urDecoder() {
+    return (source) => new Observable((observer) => {
+        const decoder = new URDecoder();
+        return source.subscribe((part) => {
+            decoder.receivePart(part);
+            if (decoder.isComplete() && decoder.isSuccess()) {
+                // emit progress
+                const progress = decoder.estimatedPercentComplete();
+                observer.next(progress);
+                // emit result
+                const ur = decoder.resultUR();
+                const decoded = ur.decodeCBOR();
+                const utf8 = new TextDecoder();
+                const tokenStr = utf8.decode(decoded);
+                observer.next(tokenStr);
+                // complete
+                observer.complete();
+            }
+            else if (decoder.isError()) {
+                // emit error
+                const reason = decoder.resultError();
+                observer.error(new Error(reason));
+            }
+            else {
+                // emit progress
+                const progress = decoder.estimatedPercentComplete();
+                observer.next(progress);
+            }
+        });
+    });
+}
+/** Creates an observable that completes with decoded token */
+export function receiveAnimated(input) {
+    return input.pipe(
+    // convert to lower case
+    map((str) => str.toLowerCase()), 
+    // filter out non UR parts
+    filter((str) => str.startsWith("ur:bytes")), 
+    // decode UR and complete
+    urDecoder(), 
+    // only run one decoder
+    shareReplay(1));
+}

package/dist/helpers/connect-uri.d.ts

@@ -0,0 +1,12 @@
+export interface WalletConnectURI {
+    service: string;
+    relays: string[];
+    secret: string;
+}
+/**
+ * Parses a nostr+walletconnect URI
+ * @throws {Error} if the connection string is invalid
+ */
+export declare function parseWalletConnectURI(connectionString: string): WalletConnectURI;
+/** Creates a nostr+walletconnect URI from a WalletConnectURI object */
+export declare function createWalletConnectURI(parts: WalletConnectURI): string;

package/dist/helpers/connect-uri.js

@@ -0,0 +1,23 @@
+/**
+ * Parses a nostr+walletconnect URI
+ * @throws {Error} if the connection string is invalid
+ */
+export function parseWalletConnectURI(connectionString) {
+    const { host, pathname, searchParams, protocol } = new URL(connectionString);
+    if (protocol !== "nostr+walletconnect:")
+        throw new Error("invalid wallet connect uri protocol");
+    const service = pathname || host;
+    const relays = searchParams.getAll("relay");
+    const secret = searchParams.get("secret");
+    if (!service || relays.length === 0 || !secret)
+        throw new Error("invalid connection string");
+    return { service, relays, secret };
+}
+/** Creates a nostr+walletconnect URI from a WalletConnectURI object */
+export function createWalletConnectURI(parts) {
+    const url = new URL(`nostr+walletconnect://${parts.service}`);
+    for (const relay of parts.relays)
+        url.searchParams.append("relay", relay);
+    url.searchParams.append("secret", parts.secret);
+    return url.toString();
+}

package/dist/helpers/encryption.d.ts

@@ -0,0 +1,2 @@
+/** Supported encryption methods */
+export type WalletConnectEncryptionMethod = "nip44_v2" | "nip04";

package/dist/helpers/encryption.js

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

package/dist/helpers/error.d.ts

@@ -0,0 +1,55 @@
+/** NIP-47 error codes as defined in the specification */
+export type WalletErrorCode = "RATE_LIMITED" | "NOT_IMPLEMENTED" | "INSUFFICIENT_BALANCE" | "QUOTA_EXCEEDED" | "RESTRICTED" | "UNAUTHORIZED" | "INTERNAL" | "UNSUPPORTED_ENCRYPTION" | "PAYMENT_FAILED" | "NOT_FOUND" | "OTHER";
+/** Base class for all NIP-47 wallet connect errors */
+export declare abstract class WalletBaseError extends Error {
+    abstract readonly code: WalletErrorCode;
+    constructor(message: string);
+}
+/** The client is sending commands too fast. It should retry in a few seconds. */
+export declare class RateLimitedError extends WalletBaseError {
+    readonly code: "RATE_LIMITED";
+}
+/** The command is not known or is intentionally not implemented. */
+export declare class NotImplementedError extends WalletBaseError {
+    readonly code: "NOT_IMPLEMENTED";
+}
+/** The wallet does not have enough funds to cover a fee reserve or the payment amount. */
+export declare class InsufficientBalanceError extends WalletBaseError {
+    readonly code: "INSUFFICIENT_BALANCE";
+}
+/** The wallet has exceeded its spending quota. */
+export declare class QuotaExceededError extends WalletBaseError {
+    readonly code: "QUOTA_EXCEEDED";
+}
+/** This public key is not allowed to do this operation. */
+export declare class RestrictedError extends WalletBaseError {
+    readonly code: "RESTRICTED";
+}
+/** This public key has no wallet connected. */
+export declare class UnauthorizedError extends WalletBaseError {
+    readonly code: "UNAUTHORIZED";
+}
+/** An internal error. */
+export declare class InternalError extends WalletBaseError {
+    readonly code: "INTERNAL";
+}
+/** The encryption type of the request is not supported by the wallet service. */
+export declare class UnsupportedEncryptionError extends WalletBaseError {
+    readonly code: "UNSUPPORTED_ENCRYPTION";
+}
+/** The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar. */
+export declare class PaymentFailedError extends WalletBaseError {
+    readonly code: "PAYMENT_FAILED";
+}
+/** The invoice could not be found by the given parameters. */
+export declare class NotFoundError extends WalletBaseError {
+    readonly code: "NOT_FOUND";
+}
+/** Other error. */
+export declare class OtherError extends WalletBaseError {
+    readonly code: "OTHER";
+}
+/** Union type of all NIP-47 error classes */
+export type WalletErrorClass = RateLimitedError | NotImplementedError | InsufficientBalanceError | QuotaExceededError | RestrictedError | UnauthorizedError | InternalError | UnsupportedEncryptionError | PaymentFailedError | NotFoundError | OtherError;
+/** Factory function to create NWC error instances from error code and message */
+export declare function createWalletError(code: WalletErrorCode, message: string): WalletErrorClass;

package/dist/helpers/error.js

@@ -0,0 +1,81 @@
+/** Base class for all NIP-47 wallet connect errors */
+export class WalletBaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+/** The client is sending commands too fast. It should retry in a few seconds. */
+export class RateLimitedError extends WalletBaseError {
+    code = "RATE_LIMITED";
+}
+/** The command is not known or is intentionally not implemented. */
+export class NotImplementedError extends WalletBaseError {
+    code = "NOT_IMPLEMENTED";
+}
+/** The wallet does not have enough funds to cover a fee reserve or the payment amount. */
+export class InsufficientBalanceError extends WalletBaseError {
+    code = "INSUFFICIENT_BALANCE";
+}
+/** The wallet has exceeded its spending quota. */
+export class QuotaExceededError extends WalletBaseError {
+    code = "QUOTA_EXCEEDED";
+}
+/** This public key is not allowed to do this operation. */
+export class RestrictedError extends WalletBaseError {
+    code = "RESTRICTED";
+}
+/** This public key has no wallet connected. */
+export class UnauthorizedError extends WalletBaseError {
+    code = "UNAUTHORIZED";
+}
+/** An internal error. */
+export class InternalError extends WalletBaseError {
+    code = "INTERNAL";
+}
+/** The encryption type of the request is not supported by the wallet service. */
+export class UnsupportedEncryptionError extends WalletBaseError {
+    code = "UNSUPPORTED_ENCRYPTION";
+}
+/** The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar. */
+export class PaymentFailedError extends WalletBaseError {
+    code = "PAYMENT_FAILED";
+}
+/** The invoice could not be found by the given parameters. */
+export class NotFoundError extends WalletBaseError {
+    code = "NOT_FOUND";
+}
+/** Other error. */
+export class OtherError extends WalletBaseError {
+    code = "OTHER";
+}
+/** Factory function to create NWC error instances from error code and message */
+export function createWalletError(code, message) {
+    switch (code) {
+        case "RATE_LIMITED":
+            return new RateLimitedError(message);
+        case "NOT_IMPLEMENTED":
+            return new NotImplementedError(message);
+        case "INSUFFICIENT_BALANCE":
+            return new InsufficientBalanceError(message);
+        case "QUOTA_EXCEEDED":
+            return new QuotaExceededError(message);
+        case "RESTRICTED":
+            return new RestrictedError(message);
+        case "UNAUTHORIZED":
+            return new UnauthorizedError(message);
+        case "INTERNAL":
+            return new InternalError(message);
+        case "UNSUPPORTED_ENCRYPTION":
+            return new UnsupportedEncryptionError(message);
+        case "PAYMENT_FAILED":
+            return new PaymentFailedError(message);
+        case "NOT_FOUND":
+            return new NotFoundError(message);
+        case "OTHER":
+            return new OtherError(message);
+        default:
+            // This should never happen with proper typing, but provides a fallback
+            return new OtherError(message);
+    }
+}

package/dist/helpers/history.d.ts

@@ -0,0 +1,26 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+export declare const WALLET_HISTORY_KIND = 7376;
+export type HistoryDirection = "in" | "out";
+export type HistoryContent = {
+    /** The direction of the transaction, in = received, out = sent */
+    direction: HistoryDirection;
+    /** The amount of the transaction */
+    amount: number;
+    /** An array of token event ids created */
+    created: string[];
+    /** The mint that was spent from */
+    mint?: string;
+    /** The fee paid */
+    fee?: number;
+};
+export declare const HistoryContentSymbol: unique symbol;
+/** returns an array of redeemed event ids in a history event */
+export declare function getHistoryRedeemed(history: NostrEvent): string[];
+/** Checks if the history contents are locked */
+export declare function isHistoryContentLocked(history: NostrEvent): boolean;
+/** Returns the parsed content of a 7376 history event */
+export declare function getHistoryContent(history: NostrEvent): HistoryContent | undefined;
+/** Decrypts a wallet history event */
+export declare function unlockHistoryContent(history: NostrEvent, signer: HiddenContentSigner): Promise<HistoryContent>;
+export declare function lockHistoryContent(history: NostrEvent): void;

package/dist/helpers/history.js

@@ -0,0 +1,47 @@
+import { getHiddenTags, getOrComputeCachedValue, isETag, isHiddenContentLocked, isHiddenTagsLocked, lockHiddenTags, setHiddenTagsEncryptionMethod, unlockHiddenTags, } from "applesauce-core/helpers";
+export const WALLET_HISTORY_KIND = 7376;
+// Enable hidden content for wallet history kind
+setHiddenTagsEncryptionMethod(WALLET_HISTORY_KIND, "nip44");
+export const HistoryContentSymbol = Symbol.for("history-content");
+/** returns an array of redeemed event ids in a history event */
+export function getHistoryRedeemed(history) {
+    return history.tags.filter((t) => isETag(t) && t[3] === "redeemed").map((t) => t[1]);
+}
+/** Checks if the history contents are locked */
+export function isHistoryContentLocked(history) {
+    return isHiddenTagsLocked(history);
+}
+/** Returns the parsed content of a 7376 history event */
+export function getHistoryContent(history) {
+    if (isHistoryContentLocked(history))
+        return undefined;
+    return getOrComputeCachedValue(history, HistoryContentSymbol, () => {
+        const tags = getHiddenTags(history);
+        if (!tags)
+            throw new Error("History event is locked");
+        const direction = tags.find((t) => t[0] === "direction")?.[1];
+        if (!direction)
+            throw new Error("History event missing direction");
+        const amountStr = tags.find((t) => t[0] === "amount")?.[1];
+        if (!amountStr)
+            throw new Error("History event missing amount");
+        const amount = parseInt(amountStr);
+        if (!Number.isFinite(amount))
+            throw new Error("Failed to parse amount");
+        const mint = tags.find((t) => t[0] === "mint")?.[1];
+        const feeStr = tags.find((t) => t[0] === "fee")?.[1];
+        const fee = feeStr ? parseInt(feeStr) : undefined;
+        const created = tags.filter((t) => isETag(t) && t[3] === "created").map((t) => t[1]);
+        return { direction, amount, created, mint, fee };
+    });
+}
+/** Decrypts a wallet history event */
+export async function unlockHistoryContent(history, signer) {
+    if (isHiddenContentLocked(history))
+        await unlockHiddenTags(history, signer);
+    return getHistoryContent(history);
+}
+export function lockHistoryContent(history) {
+    Reflect.deleteProperty(history, HistoryContentSymbol);
+    lockHiddenTags(history);
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./connect-uri.js";
+export * from "./encryption.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./support.js";
+export * from "./notification.js";
+export * from "./encryption.js";

package/dist/helpers/index.js

@@ -0,0 +1,7 @@
+export * from "./connect-uri.js";
+export * from "./encryption.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./support.js";
+export * from "./notification.js";
+export * from "./encryption.js";

package/dist/helpers/info.d.ts

@@ -0,0 +1,34 @@
+import { NostrEvent } from "nostr-tools";
+import { EncryptionMethods } from "./encryption.js";
+import { WalletMethods } from "./methods.js";
+import { NotificationTypes } 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;
+/** Wallet service capabilities and information */
+export interface WalletFeatures {
+    /** List of supported methods for this wallet service */
+    methods: WalletMethods[];
+    /** List of supported encryption methods */
+    encryption: EncryptionMethods[];
+    /** List of supported notifications, optional */
+    notifications?: NotificationTypes[];
+}
+/** Gets the wallet info from a kind 13194 event */
+export declare function getWalletFeatures(info: NostrEvent): WalletFeatures | null;
+/** Gets the encryption methods from a wallet info event */
+export declare function getEncryptionMethods(info: NostrEvent | WalletFeatures): EncryptionMethods[];
+/** Checks if the wallet service supports a specific encryption method */
+export declare function supportsEncryption(info: NostrEvent | WalletFeatures, encryption: EncryptionMethods): boolean;
+/** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
+export declare function getPreferredEncryption(info: NostrEvent | WalletFeatures): EncryptionMethods;
+/** Checks if the wallet service supports a specific method */
+export declare function supportsMethod(info: NostrEvent | WalletFeatures, method: WalletMethods): boolean;
+/** Checks if the wallet service supports notifications */
+export declare function supportsNotifications(info: NostrEvent | WalletFeatures): boolean;
+/** Checks if the wallet service supports a specific notification type */
+export declare function supportsNotificationType(info: NostrEvent | WalletFeatures, notificationType: NotificationTypes): boolean;
+/** Gets all supported methods from the wallet info */
+export declare function getSupportedMethods(info: NostrEvent | WalletFeatures): WalletMethods[];
+/** Gets all supported notifications from the wallet info */
+export declare function getSupportedNotifications(info: NostrEvent | WalletFeatures): NotificationTypes[];

package/dist/helpers/info.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 getWalletFeatures(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) ? getWalletFeatures(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) ? getWalletFeatures(info) : info;
+    return walletInfo?.methods.includes(method) ?? false;
+}
+/** Checks if the wallet service supports notifications */
+export function supportsNotifications(info) {
+    const walletInfo = isEvent(info) ? getWalletFeatures(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) ? getWalletFeatures(info) : info;
+    return walletInfo?.notifications?.includes(notificationType) ?? false;
+}
+/** Gets all supported methods from the wallet info */
+export function getSupportedMethods(info) {
+    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
+    return walletInfo?.methods ?? [];
+}
+/** Gets all supported notifications from the wallet info */
+export function getSupportedNotifications(info) {
+    const walletInfo = isEvent(info) ? getWalletFeatures(info) : info;
+    return walletInfo?.notifications ?? [];
+}

package/dist/helpers/methods.d.ts

@@ -0,0 +1 @@
+export type WalletMethods = "pay_invoice" | "multi_pay_invoice" | "pay_keysend" | "multi_pay_keysend" | "make_invoice" | "lookup_invoice" | "list_transactions" | "get_balance" | "get_info";

package/dist/helpers/methods.js

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

package/dist/helpers/notification.d.ts

@@ -0,0 +1,28 @@
+import { HiddenContentSigner } from "applesauce-core/helpers";
+import { NostrEvent } from "nostr-tools";
+import { Transaction } from "./response.js";
+export declare const WALLET_NOTIFICATION_KIND = 23197;
+export declare const WALLET_LEGACY_NOTIFICATION_KIND = 23196;
+/** A symbol used to cache the wallet notification on the event */
+export declare const WalletNotificationSymbol: unique symbol;
+/** Supported notification types */
+export type NotificationType = "payment_received" | "payment_sent";
+/** Base notification structure */
+export interface BaseNotification<TNotificationType extends NotificationType, TNotification> {
+    /** Indicates the structure of the notification field */
+    notification_type: TNotificationType;
+    /** Notification data */
+    notification: TNotification;
+}
+/** Payment received notification */
+export type PaymentReceivedNotification = BaseNotification<"payment_received", Transaction>;
+/** Payment sent notification */
+export type PaymentSentNotification = BaseNotification<"payment_sent", Transaction>;
+/** Union type for all NIP-47 notification types */
+export type WalletNotification = PaymentReceivedNotification | PaymentSentNotification;
+/** Checks if a kind 23196 or 23197 event is locked */
+export declare function isWalletNotificationLocked(notification: NostrEvent): boolean;
+/** Unlocks a kind 23196 or 23197 event */
+export declare function unlockWalletNotification(notification: NostrEvent, signer: HiddenContentSigner): Promise<WalletNotification | undefined | null>;
+/** Gets the wallet notification from a kind 23196 or 23197 event */
+export declare function getWalletNotification(notification: NostrEvent): WalletNotification | undefined | null;

package/dist/helpers/notification.js

@@ -0,0 +1,28 @@
+import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+export const WALLET_NOTIFICATION_KIND = 23197;
+export const WALLET_LEGACY_NOTIFICATION_KIND = 23196;
+/** A symbol used to cache the wallet notification on the event */
+export const WalletNotificationSymbol = Symbol("wallet-notification");
+// Setup the encryption method to use for notification kinds
+setHiddenContentEncryptionMethod(WALLET_NOTIFICATION_KIND, "nip44");
+setHiddenContentEncryptionMethod(WALLET_LEGACY_NOTIFICATION_KIND, "nip04");
+/** Checks if a kind 23196 or 23197 event is locked */
+export function isWalletNotificationLocked(notification) {
+    return isHiddenContentLocked(notification);
+}
+/** Unlocks a kind 23196 or 23197 event */
+export async function unlockWalletNotification(notification, signer) {
+    await unlockHiddenContent(notification, signer);
+    return getWalletNotification(notification);
+}
+/** Gets the wallet notification from a kind 23196 or 23197 event */
+export function getWalletNotification(notification) {
+    if (isWalletNotificationLocked(notification))
+        return undefined;
+    return getOrComputeCachedValue(notification, WalletNotificationSymbol, () => {
+        const content = getHiddenContent(notification);
+        if (!content)
+            return null;
+        return JSON.parse(content);
+    });
+}